Simple code: Can 2 references refer to the same object?

I was told that C++ does not allow 2 references refer to the same object. So I wrote a snippet to verify it:

Code:

---

class Base{                                                                                                                                                                 
    string& s;                                                                                                                                                             
public:                                                                                                                                                                     
    Base(string a):s(a){}                                                                                                                                                   
    ~Base(){cout<<"Base"<<endl;}                                                                                                                                           
};                                                                                                                                                                         
                                                                                                                                                                           
                                                                                                                                                                           
int main(int argc, char* argv[]){ 
    string b = "asdfa"; 
    string a="abc";
    Base x(a);
    Base y(b);
    y = x;
}

---

Complier reports error:

Quote:

---

main.cc: In member function `Base& Base::operator=(const Base&)':
main.cc:30: error: non-static reference member `std::string&Base::s', can't use
default assignment operator

---

This is what I expected: 2 references CAN NOT refer to the same object.

But then I wrote another snippet:

Code:

---

    string a = "abc";                                                                                                                                                       
    string b = "asdfa";                                                                                                                                                     
    string& x = a;                                                                                                                                                         
    string& y = x;                                                                                                                                                         
    y=x;                                                                                                                                                                   
    cout<<y<<endl;                                                                                                                                                         
    x[0]='X';                                                                                                                                                               
    cout<<y<<endl;

---

It seems that this code DOES work. and both x and y refer to the same string. As you modified x to "Xbc", y's value is also changed. How come?!

Quote:

---

Originally Posted by meili100

It seems that this code DOES work. and both x and y refer to the same string. As you modified x to "Xbc", y's value is also changed. How come?!

---

We're talking about references here.
You are never modifying x at all. You are modifying a.
Similarly, setting a reference to x isn't assigning a reference to x, but to a.
References are transparent and will apply anything you do it to the variable it is bound to.

The first example stems from an entirely different problem.
You are initializing a member variable, s, with the passed string a (which is temporary, btw, so it should be illegal or produce unexpected results).
Further, I believe the error is due to your reference member. References cannot be assigned, so a default assignment operator could not be created (since it would make a shallow copy).

Who says you can't have 2 references pointing to the same object?

Two references can point to the same object.

A reference cannot point to two different objects, that might be what you were told.

That is why the first example fails. When you assign the Base object called x to the base object called y, the compiler generated copy assignment operator is used. That does a member-wise copy. But for a reference, you cannot re-assign it to another object, so the reference member of y cannot have another object assigned to it. That's why you get an error about the default assignment operator.