Understand Reference and Dereferencing Operators?

Can someone please help me understand Reference and Dereference Operators?

Here is what I read/understand so far:

    int myNum = 30;
    int a = &myNum;   // a equals the address where myNum is storing 30,
    int *a = &myNum;  // *a equals th开发者_如何学JAVAe value of myNum.

When I saw the code below I was confused:

    void myFunc(int &c)   // Don't understand this. shouldn't this be int *c?
    {
      c += 10;
      cout<< c;
    }

    int main()
    {
      int myNum = 30;
      myFunc(myNum);  
      cout<< myNum ;        
    }

int &c has the address to what's being passed in right? It's not the value of what's being passed in.

So when I do c+=10 it's going to add 10 to the memory address and not the value 30. Is that correct?

BUT... when I run this...of course with all the correct includes and stuff...it works. it prints 40.

Actually the ampersand in the function parameter list for myFunc is not an address operator, nor a bitwise and operator. It is a reference indicator. It means that within myFunc, the parameter c will be an alias of whatever argument is passed to it.

You have a few issues here.

1. your second line of code int a = &myNum; // a equals the address where myNum is storing 30 is wrong;
   you can combine it with line 3 like so:
   int *a = &myNum; // a equals the address where myNum is stored; *a == myNum.

2. The type int & is read as "reference-to-int". Perhaps the Wikipedia article can help you understand what this means.

Both pieces of code are valid and your understanding of pointers in the first piece of code is correct. However, the ampersand (&) in the two pieces of code are actually different things. (Like how * is both the dereference and multiplication operator)

The second piece of code shows how the & can be used to pass variables to a function by reference. Normally if you had code like this:

int a;

void foo(int bar) {
    bar = 3;
}

int main() {
    a = 5;
    foo(a);
    // a still equals 5
}

The call to 'foo()' does not affect the variable you passed to it (bar or in this case, a). However if you changed this line:

void foo(int bar) {

to

void foo(int &bar) {

then it would affect the variable and at the end of the program above, the value of a would be 3.

In C++ when you pass things by reference using int &c you don't need to dereference. You only need to dereference pointers. If it was int *c then it would be necessary. Just remember in both cases you change the value of what was passed in the original caller so myNum is now 40.

Let's have a look at the assumptions first:

int myNum = 30;

// this won't compile. &myNum is the address of an int (an int *), not an int:
int a = &myNum;   

// *a is a pointer to an int. It received the address of myNum (which is &myNum), 
// and not its value
int *a = &myNum;  

About the code:

void myFunc(int &c)   
// c is passed by reference. This is a kind of "hidden pointer" that
// allows using the variable as if it was not a pointer but the pointed variable. 
// But as this reference and the variable that was passed by the caller (myNum 
// in your example) share the same address (this is the property of a reference), 
// any modification of the value of c inside myFunc modifies it in the 
// caller's scope too (so here, it modifies myNum). 
{
  c += 10;
  cout<< c;
}

int main()
{
  int myNum = 30;
  myFunc(myNum);  // displays 40

  // What follows displays 40 as well, due to the fact 
  // c was passed by reference to myFunc that added 10 to it       
  cout<< myNum ;  
}

So when I do c+=10 it's going to add 10 to the memory address and not the value 30. Is that correct?

No, 10 was added to the value of c by myFunc. As c is a reference (a "hidden pointer to") that received myNum, myNum was modified as well.