C++Talk.NET

Guest

For example,

int i = 5;
int &r = i;

Are i and r two different variables?
Or do i and r occupy the same memory space? that means they are the
same variable?

Thanks.

John Carson · Guest

<junw2000 (AT) gmail (DOT) com> wrote in message
news:1140754278.407331.256940 (AT) u72g2000cwu (DOT) googlegroups.com

Peter_Julian · Guest

<junw2000 (AT) gmail (DOT) com> wrote in message
news:1140754278.407331.256940 (AT) u72g2000cwu (DOT) googlegroups.com...
| For example,
|
| int i = 5;
| int &r = i;
|
| Are i and r two different variables?

Isn't i refering to an integer variable initialized to 5?
Thats exactly how references were "invented" in C++. The reference r is
just another name referring to the same integer variable that i is
referring to.

You are an instance of a Person class. You have both a name and a
nickname, i can use either to refer to the same person: you. Yet both
names are unique attributes of you. A nickname is an example of a
reference.

In my small, tiny brain, i need to store both your name and nickname
somewhere in different locations. Even though each refer to the same
object.

#include <iostream>
#include <ostream>

int main()
{
int i = 5;
int& r = i;

std::cout << "address of i = " << &i << std::endl;
std::cout << "address of r = " << &r << std::endl;

return 0;
}

/*
address of i = 006BFDF4
address of r = 006BFDF4
*/

| Or do i and r occupy the same memory space? that means they are the
| same variable?

They don't occupy the same memory space physically. The reference r and
i both *refer* to the same memory space occupied by that integer. Deep
down, a reference is nothing more than a pointer with special rules.
Ahem, lets make that: very special rules.

If you write a class that has one integer member and 2 integer member
references and you initialize the 2 references to refer to the original
integer in the class ctor, you'll end up with an instance of that class
composed of 3 entities, two of which "point" to the original integer.

Note the sizeof() output on this 32-bit platform.

#include <iostream>
#include <ostream>

class R
{
int n;
int& r;
int& rr;
public:
R(int x) : n(x), r(n), rr(n) { }
~R() { }
void display() const
{
std::cout << "&n = " << &n;
std::cout << "\n&r = " << &r;
std::cout << "\n&rr = " << &rr;
std::cout << "\nn = " << n;
std::cout << "\nr = " << r;
std::cout << "\nrr = " << rr;
std::cout << std::endl;
}
};

int main()
{
R var(99);
var.display();
std::cout << "sizeof(var) = " << sizeof(var);
std::cout << std::endl;

return 0;
}

/*
&n = 006BFDD8
&r = 006BFDD8
&rr = 006BFDD8
n = 99
r = 99
rr = 99
sizeof(var) = 12 // an integer(4 bytes) + 2 references(4 Bytes each)
*/

Its important for you to clear this issue because references provide a
special behaviour to the C++ language.

a) a reference is guarenteed to be valid. There is no such thing as an
unitialized reference.

b) a reference is unbreakable and therefore permanent. Reference r above
can't be modified to refer to another variable than i.

c) a reference can extend the lifetime of a variable.

As you can see, references were created specifically to eradicate
pointer hell. In fact, it does its job perfectly and transparently.

bonjour2all@gmail.com · Guest

its like one variable with 2 names...
the same memory location is used...this is to the best of my knowledge

Mike Wahler · Guest

<junw2000 (AT) gmail (DOT) com> wrote in message
news:1140754278.407331.256940 (AT) u72g2000cwu (DOT) googlegroups.com...

Re: How is reference implemented in C++?

THe language standard does not require any
particular mechanism. Each implementation
is free to do it in any way, as long as
the behavior is compliant.

Guest

Jordan Abel wrote:

Jordan Abel · Guest

On 2006-02-24, John Carson <jcarson_n_o_sp_am_ (AT) netspace (DOT) net.au> wrote:

n2xssvv g02gfr12930 · Guest

junw2000 (AT) gmail (DOT) com wrote:

Tomás · Guest

posted:

Jordan Abel · Guest

On 2006-02-24, ferdinand.stefanus (AT) gmail (DOT) com <ferdinand.stefanus (AT) gmail (DOT) com> wrote:

Guest

Thank you very much for your detail explanation.

But if
/*
&n = 006BFDD8
&r = 006BFDD8
&rr = 006BFDD8

Does it means that n, r and rr occupy the same memory space, since
their addresses are the same?

But sizeof(var) = 12 // an integer(4 bytes) + 2 references(4 Bytes
each).
It seems to me that they are three different integer variables. I am
confused.

Thanks.

Gavin Deane · Guest

junw2000 (AT) gmail (DOT) com wrote:

Peter_Julian · Guest

<junw2000 (AT) gmail (DOT) com> wrote in message
news:1140798661.916094.81070 (AT) z34g2000cwc (DOT) googlegroups.com...
| Thank you very much for your detail explanation.
|
| But if
| /*
| &n = 006BFDD8
| &r = 006BFDD8
| &rr = 006BFDD8
|
| Does it means that n, r and rr occupy the same memory space, since
| their addresses are the same?

No, &r is not returning the address of the reference itself, its
returning the adress of the referred-to variable. You can't directly
measure the size of the reference itself either since sizeof(r) returns
the type size of the referred-to variable.

While the reference itself does occupy memory (usually the same size as
a pointer) its job is to serve the referred-to object. The 12 bytes on
this platform indirectly exposes the actual size. But the reference is
not allowed to return that value. If it did, it would break its purpose.

|
| But sizeof(var) = 12 // an integer(4 bytes) + 2 references(4 Bytes
| each).
| It seems to me that they are three different integer variables. I am
| confused.
|
| Thanks.
|

Its one integer and two pointers-on-steroids. You are confused because
on a typical 32 bit platform an integer happens to occupy the same space
in memory as a pointer. ok, try...

#include <iostream>
#include <ostream>

class N
{
double d;
double& r;
double& rr;
public:
N(double d_) : d(d_), r(d), rr(d) { }
~N() { }

/* friend op<< */
friend std::ostream& operator<<(std::ostream& os, const N& ref)
{
os << ref.d;
return os;
}
};

int main()
{
N n(11.1);

std::cout << " n = " << n; // op<<
std::cout << "\n sizeof(double) = " << sizeof(double);
std::cout << "\n sizeof(var) = " << sizeof(n);
std::cout << std::endl;

return 0;
}

/*
n = 11.1
sizeof(double) = 8
sizeof(var) = 16
*/

Guest

Thanks a lot. I ran your code and got the same result.
I also print the sizeof(r), it is 8 bytes. sizeof(rr)=8 too.

Should sizeof(var)=sizeof(d)+sizeof(r)+sizeof(rr)?
If so, sizeof(var)=8+8+8=24.

But since the code outputs "sizeof(var) = 16",
so
sizeof(var)=sizeof(d)+sizeof(pointer)+sizeof(pointer)=8+4+4=16.

What is the problem here?

Thank you very much

Phlip · Guest

junw2000 (AT) gmail (DOT) com wrote: