Использование 'константы' для параметров функции

Все consts в Ваших примерах не имеют никакой цели. C++ является передачей значением по умолчанию, таким образом, функция получает копии тех ints и булевских переменных. Даже если функция действительно изменяет их, копия вызывающей стороны не затронута.

, Таким образом, я избежал бы дополнительного consts, потому что

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

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

Параметр константы полезен только, когда параметр передается ссылкой т.е. или ссылка или указатель. Когда компилятор видит параметр константы, он удостоверяется, что переменная, используемая в параметре, не изменяется в теле функции. Почему кто-либо хотел бы сделать параметром, передаваемым по значению как постоянный?:-)

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

причина использовать "константу" состоит в том при передаче чего-то большего (например, структура с большим количеством участников) ссылкой, в этом случае это гарантирует, что функция не может изменить его; или скорее компилятор будет жаловаться, пытаетесь ли Вы изменить его стандартным способом. Это препятствует тому, чтобы он был случайно изменен.

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

константа Использования, когда Вы хотите, чтобы что-то было неизменно - добавленная подсказка, которая описывает то, что делает Ваша функция и что ожидать. Я видел много API C, которые могли сделать с некоторыми из них, особенно, которые принимают струны до!

я был бы более склонен опустить ключевое слово константы в cpp файле, чем заголовок, но поскольку я ухаживаю к cut+paste за ними, они были бы сохранены в обоих местах. Я понятия не имею, почему компилятор признает, что, я предполагаю, что это - вещь компилятора. Лучшая практика должна определенно поместить Ваше ключевое слово константы в оба файла.

Я не поместил бы константу на параметры как этот - все уже знают что булевская переменная (в противоположность boolean&) является постоянным, так включает, это заставит людей думать, "ожидают, что?" или даже что Вы передаете параметр ссылкой.

Если параметр передается значением (и не ссылка), обычно нет большого различия, объявляется ли параметр как константа или не (если это не содержит ссылочного участника - не проблема для встроенных типов). Если параметр является ссылкой или указателем, обычно лучше защитить, сослался/указал на память, не сам указатель (я думаю, что Вы не можете сделать саму ссылку константа, не, что это имеет значение, хотя Вы не можете изменить рефери). Это кажется хорошей идеей защитить все, что Вы можете как константа. Можно опустить его без страха перед деланием ошибки, если параметрами являются просто ПЕРЕХОДНЫЕ ПРИСТАВКИ (включая встроенные типы) и нет никакого шанса того, что они изменялись далее вдоль дороги (например, в примере bool параметр).

я не знал о .h/.cpp различии в объявлении файла, но оно действительно имеет некоторый смысл. На уровне машинного кода ничто не "константа", поэтому если Вы объявляете функцию (в.h) как неконстанта, код совпадает с, если Вы объявляете его как константу (оптимизация в стороне). Однако это помогает Вам включить в список компилятор, что Вы не измените значение переменной в реализации функции (.ccp). Это могло бы прибыть удобное в случай, когда Вы наследовались интерфейсу, который позволяет изменение, но Вы не должны изменяться на параметр для достижения необходимой функциональности.

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

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

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

C++ имеет некоторый дополнительный багаж с идеей правильности константы, таким образом, это становится еще более важным.

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

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

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

В случае Вы упоминаете, он не влияет на вызывающие стороны Вашего API, который является, почему он обычно не делал (и не необходимо в заголовке). Это только влияет на реализацию Вашей функции.

Это не особенно плохая вещь сделать, но преимущества не являются настолько большими, учитывая, что это не влияет на Ваш API, и это добавляет ввод, таким образом, это обычно не делается.

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

константа должна быть предпочтена при передаче ссылкой, если цель функции не состоит в том, чтобы изменить переданное значение.

Наконец, функция, которая не изменяет текущий объект (это) может, и вероятно должно быть объявлено константой. Пример ниже:

int SomeClass::GetValue() const {return m_internalValue;}

Это - обещание не изменить объект, к которому применяется этот вызов. Другими словами, можно звонить:

