Your Tutorial is in my opinion far superior to C++ PP. It has really helped me get a better grasp of this language.

Thank you for bringing the human element to this tutorial and making it easier to understand.

Note: You should consider making this Tutorial into a book. It’s better than what I’ve seen being offered out in the world.

Take care and best of luck in your endeavors.

Dennis

continue job for welfare of programmers!!!!!!!!!!!!!!!!!!

And good point in the comment up here, i’m pleased to see i’m learning from someone who realy knows what he’s talking about xD

Now, when somebody asks me where to learn cplusplus, it’s your site I’ll recomend (unfortunately most pleople I know wont be very pleased to have to translate it so then can understand)

keep the good work!

(eh, sorry for the bad english)

int x;
cout < < &x << endl;
int y;
cout << &y << endl;
int z;
cout << &z << endl;

produces the result:
0012FF7C
0012FF78
0012FF74

As you can see, the first thing allocated was put in 0012FF7C, the second in 0012FF78, and the third in 0012FF74.

In the first example above, we allocate one variable (nRef), so it gets allocated to 0012FF7C as we would expect.

The second example is more interesting. In the second example above, we allocate one reference (rnRef)… When we take the address of a reference, it returns the address of whatever it’s referencing (not it’s actual address). &rnRef returns 0012FF78, which is the second spot available for allocation. If the thing rnRef is pointing to is in the second spot available for allocation, then what’s in the first spot?

The answer is the reference itself!

If this is true, then the value at address 0012FF7C (which is where the reference actually lives) should be the address 0012FF78 (which is what the reference is pointing at). If we look at the value in memory address 0012FF7C (using a debugger), we see the decimal value 1245048, which is 0012FF78 in hex.

So it appears the theory is true. The reference itself is being allocated at memory 0012FF7C. It contains the value 0012FF78, which is what the reference is looking at. Memory 0012FF78 has the value 6. The literal value 6 was given it’s own memory address so the reference could point to it. ]]> http://www.learncpp.com/cpp-tutorial/611-references/#comment-7219 Zafer Mon, 04 Feb 2008 18:38:30 +0000 http://www.learncpp.com/cpp-programming/611-references-2/#comment-7219 Yes this theory is meaningful. I don't see however how the second allocation is doing an extra allocation. Yes this theory is meaningful. I don’t see however how the second allocation is doing an extra allocation.

My guess is that the compiler promotes the literal 6 to a constant int, and then assigns the reference to that. To see if I could find any evidence of this behavior, I did a simple test:

const int nRef = 6;
cout < < &nRef << endl;

On my machine, this prints 0012FF7C

const int &rnRef = 6;
cout < < &rnRef << endl;

On my machine, this prints 0012FF78

With integers being 4 bytes, note that the second example appears to be doing an extra allocation. This certainly lends support to the theory of the literal being promoted to a constant integer. ]]> http://www.learncpp.com/cpp-tutorial/611-references/#comment-7209 Zafer Mon, 04 Feb 2008 16:44:54 +0000 http://www.learncpp.com/cpp-programming/611-references-2/#comment-7209 I have a question about the statement: "You can assign const references to literal values, though there is typically not much need to do so: const int &rnRef = 6;" In another tutorial, I read that a reference variable needs an accessable address. When we declare a reference variable we can only assign something that has a valid address. In other words, the thing we are assigning should be an l-value. However, constant literals do not have predefined memory address therefore cannot be assigned to a reference variable. Please correct me if I'm wrong. I have a question about the statement: “You can assign const references to literal values, though there is typically not much need to do so: const int &rnRef = 6;”

In another tutorial, I read that a reference variable needs an accessable address. When we declare a reference variable we can only assign something that has a valid address. In other words, the thing we are assigning should be an l-value. However, constant literals do not have predefined memory address therefore cannot be assigned to a reference variable. Please correct me if I’m wrong.