(режим для начинающих) Свойства переменных Когда Вызывается

Question

Итак, я начинаю изучать С ++ и наткнулся на этот example--

#include <iostream> 

void doIt(int x) 
{ 
    x = 3; 
    int y = 4; 
    std::cout << "doIt: x = " << x << " y = " << y << std::endl; 
} 

int main() 
{ 
    int x = 1; 
    int y = 2; 
    std::cout << "main: x = " << x << " y = " << y << std::endl; 
    doIt(x); 
    std::cout << "main: x = " << x << " y = " << y << std::endl; 
    return 0; 
} 

--и для последовательности, где Doit() называется, Doit: х = 3 y = 4. Возможно, есть какая-то неизвестная вещь, которую я мог бы найти, чтобы лучше понять, что произошло, но, по сути, мне интересно, является ли x передан функции как переменная или ее значение (1). Если бы он был принят как 1, не было бы ошибки? Означает ли это, что для функции потребуется целочисленная переменная, а не отдельное целое число? Эта программа была предназначена, чтобы показать, как эти переменные являются локальными, но я не уверен, как все это сочетается.

Answer 1

Когда вы передадите целое число к вашей функции doIt(int x), то вы передадите int, которые вы передаете.Поэтому все, что вы делаете, чтобы x внутри тела doIt() будет эксклюзивом для копии, которая живет в doIt()

уведомления о том, что имя переменной может быть таким же, или могут быть разными. это не имеет значения. если вы передаете VALUE, содержимое переменной будет ВСЕГДА скопировано.

#include <iostream> 

void doIt(int x) //x here is completely different value than in main 
       //even though they have the same name 
{ 
    x = 3; //this variable has its own scope 
    int y = 4; 
    std::cout << "doIt: x = " << x << " y = " << y << std::endl; 
} //at the end of this function x is destroyed 

int main() 
{ 
    int x = 1; 
    int y = 2; 
    std::cout << "main: x = " << x << " y = " << y << std::endl; 

    doIt(x); //the content of variable x will be passed by value to doIt() 

    std::cout << "main: x = " << x << " y = " << y << std::endl; 
    return 0; 
} 

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

void doIt(int &z) //z is passed by reference, changing it will stick 
//z is the SAME variable that was passed in, even if the name is different 
{ 
    z = 3; //this will change the value that was passed in 
    int y = 4; 
    std::cout << "doIt: z = " << x << " y = " << y << std::endl; 

} //z is not destroyed here, because it wasnt created in this scope 

int main() 
{ 
    int x = 1; 
    int y = 2; 
    std::cout << "main: x = " << x << " y = " << y << std::endl; //x is 1 
    doIt(x); 
    std::cout << "main: x = " << x << " y = " << y << std::endl; //x is 3 now 
    return 0; 
} 

Пасс ссылка будет «секретно» отправить переменную по ее адресу памяти, поэтому int, что получает ваша функция будет фактически SAME один, который был принят в Заметьте, что я выбрал. имя переменной z, потому что имя переменной в разных областях не имеет значения.

Answer 2

Переменные не передаются в функции - значения. (Если мы говорим, что «переменная передается в функцию», это просто сокращённое на значение переменной был передан функции)

Когда doIt называется, x и y в doIt являются новый переменные, не связанные с единицами в main. Значение первого параметра (значение x в main, которое равно 1), хранится в x. Затем 3 хранится в x (по линии x = 3;). Затем 4 хранится в y. Затем вы печатаете x и y, которые содержат значения 3 и 4.

Once doIt возвращает переменные main «s не были изменены, потому что они разные переменные (которые по совпадению имеют такое же имя). Итак, main печатает 1 и 2 снова.

Answer 3

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

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

Answer 4

Когда функция принимает простой аргумент (например, int x), компилятор передает значение VALUE вызываемой функции (иначе называемой «вызываемой»). Внутри вызываемого абонента это значение сохраняется в локальной переменной [1], поэтому, когда вы обновляете его, указав x = 3, КОПИЯ внутри функции обновляется, а не исходное значение в вызывающем.

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

Если вы хотите изменить значение входной переменной, оно должно быть ссылкой, void doIt(int &x) - в этом случае компилятор передаст действительную переменную по ссылке, чтобы вы могли ее модифицировать [технически это означает, что адрес переменной, а не ее содержимое, а затем соответствующий код в вызываемом для обработки разницы].

[1] Да, технически эта копия чаще всего выполняется по коду вызывающего абонента.