The difference between a C + + reference and a pointer

Turn!!!! http://blog.csdn.net/wangqiulin123456/article/details/8464418

Although you can access another value indirectly using both references and pointers, there are two important differences between them:

• References always point to an object, and it is wrong to define that the reference is not initialized.
• The difference in the assignment behavior, which modifies the value of the object that the reference is associated with, rather than associating the reference with another object. Once a reference is initialized, it always points to the same particular object.

★ Same point:

1. Is the concept of the address;

The pointer points to a piece of memory whose contents are the address of the referred memory, and the reference is the alias of a block of memory.

★ Difference:

1. The pointer is an entity, and the reference is only an individual name;

2. The reference does not need to dereference (*), the pointer needs to be dereferenced;

3. References can only be initialized once at the time of definition, and then immutable; pointers are variable;

Reference "mindedness" ^_^

4. Reference does not have a const, pointer has const,const pointer is immutable;

5. The reference cannot be null, the pointer can be empty;

6. "sizeof Reference" gets the size of the variable (object) pointed to, and the "sizeof pointer" gets the size of the pointer itself (the address of the variable or object to which it is pointing);

typeID (t) = = typeid (t&) constant is true, sizeof (t) = = sizeof (t&) is true, but when referenced as a member, it occupies the same space as the pointer (no Standard rules found).

7. The pointer and the reference self-increment (+ +) operation has different meanings;

★ Contact

1. References are implemented within the language using pointers (how do I do that?) ）。

2. For general applications, the reference is interpreted as a pointer and does not make a serious semantic error. A reference is a pointer to a restricted operation (allow only the content operation).

★ "High quality C + + Programming Guide" 6.6

References are concepts in C + +, and beginners tend to confuse references with pointers. In the program, N is a reference to M (reference), and M is the quoted (referent).

[CPP]View Plaincopyprint?

1. int m;
2. int &n = m;

N is equivalent to an M alias (nickname), and any action on N is an operation on M. For example, someone named Wang Xiaomao, whose nickname is "Sanmao". Say "Sanmao" how how, in fact is to Wang Xiao judge. So n is neither a copy of M nor a pointer to M, in fact N is M itself.

Some of the rules cited are as follows:

(1) The reference is created and must be initialized (the pointer can be initialized at any time).

(2) cannot have a null reference, the reference must be associated with a valid storage unit (the pointer can be null).

(3) Once a reference is initialized, the referenced relationship cannot be changed (the pointer can change the object at any time).

In the following sample program, K is initialized as a reference to I. The statement k = J cannot modify k to be a reference to J, just change the value of K to 6. Since k is a reference to I, the value of I also becomes 6.

[CPP]View Plaincopyprint?

1. int i = 5;
2. int j = 6;
3. int &k = i;
4. The values of k = j; //K and I are all changed to 6;

The above program looks like you're playing a word game and doesn't reflect the value of the quote. The primary function of a reference is the parameter and return value of the passed function. In the C + + language, the parameters and return values of a function are passed in three ways: value passing, pointer passing, and reference passing.

The following is a sample program for "Value passing". Since x in the FUNC1 function body is a copy of the external variable n, changing the value of x does not affect n, so the value of n is still 0.

[CPP]View Plaincopyprint?

1. void Func1 (int x)
2. {
3. x = x + 10;
4. }
5. int n = 0;
6. FUNC1 (n);
7. cout << "n =" << n << Endl; //n = 0

The following is a sample program for "pointer passing". Since x in the FUNC2 function body is a pointer to an external variable n, changing the contents of the pointer will cause the value of N to change, so the value of n becomes 10.

[CPP]View Plaincopyprint?

1. void Func2 (int *x)
2. {
3. (* x) = (* x) + 10;
4. }
5. ?
6. int n = 0;
7. FUNC2 (&n);
8. cout << "n =" << n << Endl; //n = ten

The following is a sample program for "reference passing." Since x in the FUNC3 function body is a reference to an external variable n, x and n are the same thing, changing x equals changing n, so the value of n becomes 10.

[CPP]View Plaincopyprint?

1. void Func3 (int &x)
2. {
3. x = x + 10;
4. }
5. //...
6. int n = 0;
7. FUNC3 (n);
8. cout << "n =" << n << Endl; //n = ten

In contrast to the above three sample programs, it is found that "reference passing" is of the nature of "pointer passing" and is written like "value passing". In fact, anything that "references" can do "pointers" can also be done, why "reference"

