C ++ reference type

C ++ has one more class type than C: reference. This variable is not changed.
Pointer is not like a pointer. I didn't know much about it before. I was confused when I checked the program.
I have recently tried to learn more about the quote, and I think it is a little bit rewarding for beginners to share it with the community.
A reference refers to a reference to an object. So what is an object? In C ++, objects in the narrow sense refer
Variables declared using complex data types such as class, structure, and Union, such as myclass and cdialo
G mydlg. Generalized objects include variables declared using int, Char, float, and other simple types.
Such as int A and char B. The term "object" is a broad object. C ++
It is helpful for beginners to look at reference books by setting up the concept of this broad object.
Most books only use the word "object". For this word, there are two concepts: broad and narrow.
.

I. Reference Basic Features

First, let's declare a reference and use it to preliminarily understand the reference.
Example 1:
1. Int v, k, h;
2. Int & Rv = V;
3. Rv = 3; // at this time, the value of V is also changed to 3.
4. V = 5;
5. K = RV + 2; // K = 5 + 2 = 7.
6. H = 12;
7. Rv = h;
8. Rv = 20;
The first clause declares three objects (simple variables ).
The 2nd clause declares a reference named RV, which has the int type, or is
References the int type, and it is initialized to be "Bound" with the int type object v. R
V is called the reference of object v.
In the first sentence, the RV value is assigned to 3. The magic of reference is here, while changing the reference value
Changed the value of the object bound with the reference. So the value of V also changes to 3.
In the first sentence, the V value is changed to 5, and the reference value pointing to V is also changed to 5. Therefore
The value is 5 + 2 equals 7.

The preceding five sentences describe the relationship between the referenced and bound objects: they are linked in numerical values and change you.
It changes me, and it changes you. In fact, the reference of the access object and the access object is
Is used to access the same memory area.

Sentences 6, 7, and 8 describe another feature of reference: one end. What does it mean? When you reference
After a reference is bound to an object in the declaration statement
It can't be changed. So this is why I used the word "binding. Different pointers
. After the pointer is initialized to point to an object in the pointer declaration statement
You can also change it to another object. Therefore, assigning an RV value to h in the first sentence does not mean that this reference
The RV is rebound to H. In fact, the first sentence is just a simple assignment statement. After execution, RV and
The values of V are changed to 12. After 8th sentences are executed, the values of RV and V are both 20, while the values of H remain unchanged by 12.

There is also a feature for reference: the object to which the reference is bound must be initialized during declaration.
. We all know that the pointer can be declared without initialization, but cannot be referenced. Therefore, the following statements cannot be passed
Compiled:
Int V;
Int & RV;
Rv = V;

Another example:
Example 2:
Class myclass
{
Public:
Int;
...
...
};

Myclass;
Myclass & CC = myclass;
Myclass. A = 20; // equivalent to CC. A = 20
Cc. A = 60; // equivalent to myclass. A = 60

As shown in the preceding example, no matter how complicated the object is, you can reference or use the object.
The object itself is in the same syntax format. In essence, we use the same partition in the memory.
Domain.
The syntax for getting a referenced address is the same as that for getting an object address.
Symbol "&". For example:
Int I;
Int & Ri;
Int * Pi = & Ri; // This sentence serves the same purpose as int * Pi = & I.
Of course, getting the address of an object is the same as getting the address referenced by this object.
.

II. Function parameter transfer

Now let's further understand the reference through the function parameter transfer mechanism. In C ++, give a function
There are three methods for passing parameters: 1. Passing the object itself. 2. Pass the pointer to the object. 3. Passing objects
.
Example 3:
Class myclass
{
Public:
Int;
Void method ();
};

Myclass;

Void fun1 (myclass );
Void fun2 (myclass *);
Void fun3 (myclass &);

Fun1 (myclass); // After the function is called, myclass. A = 20 remains unchanged.
Fun2 (& myclass); // After the function is called, myclass. A = 60, changed.

Fun3 (myclass); // After the function is called, myclass. A = 80, changed.

// Pay attention to the real parameters of fun1 and fun3, and prove again: Use object and use Object Reference
The syntax format is the same.

Void fun1 (myclass MC)
{
MC. A = 40;
MC. Method ();
}

Void fun2 (myclass * MC)
{
Mc-> A = 60;
Mc-> method ();
}

Void fun3 (myclass & Mc)
{
MC. A = 80;
MC. Method ();
}
We have an object of the myclass type, myclass, and three functions, fun1, fun2, and fun3.
The functions must take the object itself as the parameter, the pointer to the object as the parameter, and the object reference as the parameter.
Number.

Please refer to the fun1 function. It uses the object itself as the parameter. This parameter passing method is called the value passing method.
. C ++ will generate a copy of The myclass object and pass the copy to the fun1 function. In fun1 Function
The member variable A of MC is modified internally, but the copied member variable A is not affected at all.
A is a member variable of myclass as a real parameter.
The fun2 function uses a pointer to the myclass type as a parameter. In this function, the MC Institute is modified
The member variable A of the object to be directed to. This actually modifies the member variable A of the myclass object.
Fun3 uses the reference of the myclass object as the parameter, which is called the reference transfer method. Modified
Member variable A of MC. As mentioned earlier, accessing an object and accessing the reference of this object are actually accessing
Ask about the same memory area, so this will directly modify the member variable A of myclass.

