Метод считывания и метод set, указатели или ссылки и хороший синтаксис для использования в C++?

Джонатан, какой компилятор вы используете? Есть большая вероятность, что shared_ptr уже поставляется с ним как часть реализации TR1 компилятора.

В дополнение к другим ответам, если вы выберете ссылки для получателя, не t напишите это, как в вашем примере:

YourClass &Member(){
   return *this->pMember;
}

Ваш геттер фактически разрешает установку, как в instance-> Member () = YourClass (); и, таким образом, обходит ваш установщик. Это может быть запрещено, если YourClass не копируется, но это еще одна вещь, о которой следует помнить. Другой недостаток - геттер не является константой.

Вместо этого напишите свой получатель следующим образом:

const YourClass &Member() const {
   return *this->pMember;
}

Ваш код выглядит так, как будто вы привыкли к другому языку - в C ++ использование this-> x (например) относительно необычно. Когда код вообще хорошо написан, используется аксессор или мутатор.

Хотя я довольно необычен в этом конкретном отношении, я сделаю запись (еще раз), говоря, что принуждение клиентского кода использовать непосредственный аксессуар или мутатор - плохая идея. Если у вас действительно есть ситуация, когда клиентский код имеет смысл манипулировать значением в вашем объекте, тогда клиентский код должен использовать обычное присвоение для чтения и / или записи этого значения.

Когда / если вам нужно контролировать, какое значение назначен, перегрузка оператора позволяет вам взять этот контроль, не заставляя уродливый синтаксис получения / установки в клиентском коде. В частности, вам нужен прокси-класс (или шаблон класса). Просто для одного примера, одна из наиболее распространенных ситуаций, когда людям нужны функции get / set, - это что-то вроде числа, которое должно быть ограничено определенным диапазоном. setXXX проверяет, находится ли новое значение в диапазоне, а getXXX возвращает значение.

Если вы этого хотите, (довольно) простой шаблон может сделать гораздо больше. чисто:

template <class T, class less=std::less<T> >
class bounded {
    const T lower_, upper_;
    T val_;

    bool check(T const &value) {
        return less()(value, lower_) || less()(upper_, value);
    }

    void assign(T const &value) {
        if (check(value))
            throw std::domain_error("Out of Range");
        val_ = value;
    }

public:
    bounded(T const &lower, T const &upper) 
        : lower_(lower), upper_(upper) {}

    bounded(bounded const &init) 
        : lower_(init.lower), upper_(init.upper)
    { 
        assign(init); 
    }

    bounded &operator=(T const &v) { assign(v);  return *this; }

    operator T() const { return val_; }

    friend std::istream &operator>>(std::istream &is, bounded &b) {
        T temp;
        is >> temp;

        if (b.check(temp))
            is.setstate(std::ios::failbit);
        else
            b.val_ = temp;
        return is;
    }
};

Это также делает код намного ближе к самодокументированию - например, когда вы объявляете объект вроде: bounded (1, 1024); , сразу становится очевидным, что намерение является целым числом в диапазоне от 1 до 1024. Единственная часть, которую кто-то может найти под вопросом, - это то, входит ли 1 и / или 1024 в диапазон. Это значительно отличается от определения int в классе и ожидания, что каждый, кто когда-либо смотрит на класс, поймет, что они должны использовать setXXX для обеспечения некоторого (на тот момент неизвестного) набора границ для значений, которые могут быть назначено.

Когда вы встраиваете одну из них в класс, вы делаете ее общедоступной переменной, и диапазон по-прежнему применяется. В клиентском коде нет реальных аргументов в пользу синтаксиса - вы просто назначаете общедоступную переменную, как и любую другую - с незначительной детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

и ожидая, что все, кто когда-либо посмотрит на класс, поймут, что они должны использовать setXXX для обеспечения некоторого (на тот момент неизвестного) набора границ для значений, которые могут быть назначены.

Когда вы вставляете одно из них в класс, вы делаете его общедоступной переменной, и диапазон по-прежнему применяется. В клиентском коде нет реальных аргументов в пользу синтаксиса - вы просто назначаете общедоступную переменную, как и любую другую - с незначительной детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

и ожидая, что все, кто когда-либо посмотрит на класс, поймут, что они должны использовать setXXX для обеспечения некоторого (на тот момент неизвестного) набора границ для значений, которые могут быть назначены.

Когда вы вставляете одно из них в класс, вы делаете его общедоступной переменной, и диапазон по-прежнему применяется. В клиентском коде нет реальных аргументов в пользу синтаксиса - вы просто назначаете общедоступную переменную, как и любую другую - с незначительной детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указывать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

предполагается использовать setXXX для принудительного применения некоторого (на тот момент неизвестного) набора границ для значений, которые могут быть присвоены.

Когда вы встраиваете одно из них в класс, вы делаете его общедоступной переменной, и диапазон все еще применяется. В клиентском коде нет реальных аргументов в пользу синтаксиса - вы просто назначаете общедоступную переменную, как и любую другую - с незначительной детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указывать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

