Может кто-нибудь объяснить мне, как именно этот код выполняется?

Question

Может кто-нибудь объяснить, как здесь выполняется код? Я не понимаю, как выход на второй линии 8 7 8 и в третьей линии 21 20 21.

#include<iostream> 
using namespace std; 
//Funtion passed by value and by reference 
int fn1(int &a, int b, int *c){ 
    a=b++; 
    b+=7; 
    *c= ++a; 

    return b; 
} 

int main(){ 
    int x=4, y=7, z=14; 
    cout<< x<< " " << y<< " "<< z<< endl; // output: 4 7 14 
    fn1(x,y,&z); 
    cout<< x<< " " << y<< " "<< z<< endl; // output: 8 7 8 (I dont get this part!!!) 
    x=9, y=12, z=19; 

    y=fn1(x,y,&z); 
    fn1(x,y,&z); 
    cout<< x<< " " << y<< " "<< z<< endl; // output: 21 20 21(I dont get this part!!!) 
    return 0; 
} 

Answer 1

Вы создаете ссылку для прохождения б, как это и адрес Кассиопеяна

a is a reference to x hence any change in value of a is reflected in x 
since y is passed by value any change in value of b will not change y 
and for z as its address is passed any change to the location will be reflected in z 

for a = b++ 
a gets the value 7 and b is incremented to 8(post increment) 
b+=7 
*c = ++a 
a will become 8 and will get assigned to address pointed by c 
hence you get output as 8 7 8 as x will be a y will remain 7 and z will be c 

же в течение следующих двух вызовов

Answer 2

Вторая строка:

x модифицируется fn1 потому что первый параметр передается по Ссылки на сайты е.

z изменен fn1, потому что указатель на z передан функции.

Первая строка:

a = b++ 

7 Назначает к a, потому что это b7 и b++ является функцией пост-инкремент.

c = ++a 

приращений a к 8 и назначать 8 к c, потому что ++a является функцией предварительного приращения.

То же самое для линии 3.

Answer 3

Хотя я не уверен, что вы ожидали выходы быть, я видел одну вещь, которая, вероятно, не намеренно.

Обратите внимание, что ваша функция fn1 возвращает int, однако, когда вы вызываете ее в строке 20, она не используется для обновления какой-либо из ваших переменных. Возможно, вы хотели обновить значение y?

Кроме того, вы можете получить лучшее представление о том, как функция работает, добавляя операторы печати, чтобы увидеть, как внутренние переменные итерацию:

int fn1(int &a, int b, int *c){ 
    a=b++; 
    cout << "a: " << a << " "; 
    b+=7; 
    cout << "b: " << b << " "; 
    *c= ++a; 
    cout << "c: " << *c << endl; 

    return b; 
} 

Answer 4

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

b+=7 

используется, чтобы переписать исходное значение Y. Затем снова вызовите функцию с новым значением Y.

Answer 5

В вашей int fn1(int &a, int b, int *c) функции:

a передается в виде ссылки.
b передается по значению.
c Поставляется с указателем.

a = b++; изменяет x, поскольку a является ссылкой x.
b += 7; изменяет b, но не y, потому что b - это всего лишь значение y.
*c = ++a; изменяет x и z потому что a является отнесение x и c является указателем на z.

Когда вы используете ссылки и указатели, вы можете записывать непосредственно значения в свое собственное пространство памяти. Однако, когда вы используете по значению (думаю, b), новая переменная создается в текущей области (внутри функции fn1), и любые изменения в ней выделены для этой области.

Проверьте этот ответ, чтобы узнать больше о облаках на C++. https://stackoverflow.com/a/11345787/1000437

Надеюсь, это поможет.

Answer 6

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

fn1(x,y,&z); 
cout<< x<< " " << y<< " "<< z<< endl; 
// output: 8 7 8 (I dont get this part!!!) 

Давайте посмотрим на нашу функцию FN1

int fn1(int &a, int b, int *c){ 
a=b++; 
b+=7; 
*c= ++a; 

return b; 
} 

Первое, обратите внимание, что в fn1(int &a) переменной а передается по ссылке, а не по стоимость. Это означает, что мы будем напрямую работать со значением, которое мы передаем a. Это в основном означает, что если вы измените значение a внутри функции, изменение будет persist. Итак, с int x=4, y=7, z=14; и мы вызываем fn1(x, y, &z), мы передаем переменную x в a (подумайте, что она временно переименовывается из x в a). Итак, a изначально 4. b - просто значение, поэтому содержимое y передается в b и * c является указателем и просто принимает в качестве значения физический адрес z (поэтому у вас есть fn1(&z)).

Так что, когда мы называем нашу функцию fn1(x, y, &z) мы выполняем:

a=b++; 

Таким образом, изменения в 7, б изменений 8. (если это сбивает с толку, читать интро о операторов this) Тогда:

b+=7; //same as: b=b+7; 

Так что b принимает значение 8 + 7 = ?? (! Жаль, что я не имею степень по математике!)

Наконец:

*c= ++a; 

Теперь, так как мы имеем ++ а, сначала изменения в = а + 1, и теперь принимает значение из 8, так как это было 7! И * c означает «значение переменной, с которой указывает указатель c»: так что значение переменной c указывает на z. Таким образом, значение z изменяется на любое значение a (которое равно 8).

И вот последний шаг (для настоящего на этот раз). Почему не y изменить? Поскольку мы fn1 берет значение b по значению, а не по ссылке, а когда функция заканчивается, var b уничтожается.

Теперь попробуйте сделать вторую часть:

y=fn1(x,y,&z); 

В этом случае у будет принимать все fN1 возвращается! Я бы посоветовал вам шаг за шагом. Если это все еще запутывает, выполняйте раздельно с поведением каждого типа var, передавая его по ref, по val и позже указателем.