difference between returning a 'int&' instead of a 'int'

can someone tell me the difference, pros and cons of both the following functions.

Code:

---

class Node
{
        int data_;
        Node* prev_;
        Node* next_;
       
        public:
                Node(){data_ = 5;}
                ~Node(){};
                int getdata(){return data_;}
};

int main()
{
        Node obj;
        cout << obj.getdata() << endl;
        return 0;
}

---

Code:

---

class Node
{
        int data_;
        Node* prev_;
        Node* next_;
       
        public:
                Node(){data_ = 5;}
                ~Node(){};
                int& getdata(){return data_;}
};

int main()
{
        Node obj;
        cout << obj.getdata() << endl;
        return 0;
}

---

incase you didn't see it i added a '&' in front of the getdata member function.

the '&' gives you a reference to the variable who's memory lives inside the object. If you modify it, you modify the one in the object. Not so in the other case.

"by reference" means that you get to work with the same instance. "by value" means that you get a copy of the instance. Adding the "&" just makes it by reference instead of by value.

well put Fillyourbrain.. thnks

Anytime! well anytime that I'm actually logged into this message board. Truthfully its been a while.

An advantage of returning by reference is that you can cascade operations and that you can write directly to the data member (instead of using a 'set' function), e.g.

Code:

---

int main()
{
        Node obj1;
        Node obj2;
        Node obj3;
       
        obj1.getdata() = obj2.getdata() + obj3.getdata()
}

---

This looks somewhat awkward, though. Why is it so much better than

Code:

---

obj1.setdata(obj2.getdata() + obj3.getdata());

---

Anyway, container-like classes exist to store data for you. Otherwise you are free to do anything you want with its contents. So references make sense.

However, in case of classes that have a different purpose, returning references may limit your choices later on. May-be you want to change the class implementation, and remove the variable that you previously returned by reference. Or you might want to add code that should be executed when a member is written to, but not when it is read.

It gets more sensible when you have operator[] or operator() variants of the class. For exampe, in my recent tic-tac-toe program, I have this operator:

Code:

---

CellState& CTicTacToe::operator() (size_t x, size_t y) const
{
        ASSERT(x < size && y < size);

        return board[x + size * y];
}

---

which means that you can do this:

Code:

---

CTicTacToe board;

board(1,1) = CS_X;

---

--
Mats

Is that to say that code like

Example:

Code:

---

static int global_x = 0;
static int global_y = 0;

int &setXY(int y)
{
  global_y = y;
  return global_x;
}

int main(void)
{
  setXY(5) = 3;
}

---

Is not sensible? Because I think its perfectly easy to follow.

--Truly I hope any new programmer takes me completely unseriously and never, ever considers writing anything as malformed as that.

From a library-user point of view? It's because you know the code.

Let's say you program a matrix class, then your clients will use C = A + B*D instead of some function nesting...

C = A + B*D is not analogous to setXY(3) = 5.