This thing?

The answer is "do the right thing with the proper tools."

Pointers can manipulate things in memory without restraint, although pointers are powerful, but very dangerous.

Like a knife, it can be used to cut trees, cut paper, manicure, barber, etc., who dares to use it?

If you really only need to borrow an "alias" for an object, use "reference" instead of "pointer" to avoid an unexpected occurrence. For example, someone needs a proof that the seal on the document would have been stamped on it, and if the key to the official seal is given to him, then he has acquired the right not to.

★ Clause One: The difference between a pointer and a reference

Pointers and references look completely different (pointers use the operator ' * ' and '-a ', referencing the operator '. ') ), but they seem to have the same functionality. Pointers and references let you refer to other objects indirectly. How do you decide when to use a pointer and when to use a reference?

First, realize that you cannot use a reference to a null value under any circumstances. A reference must always point to some object. So if you use a variable and point it to an object, but that variable may not point to any object at some point, you should declare the variable as a pointer, because you can assign a null value to the variable. Conversely, if the variable is definitely pointing to an object, such as your design does not allow the variable to be empty, then you can declare the variable as a reference.

　　"But wait a minute," you asked suspiciously,"what kind of consequences would this code have?" "

[CPP]View Plaincopyprint?

1. char *pc = 0; //Set pointer to null value
2. char& rc = *pc; //Let the reference point to a null value

This is very harmful, no doubt about it. The result will be indeterminate (the compiler can produce some output, causing anything to happen) and should avoid the person who writes the code unless they agree to correct the error. If you are concerned that such code will appear in your software, then you'd better avoid using references altogether, or let better programmers do it. We will later ignore the possibility of a reference pointing to a null value.

Because the reference will definitely point to an object, in C, the reference should be initialized.

[CPP]View Plaincopyprint?

1. string& rs; //error, reference must be initialized
2. Strings ("Xyzzy");
3. String&rs = s; //Correct, RS pointing s
5. Pointers do not have such a limitation.
6. String*ps; //Uninitialized pointer
7. //Legal but dangerous

The fact that there are no references to null values means that using the referenced code is more efficient than using pointers. Because you do not need to test its legitimacy before using a reference.

[CPP]View Plaincopyprint?

1. void printdouble ( const double& rd)   
2. {  
3. Cout<< rd; //  do not need to test Rd, it    
4. }   //  must point to a double value   
5. &NBSP;&NBSP;
6. Instead, the pointer should always be tested to prevent it from being empty:   
7. void  printdouble (const DOUBLE&NBSP;*PD)   
8. {  
9. if  (PD)   
10. {//  check for null  
11. COUT<<&NBSP;*PD ;   
12. }  
13. }&NBSP;&NBSP;

Another important difference between pointers and references is that pointers can be re-assigned to point to another different object. But the reference always points to the object that was specified at initialization and cannot be changed later.

[CPP]View Plaincopyprint?

1. STRINGS1 ("Nancy");
2. STRINGS2 ("Clancy");
3. string& rs = s1; //RS reference S1
4. String *ps= &s1; //PS point to S1
5. rs = s2; //RS still references S1
6. //But the value of S1 is now "Clancy"
7. PS = &s2; //PS now pointing to s2;//S1 no change

In general, you should use pointers when you consider the possibility of not pointing to any object (in which case you can set the pointer to null), and you need to be able to point to different objects at different times (in which case you can change the pointer's direction). If you always point to an object and do not change the point once it points to an object, then you should use a reference.

Another case is that when you reload an operator, you should use a reference. The most common example is the operator []. The typical use of this operator is to return a target object, which can be assigned a value.

[CPP]View Plaincopyprint?

1. vector<Int>v (10); //Set up the shaping vector (vector), size is ten
2. //vector is a template in the standard C library (see article)
3. V[5] = 10; //The object that is assigned is the value returned by the operator []

If the operator [] returns a pointer, then the latter statement has to be written like this:

[CPP]View Plaincopyprint?

1. *V[5] = 10;

But that would make v look like a vector pointer. So you would choose to have the operator return a reference. (There is an interesting exception to this, see clause 30)

You should not use pointers when you know that you must point to an object and do not want to change its point, or if you overload the operator and are misunderstood to prevent unnecessary semantics. In other cases, you should use pointers.

The difference between a C + + reference and a pointer