Thread: References

Originally Posted by Elysia

*this is not 1000. this is a pointer to the class itself, hence *this is the class itself. The class is not an integer, hence that is not valid.

*this gives us object, but object is just a memory address, as it is any variable in C++, that is what I actually meant, am I right?

Originally Posted by MutantJohn

I don't ever recommend returning by reference. Especially when it looks like you're receiving a parameter by value and then returning a reference to that. In all likelihood, that's UB. Just return by value.

I am aware of that, just trying to understand references

Originally Posted by GReaper

You're over-complicating it, in my opinion. Think of it like this: A pointer is the position of a variable in memory. A reference (in C++ terms) is the variable itself. That's how I view it, and it works pretty well.

Your logic makes sense.

Originally Posted by Elysia

No, a reference is not a memory address. It's a type that may contain data and functions. Hence it does make sense to treat it as an "int".

If you're just trying to understand references, then just think of them as aliases. They share storage with the variable they reference. In essence, they're the same variables, but with different names. You don't need to complicate it any further.

I understood that references can be used as aliases

Code:

class Foo
{
    private:
        int x;

    public:
        Foo() : x(0) {}
        int getX() const {return x;}
        void setX(int _x) { x = _x;} 
};

int main(void)
{
    Foo foo;
    Foo& fooRef = foo;
     
    printf("fooRef: %d\n", fooRef);
    printf("foo: %d\n", foo);
    
    cout << "foo.getX(): " << foo.getX() << endl;
    cout << "fooRef.getX(): " << foo.getX() << endl << endl;
    
    foo.setX(999);
    cout << "After calling foo.setX(999);" << endl;
    cout << "foo.getX(): " << foo.getX() << endl;
    cout << "fooRef.getX(): " << foo.getX() << endl;
}

code produces following

fooRef: 0
foo: 0
foo.getX(): 0
fooRef.getX(): 0

After calling foo.setX(999);
foo.getX(): 999
fooRef.getX(): 999

But I think references might share different storage like in this case:

Code:

class Test
{
    int &i;   // int *const i;
    int &j;   // int *const j;
    int &k;   // int *const k; 
};

int main()
{    
    // This will print 12 i.e. size of 3 pointers
    cout<<  "size of class Test = "  <<   sizeof(class Test)  <<endl;
    return 0;
}