предполагается использовать setXXX для принудительного применения некоторого (на тот момент неизвестного) набора границ для значений, которые могут быть присвоены.

Когда вы встраиваете одно из них в класс, вы делаете его общедоступной переменной, и диапазон все еще применяется. В клиентском коде нет реальных аргументов в пользу синтаксиса - вы просто назначаете общедоступную переменную, как и любую другую - с незначительной детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

Нет никакого реального аргумента в пользу синтаксиса - вы просто присваиваете общедоступную переменную, как и любую другую - с незначительной детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указывать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

Нет никакого реального аргумента по поводу синтаксиса - вы просто присваиваете общедоступную переменную, как и любую другую - с небольшой детализацией, заключающейся в том, что попытка присвоить значение, выходящее за пределы допустимого диапазона, вызовет исключение. Теоретически класс, вероятно, должен принимать параметр-шаблон политики, чтобы точно указывать, что он делает в этом случае, но у меня никогда не было реальной причины беспокоиться об этом.

Лучше всего предоставить клиенту реальный объектно-ориентированный интерфейс, скрывающий детали реализации. Геттеры и сеттеры не являются ОО.

в чем разница между ними?

Ссылка - это псевдоним вещи (это это вещь *). Указатель - это адрес вещи. Если есть шанс, что то, на что указывает, не будет, тогда вы, вероятно, не захотите возвращать ссылки. Ссылки говорят вызывающему: «Я дам вам псевдоним, который будет существовать, когда я верну его вам». На самом деле нет никакого способа проверить ссылку, чтобы узнать, действительно ли то, что лежит в основе.

С помощью указателя семантически вы подразумеваете, что вызывающий может пожелать проверить, существует ли элемент Member перед его использованием. Обычно это делается с проверкой NULL.

В конечном итоге "правильного" ответа не существует. Это зависит от контракта класса и от того, хочет ли вызывающий / должен / хочет проверить, является ли "Член"

+1, чтобы задать вопрос об использовании сеттеров и геттеров. Если вы должны их использовать и иметь возможность нулевого значения, рассмотрите возможность использования boost :: shared_ptr. Таким образом, владение осуществляется за вас.

Как говорили другие, используйте указатели, если возможно значение null.

В большинстве случаев , По возможности я предпочитаю использовать ссылки. Лично в моем коде мне нравится использовать различие между указателями и ссылками для обозначения владения сигналом. Я думаю, что вызовы со ссылками - это «одалживание» объекта другой функции или классу. Исходный класс, который передал или вернул ссылку, по-прежнему владеет ею и отвечает за ее создание, обслуживание и очистку. Когда мой код передает неконстантный указатель, с другой стороны, это обычно означает, что происходит какая-то передача или разделение прав собственности со всеми вытекающими отсюда обязанностями.

(И да, я обычно использую умные указатели . Это похоже на ссылки в моей голове. Я говорю о коде более низкого уровня, чем здесь.)

Мне нравится использовать различие между указателями и ссылками для обозначения владения сигналом. Я думаю, что вызовы со ссылками - это «одалживание» объекта другой функции или классу. Исходный класс, который передал или вернул ссылку, по-прежнему владеет ею и отвечает за ее создание, обслуживание и очистку. С другой стороны, когда мой код передает неконстантный указатель, это обычно означает, что происходит какая-то передача или разделение прав собственности со всеми вытекающими отсюда обязанностями.

(И да, я обычно использую умные указатели . Это похоже на ссылки в моей голове. Я говорю о коде более низкого уровня, чем здесь.)

Мне нравится использовать различие между указателями и ссылками для обозначения владения сигналом. Я думаю, что вызовы со ссылками - это «одалживание» объекта другой функции или классу. Исходный класс, который передал или вернул ссылку, по-прежнему владеет ею и отвечает за ее создание, обслуживание и очистку. С другой стороны, когда мой код передает неконстантный указатель, это обычно означает, что происходит какая-то передача или разделение прав собственности со всеми вытекающими отсюда обязанностями.

(И да, я обычно использую умные указатели . Это похоже на ссылки в моей голове. Я говорю о коде более низкого уровня, чем здесь.)

и отвечает за его создание, обслуживание и очистку. С другой стороны, когда мой код передает неконстантный указатель, это обычно означает, что происходит какая-то передача или разделение прав собственности со всеми вытекающими отсюда обязанностями.

(И да, я обычно использую умные указатели . Это похоже на ссылки в моей голове. Я говорю о коде более низкого уровня, чем здесь.)

и отвечает за его создание, обслуживание и очистку. С другой стороны, когда мой код передает неконстантный указатель, это обычно означает, что происходит какая-то передача или разделение прав собственности со всеми вытекающими отсюда обязанностями.

(И да, я обычно использую умные указатели . Это похоже на ссылки в моей голове. Я говорю о коде более низкого уровня, чем здесь.)