Различие аргумента функции как (интервал константы и) и (интервал и a) в C++
Я знаю, что, если Вы пишете пустой function_name (int& a), затем функционировать не сделает, локальная копия Вашей переменной передала как аргумент. Также встретились в литературе, что необходимо записать пустой function_name (интервал константы и a), чтобы сказать компилятор, что я не хочу, чтобы переменная, переданная как аргумент, была скопирована.
Так мой вопрос: то, что является различием с этим два случая (за исключением того, что "константа" гарантирует, что переменная передала, не будет изменено функцией!!!)???
7 ответов
Вы должны использовать const в подписи всякий раз, когда вам не нужно писать. Добавление const в подпись имеет два эффекта: оно сообщает компилятору, что вы хотите, чтобы он проверял, и гарантирует, что вы не измените этот аргумент внутри своей функции. Второй эффект заключается в том, что внешний код может использовать вашу функцию, передающую объекты, которые сами по себе являются постоянными (и временными), что позволяет использовать одну и ту же функцию в большем количестве.
В то же время ключевое слово const является важной частью документации вашей функции / метода: сигнатура функции явно указывает, что вы собираетесь делать с аргументом и безопасно ли это. чтобы передать объект, который является частью инвариантов другого объекта, в вашу функцию: вы явно указываете, что не будете связываться с их объектом.
Использование const приводит к более строгому набору требований в вашем коде (функции): вы не можете изменять объект, но в то же время оно менее ограничительно для вызывающих, что делает ваш код более пригодным для повторного использования.
void printr( int & i ) { std::cout << i << std::endl; }
void printcr( const int & i ) { std::cout << i << std::endl; }
int main() {
int x = 10;
const int y = 15;
printr( x );
//printr( y ); // passing y as non-const reference discards qualifiers
//printr( 5 ); // cannot bind a non-const reference to a temporary
printcr( x ); printcr( y ); printcr( 5 ); // all valid
}
Вы правильно констатируете разницу. Вы также можете сформулировать это как:
Если вы хотите указать, что функция может изменить аргумент (например, для init_to_big_number (int & i) , указав аргумент с помощью (variable) Ссылка. В случае сомнений укажите его const .
Обратите внимание, что преимущество отсутствия копирования аргумента заключается в производительности, то есть для «дорогих» объектов. Для встроенных типов, таких как int нет смысла писать void f (const int & i) . Передача ссылки на переменную так же затратна, как и передача значения.
Они используются для разных целей. Передача переменной с использованием const int & гарантирует, что вы получите семантику передачи за копированием с гораздо большей производительностью. Вам гарантируется, что вызываемая функция (если она не совершает каких-то безумных вещей с использованием const_cast ) не изменит переданный аргумент без создания копии. int & используется, когда функция обычно имеет несколько возвращаемых значений. В этом случае они могут использоваться для хранения результатов функции.
Итак, мой вопрос: в чем разница с этими двумя случаями ( за исключением того, что "const" означает, что переданная переменная не будет изменена { {1}} function !!!) ???
Это разница.
Я бы сказал, что
void cfunction_name(const X& a);
позволяет мне передать ссылку на временный объект следующим образом
X make_X();
function_name(make_X());
Хотя
void function_name(X& a);
не может этого достичь. со следующей ошибкой error: недопустимая инициализация неконстантной ссылки типа 'X &' из временного объекта типа 'X'
Есть большая разница в том, с каким параметром они могут работать, Скажем, у вас есть конструктор копирования для вашего класса из int,
customeclass(const int & count){
//this constructor is able to create a class from 5,
//I mean from RValue as well as from LValue
}
customeclass( int & count){
//this constructor is not able to create a class from 5,
//I mean only from LValue
}
версия const может работать с временными значениями, а версия non constant не может работать с временными значениями, вы легко столкнетесь с проблемой, когда вы пропустите const там, где это необходимо, и используете STL, но получите ошибку, говорящую, что она не может найти версию, которая принимает временные значения. Я рекомендую использовать const там, где это возможно.
Не говоря уже о производительности, пусть говорит код!
void foo(){
const int i1 = 0;
int i2 = 0;
i1 = 123; //i gets red -> expression must be a modifiyble value
i2 = 123;
}
//the following two functions are OK
void foo( int i ) {
i = 123;
}
void foo( int & i ) {
i = 123;
}
//in the following two functions i gets red
//already your IDE (VS) knows that i should not be changed
//and it forces you not to assign a value to i
//more over you can change the constness of one variable, in different functions
//in the function where i is defined it could be a variable
//in another function it could be constant
void foo( const int i ) {
i = 123;
}
void foo( const int & i ) {
i = 123;
}
использование "const" там, где это необходимо, имеет следующие преимущества: * вы можете изменить постоянство одной переменной i, в разных функциях в функции, где i определен, это может быть переменная в другой функции это может быть постоянное значение. * ваша IDE уже знает, что i не следует изменять. и вынуждает вас не присваивать значение i
с уважением Ой