Why we have to pass the values instead of the address into a "call by reference" function in C++?

Question

I'm new to C++ and learning call by reference now.

I learned this block of code on my material:

void callByRef(&a, &b);

int main(){
    int k = 12;
    int m = 4;
    callByRef(k, m) //QUESTION HERE
    return 0;
}

void callByRef(&a, &b){
    a += 3;
    b -= 2;
    return;
}

So my question is when declaring callByRef, we use the addresses of a and b as the parameters, so when we call callByRef in the main, why we need to pass in (k, m) instead of (&k, &m)?

It's basic, but I just want to get the right picture for my future studying. Thanks guys!

"we use the addresses of a and b as the parameters" What? The declaration should look like `void callByRef(int& a, int& b)`, and that's __not__ taking the address of parameters, it's declaring them as references. — tkausl, Sep 19 '17 at 03:59
`void callByRef(&a, &b)` [is not legal C++](https://ideone.com/dpTUvj). If that's what your course material contains, you should complain and demand your money back. — n. m. could be an AI, Sep 19 '17 at 04:46

Artem Barger · Answer 1 · 2017-09-19T04:08:00.270

The operator of &a means the address of variable a, the operator of *a means the content of memory addressed by variable a. Now the function definition is following:

void callByRef(int &a, int &b){
    a += 3;
    b -= 2;
    return;
}

where int &a means that a will be a reference to some variable of type int. Therefore whenever you gong to call the function you need to pass the variable itself rather its address, hence callByRef(a, b) and not callByRef(&a, &b).

The reason of such declaration is following, parameters passed to the function, passed by value, namely the content of the variable literally copied into function variable, therefore any change to it inside the function won't have any effect. For example:

void callByVal(int a, int b){
    a += 3;
    b -= 2;
    return;
}

and having:

x = 5;
y = 10;

calling callByVal(x, y) won't have any effect on x and y. To overcome this, you need to pass parameters either by reference or int &a or as an alternative you can pass pointer and update memory directly:

void callByPtr(int *a, int *b){
    *a += 3;
    *b -= 2;
    return;
}

And now it make sense to pass variables addresses, e.g. callByPtr(&a, &b).

score 0 · Answer 2 · answered Sep 19 '17 at 03:57

0

The callByRef() function passes the references as arguments so you don't need to send the explicit reference to the function. Have a read through this to understand a bit better.

Tutorial

answered Sep 19 '17 at 03:57

hahahakebab

328
7
22

Thanks for your answer hahahakebab! Reading it now. – Hang Sep 19 '17 at 04:00

score 0 · Answer 3 · answered Sep 19 '17 at 06:15

You don't pass the value. References in C++ aren't exactly like pointers. Think of them as simply being another name for an object.

Naturally you need to bind that name to an object in order for the reference to refer to it. So for instance when we write int &i = k; we are saying that the variable that is already named k, may be referred to as i. To bind the reference, we need to name the other object. And the name of the object is k, not &k.

The same applies to function parameters and arguments. The function callByRef is specified to operate on two objects it will call a and b. When you call that function, you must name the original objects it will refer to. And the original objects are named k and m, not &k and &m.

Why we have to pass the values instead of the address into a "call by reference" function in C++?

3 Answers3