C ++: доступ к постоянным переменным-членам через класс или экземпляр?

Что касается первого вопроса, помимо вопроса стиля (он делает очевидным, что это переменная класса и не имеет связанного объекта), Фред Ларсен в комментариях к вопросу ссылается на предыдущий вопрос. Прочтите Ответ Адама Розенталя на очень вескую причину, по которой вы хотите быть осторожными с этим. (Я бы проголосовал за Фреда, если бы он опубликовал его в качестве ответа, но я не могу поверить в то, где это должно быть. Я проголосовал за Адама.)

Что касается вашего второго вопроса:

Почему я должен повторять часть "const double" в моем файле cpp?

Вы должны повторить тип в первую очередь как деталь реализации: это то, как компилятор C ++ анализирует объявление. Это не совсем идеальный вариант для локальных переменных, и C ++ 1x (ранее C ++ 0x) использует ключевое слово auto, чтобы избежать повторения для обычных функциональных переменных.

Итак, это:

vector<string> v;
vector<string>::iterator it = v.begin();

может стать таким:

vector<string> v;
auto it = v.begin();

Нет четкой причины, по которой это не может работать и со статикой, поэтому в вашем случае thos:

const double Foo::d = 42;

вполне может стать этим.

static Foo::d = 42;

Ключ в том, чтобы иметь какой-нибудь способ идентифицировать это как объявление.

Заметьте, я не говорю ясной причины: грамматика C ++ - живая легенда: чрезвычайно трудно охватить все ее крайние случаи. Я не думаю, что сказанное выше неоднозначно, но может быть. Если это не так, они могли бы добавить это к языку. Расскажите им об этом ... для C ++ 2x: /.

Я бы предпочел Foo::ZERO inst.ZERO, потому что он более ясно показывает, что происходит. Однако в методе класса Foo я бы просто использовал ZERO.

Что касается вопроса о бонусе, const просто является частью полного типа.

Учитывая, что вы объявляете их статическими и делаете их константами класса, я бы использовал Foo :: Zero, чтобы сообщить о намерениях случайному, а не случайному читателю вашего кода.

Я бы также заменил все имена констант в верхнем регистре, то есть превратил Foo :: ZERO в Foo :: Zero. Обычное соглашение для макросов препроцессора заключается в том, чтобы называть их заглавными буквами, а использование аналогичной схемы именования для ваших констант C ++ вызывает проблемы, потому что препроцессор может просто пропустить ваши константы C ++, и вы получите очень интересные сообщения об ошибках.

Я бы использовал Foo :: ZERO, но это только я. Особенно, если вы производите от Foo, что сбивает с толку.

Что касается вашего второго вопроса, вам нужно создать память для двойного значения, и это происходит в модуле реализации.

Я думаю, что единственный тип, для которого вам не нужно создавать память, - это интегральный тип const. Затем вы можете поместить значение в файл заголовка. Но поскольку у него нет адреса, вы не сможете передать его по ссылке на функцию, если не поместите определение в файл .cpp. (Похоже, это так и работает с gcc).

Неважно, какую форму вы используете в своем примере. Оба они означают одно и то же. Я бы предпочел использовать классовый метод в целом, потому что у вас не всегда может быть экземпляр, удобный для использования оператора точки.

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

Что касается вашего бонусного вопроса, то язык таков. Всегда нужно объявлять полный тип. Возможно, вам стоит задать этот вопрос в отдельном вопросе.

лично я бы использовал анонимное перечисление. Хотя конечный результат точно такой же :)

Что касается ваших вопросов. Я определенно предпочитаю Foo :: Zero, потому что, глядя на него, очевидно, к чему вы обращаетесь. inst.Zero требует, чтобы вы заранее выяснили, какой тип inst.

Вы должны повторить тип данных, потому что так работает C ++. Точно так же, если вы написали следующее в заголовочном файле.

extern int foo;

Вам все равно нужно будет упомянуть

int foo

в файле CPP. Как упоминалось в pukku, вы объявляете переменную типа «const int». Таким образом, "const int" необходимо повторить в определении переменной.