The difference between pointers and references in C + +

The difference between pointers to different types is that the pointer type knows what the compiler interprets in memory content and size in a particular address (the address the pointer points to), whereas the void* pointer represents only one memory address, and the compiler cannot pass the pointer to the object's type and size, so you want to pass void* The pointer manipulation object must be type-converted.  ★ 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;A reference is an alias for 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&) constant is true, but when referenced as a class member name, it occupies 4 bytes of space with the pointer (no standard rule 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. 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 more effective C + + clauses I'll give you a turn around. 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;//set pointer to null valuechar& 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 void printdouble (const double *PD) {      if (PD)      {//check whether null     } }

   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 in the following situations, One is that you consider the possibility of not pointing to any object (in which case you are able to set the pointer to null), The second is that you need to be able to point to different objects at different times (in this case, you can change the pointer 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 article No.)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 (the address value) is done with pass by 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 However, the reference itself is carried out by the pass by reference, 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).  

The difference between pointers and references in C + +