The difference between pointers and references (c + +)

http://blog.csdn.net/thisispan/article/details/7456169

★ 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).

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).

int m;

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.

int i = 5;

Int J = 6;

int &k = i;

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.

void Func1 (int X) { x = x + 10; } int n = 0; Func1 (n); 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.

void Func2 (int *x) { (* x) = (* x) + 10; } & #8943; int n = 0; FUNC2 (&n); cout << "n =" << n << endl; n = 10

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.

void Func3 (int &x) { x = x + 10; } & #8943; int n = 0; Func3 (n); cout << "n =" << n << endl; n = 10

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.

——————————

Excerpt from "high quality C + + programming"

Pointers and references, in the moreeffective C + + clause i'll give you the Details.

Article one: the difference between a pointer and a reference

Pointers and references look completely different (pointers are using the operator ' * ' and '-a ', referencing the operator '). '), but they seem to have the same function. 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?" ”

Char *pc = 0;//sets the pointer to a null value

char& rc = *pc;//to Point A reference 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.

string& rs;//error, reference must be initialized

string S ("xyzzy");

string& rs = s;//correct, Rs pointing s

Pointers do not have such a limitation.

String *ps;//uninitialized pointer

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.

void printdouble (const double& rd) { cout << rd; You do not need to test rd, it }//must point to a double value instead, The pointer should always be tested to prevent it from being empty: void printdouble (const Double *pd) { If (pd) {//check if NULL cout << *pd; } }

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.

String S1 ("Nancy"); String S2 ("Clancy"); string& rs = s1; RS reference S1 String *ps = &s1; PS Pointing S1 rs = s2; RS still cites s1, But the value of S1 is now "Clancy" PS = &s2; PS Now points to s2; S1 hasn't changed.

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.

Vector<int> v (10); Set up the shaping vector (vector), the size of 10; A vector is a template in the standard C library (see clause 35) v[5] = 10; The target 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: *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. And in other cases, you should use pointers to assume that you have

void func (int* p, int&r); int a = 1; int B = 1; Func (&a,b);

The value of the pointer itself (address Value) is Passby value, You can change the address value, but this does not change the value of the variable pointed to by the pointer,

p = someotherpointer;//a is still 1

But you can use the pointer to change the value of the variable pointed to by the pointer,

*p = 123131;//a now is 123131

But the reference itself is carried out by pass byreference, changing its value to change the value of the variable that the reference corresponds to.

R = 1231;//b now is 1231

Use references whenever possible, and use pointers when you have to.

When you do not need to "re-point", the reference generally takes precedence over the pointer being Selected. This usually means that referencing a public interface for a class is more Useful. The typical scenario where a reference occurs is the surface of the object, and the pointer is used inside the Object.

The exception above is when a Function's argument or return value requires a "critical" reference. It is usually better to return/get a pointer and use a NULL pointer to accomplish this particular Mission. (a reference should always be an alias for an object, not a null pointer that is dereferenced).

Note: Traditional C programmers sometimes do not like references because they do not provide clear citation semantics at the Caller's Code. however, when you have some C + + experience, you will soon realize that this is a form of information hiding, which is beneficial rather than harmful. As is the case, the programmer should write code for the problem to be solved, not the machine itself.

The difference between pointers and references (c + +)