const SomeClass* pSomeClass;
pSomeClass->GetValue();

, Если бы функция не была константой, это привело бы к предупреждению компилятора.

Отмечание параметров, передаваемых по значению 'константа' является определенно субъективной вещью.

Однако я на самом деле предпочитаю отмечать константу параметров, передаваемых по значению, точно так же, как в Вашем примере.

void func(const int n, const long l) { /* ... */ }

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

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

Однако для большей функции, это - форма документации реализации, и это осуществляется компилятором.

я могу быть уверен, делаю ли я некоторое вычисление с 'n' и 'l', я могу осуществить рефакторинг/переместить то вычисление без страха перед получением различного результата, потому что я пропустил место, где один или оба изменяются.

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

А-ч, жесткий. На одной стороне объявление является контрактом, и действительно не имеет смысла передавать аргумент константы значением. С другой стороны, при рассмотрении реализации функции Вы даете компилятору больше возможностей оптимизировать, если Вы объявляете постоянный аргумент.

Я использую константу на параметрах функции, которые являются ссылками (или указатели), которые находятся только [в] данных и не будут изменены функцией. Значение, когда цель использовать ссылку состоит в том, чтобы не копировать данные а не позволять изменять переданный параметр.

константа Помещения на булевской переменной b параметр в Вашем примере только помещает ограничение на реализацию и не способствует для интерфейса класса (хотя не изменение параметров обычно рекомендуется).

функциональная подпись для

void foo(int a);

и

void foo(const int a);

является тем же, которое объясняет Ваш.c и .h

Asaf

Я говорю константу Ваши параметры, передаваемые по значению.

Рассматривают эту ошибочную функцию:

bool isZero(int number)
{
  if (number = 0)  // whoops, should be number == 0
    return true;
  else
    return false;
}

, Если бы параметр числа был константой, компилятор остановил бы и предупредил бы нас об ошибке.

Когда я кодировал C++ для жизни I consted все, что я возможно мог. Используя константу отличный способ помочь компилятору помочь Вам. Например, луг константы Ваши возвращаемые значения метода может сохранить Вас от опечаток, таких как:

foo() = 42

, когда Вы имели в виду:

foo() == 42

, Если нечто () определяется для возврата ссылки неконстанты:

int& foo() { /* ... */ }

компилятор счастливо позволит Вам присвоить значение анонимному временному файлу, возвращенному вызовом функции. Создание его константа:

const int& foo() { /* ... */ }

Устраняет эту возможность.

константа должна была быть значением по умолчанию в C++. Как это:

int i = 5 ; // i is a constant

var int i = 5 ; // i is a real variable

Следующие две строки функционально эквивалентны:

int foo (int a);
int foo (const int a);

, Очевидно, Вы не будете в состоянии изменить a в теле foo, если оно определило второй путь, но нет никакого различия от внешней стороны.

то, Где const действительно пригождается, с параметрами указателя или ссылкой:

int foo (const BigStruct &a);
int foo (const BigStruct *a);

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

*: Если это не выбрасывает мыс константы, но это - другое сообщение.

Иногда (слишком часто!) Я должен распутать чужой код C++. И все мы знаем, что чужой код C++ является полной путаницей почти по определению:) Так первая вещь я делаю для дешифровки локального потока данных, помещается константа в каждом определении переменной, пока компилятор не начинает лаять. Это означает квалифицирующие константу аргументы значения также, потому что они - просто необычные локальные переменные, инициализированные вызывающей стороной.

А-ч, мне жаль, что переменные не были , константа по умолчанию и изменяемый требовалась для переменных неконстанты:)

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

Неправильно.

Это о самодокументировании Вашего кода и Ваших предположений.

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

Кроме того, поскольку кто-то упомянул ранее, это могло бы помогать компилятору оптимизировать вещи немного (хотя это - съемка общим планом).

Об оптимизации компилятора: http://www.gotw.ca/gotw/081.htm

. старые статьи "Гуру недели" на comp.lang.c ++. модерировались здесь здесь .

Соответствующая статья GOTW доступна на веб-сайте Херба Саттера здесь .