C pass reference to parameter

Question

as I know in c++ when you pass a variable by reference means that we pass the very variable not a copy of it. so if a function that takes a refernce as a parameter we know that any change that that function does on the parameter will affect the original variable(variable passed in). but I'm stuck now: I have a member function that takes a reference to int this member function void DecrX(int &x) decrements x when it is called. the problem i get is that the original variable always never affected???!!! eg:

#include <iostream>
using namespace std;

class A
{
public:
    A(int &X):x(X){}
    int &getX(){return x;}
    void DecrX(){--x;}
    void print(){cout<<"A::x= "<<x<<endl<<endl;}
private:
    int x;
};

int main()
{

int x=7;
cout<<"x= "<<x<<endl;
A a(x);//we passed the x by reference
a.DecrX();// here normally DecrX() affect the original x
a.print();//here it is ok as we thought
a.DecrX();
a.DecrX();
a.print();
cout<<"x= "<<x<<endl;//why x is still 7 not decremented

cout<<endl;
return 0;
}

Answer 1

You can make this problem easier for yourself to understand by being a little more verbose, specifically, give your member variables more distinct names.

class A
{
public:
    A(int& x) : m_x(x) {}
    const int& getX() const { return m_x; }
    void DecrX() { --m_x; }
    void print() {cout << "A::m_x= " << m_x << endl << endl;}
private:
    int m_x;
};

Now, lets look at this more carefully. "m_x" (member x) is of type "int". It's not a reference. It's a value.

A(int& x)

Declares a constructor which takes a reference to a variable and calls this reference "x".

: m_x(x)

Initializes member x, an integer value, with the value of the reference called x.

The problem is that your member m_x is itself a value and not a reference.

class A
{
public:
    A(int& x) : m_x(x) {}
    const int& getX() const { return m_x; }
    void DecrX() { --m_x; }
    void print() {cout << "A::m_x= " << m_x << endl << endl;}
private:
    int& m_x;
};

BEWARE: Creating objects which take references to things can be a nightmare.

#include <iostream>

class A
{
public:
    A(int& x) : m_x(x) {}
    const int& getX() const { return m_x; }
    void DecrX() { --m_x; }
    void print() { std::cout << "A::m_x= " << m_x << std::endl << std::endl; }
private:
    int& m_x;
};

A calculateStuffAndReturnAnAForMe(int x, int y)
{
    int z = x + y;
    A a(z);
    return a;
}

int main()
{
    A badData = calculateStuffAndReturnAnAForMe(5, 10);
    badData.print(); // badData's m_x is a reference to z, which is no-longer valid.
    std::string input;
    std::cout << "Enter your name: ";
    std::cin >> input;
    std::cout << std::endl << "You entered: " << input << std::endl;
    badData.print();
}

In this case, the "a" we return has a reference to stack-variable "z" but "z" goes away when we leave the function. The result is Undefined Behavior.

See live demo: http://ideone.com/T279v7

Answer 2

In cout<<"x= "<<x<<endl; you print the local variable of main(), whereas in a.print() lines you print the local variable x of object a, which the member function DecrX() decreases.

Answer 3

You're modifying a copy not the original not itself, so the original will not be changed. Read comments:

A(int &X) : x (X) {}   // This copies modifiable `X` into `x`.
            |  ^
            |  |
            +--+

void DecrX(){--x;}    // This decrements `x` not referenced `X`

To have the ability of modifying the original variable, you should declare a reference:

class A
{
public:
    A(int &X):x(X){}

    void DecrX(){--x;}

private:
    int &x; // <<------------ A reference
        ^
};

Be careful, life time of passed variable should be longer than the receiver object of A.

Answer 4

The problem is that the fact that your constructor takes variable by reference is irrelevant here:

class A
{
public:
    A(int &X):x(X){}      // <-- initializes member x by copying passed argument
    void DecrX(){--x;}    // <-- decrements member of class A
    ...
    int x;
};

to achieve what you actually described, you need to define member x as a reference as well:

int& x;

"if we declare a pointer as member data will do the same as you declared the reference int &x?"

The pointer is initialized using an address. Important to realize is that NULL is perfectly valid value while reference can not be initialized by other means than using valid variable / object. Note that once you declare member x as a reference, you introduce a constraint that instance of class A can not be created without valid int variable. Have a look at: Should I prefer pointers or references in member data?

Answer 5

The problem here is that you pass the reference, but then assign it to the class member x. Doing this will not keep the reference. And the x class member and the x in the main are totally unrelated. I hope this makes sense. To fix this, you could make the class member x a pointer.