From the function bodies of fun1 and fun3, we can also see that using objects and using object references are in the syntax format
Is the same.

In fun1, C ++ transfers a copy of the real parameter to the form parameter. Therefore, if the real parameter occupies a large memory
System overhead in parameter passing will be very high. In fun2 and fun3
Only the address of the real parameter is passed to the parameter, which is four bytes at best.
Small.

3. Returns the referenced function.

Reference also has a very useful feature: If a function returns a reference type,
Functions can be used as left values. Don't worry about what is the left value. You just need to know: if an object
Or the expression can be placed on the left of the value assignment number, so this object and expression are called the left value.
Here is an example that is useless but very informative:
Example 4:
1. Int I;
2. Int & F1 (Int &);
3. Int F2 (INT );
4. F1 (I) = 3;
5. F2 (I) = 4;

Int & F1 (Int & I)
{
Return I;
}

Int F2 (int I)
{
Return I;
}
Compile the code and you will find that 4th sentences are correct and 5th sentences are wrong. For this example
The reference is passed to F1, and F1 returns the reference as it is. The meaning of the 4th sentence is the same as that of I = 3.

I checked the book and referenced this feature to be used in heavy-duty operators. However, I perform the reload operation
It is still confusing, so we cannot give an example.
Emphasize a small problem and see what is wrong with the following code:

Int & F1 ();

F1 () = 5;
...
...
Int & F1 ()
{
Int I;
Int & rI = I;
Return Ri;
}

Note that the reference Ri returned by function F1 is declared in the function body. Once the function returns
Number scope, RI points to the memory area, that is, the memory area occupied by object I is withdrawn, and then
An error occurs when you assign values to the disk memory area.

4. Conversion of reference

In the preceding example, all referenced types are int type, and these references are initialized to bind
To int type objects. Then we imagine whether a reference can be declared, which has the int type but is
Initialize an object bound to a float type? See the following code:
Float F;
Int & Rv = F;
The result shows that the conversion cannot be compiled by msvc ++ 6.0. However, the conversion of references is not completely different.
Possible, in fact, a reference of the base class type can be initialized and bound to a derived class object, as long as
Two conditions: 1. The specified base class is accessible. 2. The conversion is unambiguous. For example:
Example 5:
Class
{
Public:
Int;
};
Class B: public
{
Public:
Int B;
};
A oa;
B ob;
A & Mm = ob;
Mm. A = 3;

We have a base class A and a derived class B, and a base class Object OA and a derived class Object OB, we
It also declares a reference to mm, which has a base class type but is bound to the derived class Object ob. Because of our
Both classes are very simple and satisfy the two conditions. Therefore, this code is legal. In this example,
Mm and the base class sub-objects in the derived class ob share a memory unit. Therefore, the statement mm. A = 3 is equivalent
Ob. A = 3, but the expression mm. B is invalid, because the base class sub-object does not include the member of the derived class.
.

5. Summary

Finally, let's summarize the references:
1. Objects and object references are a thing in a sense.
The same memory zone is accessed.
2. The syntax format of using an object is the same as that of using an object reference.
3. The reference must be initialized.
4. After a reference is bound to an object during initialization, it can only be bound to this object forever.
5. The reference of the base class type can be bound to the object of the derived class of the base class, as long as the base class and the derived class meet
The two conditions mentioned in this article. In this case, the reference is actually a reference of the base class sub-object in the derived class object.
.
6. When passing an object reference to a function, only the address of the object is passed.
Low Consumption. Accessing the form parameter in the function body actually accesses this object as the real parameter.
7. If a function returns a reference, the function call expression can be used as the left value.

Sat. Others
1. The code in this article has been debugged and verified in msvc ++ 6.0.
2. Example in Section 4 "conversion of reference:
Float F;
Int & Rv = F;
It is said that it is legal to view information of BC ++ 3.1. At this time, the compiler generates a temporary Float Type
The reference RV is bound to this temporary object. That is to say, RV is not a reference of F. Unknown
What is the use of this feature in Dao BC ++ 3.1.
3. You can declare this reference in msvc ++ 6.0:
Const Int & Rv = 3;
The value of RV is 3 and cannot be changed. This may be useless. Because if we want
If you use a symbol to represent constants, some are more common methods:
# Define RV 3
4. Modify the example in Section 4 slightly:
Float F;
Int & Rv = (Int &) F;
In this case, you can use msvc ++ 6.0 for compilation. At this time, the RV is bound to F, and the RV and F share one
Storage area. However, because the type of the referenced RV is int, when the RV accesses this storage area
Is interpreted as an integer. when accessing this bucket through F, the content of the bucket is interpreted as a real number.