C ++ references

References
Reference is an important extension of C ++ to C language.

I. Concepts of reference

Reference introduces a synonym for an object. The expression of the definition reference is similar to the definition pointer, but it is replaced *.

Example: Point pt1 (10, 10 );

Point & pt2 = pt1; defines a reference where pt2 is pt1. With this definition, pt1 and pt2 indicate the same object.

It is important to note that references do not generate copies of objects, but are only synonyms of objects. Therefore, after the current statement is executed:

Pt1.offset (2, 2 );

Both pt1 and pt2 have (12, 12) values.

The reference must be initialized immediately during definition because it must be a synonym for something. You Cannot initialize a reference before defining it. For example, the following statement is invalid:

Point & pt3;

Pt3 = pt1;

So what is the purpose of referencing a synonym for something?

The following two main purposes of reference are discussed: as a function parameter and return the left value from the function.

Ii. Reference parameters

1. Passing variable parameters

In traditional C, parameters are passed through values when a function is called, which means that the function parameters do not have the ability to return values.

Therefore, in traditional C, if function parameters are required to have the ability to return values, they are usually implemented through pointers. For example

The C program for the exchange of two integer values is as follows:

Void swapint (int * a, int * B)

{

Int temp;

Temp = *;

* A = * B;

* B = temp;

}

After the reference mechanism is used, the C ++ version of the above program is:

Void swapint (Int & A, Int & B)

{

Int temp;

Temp =;

A = B;

B = temp;

}

The C ++ method that calls this function is: swapint (x, y); C ++ automatically transmits the address of X and Y to the swapint function as a parameter.

2. Passing large objects to Functions

When a large object is passed to a function, you can use the reference parameter to improve the parameter transfer efficiency, because the reference does not produce a copy of the object, that is, when the parameter is passed, the object does not need to be copied. The following example defines a class with a finite Integer Set:

Const maxcard = 100;

Class Set

{

Int elems [maxcard];
// The element in the set. maxcard indicates the maximum number of elements in the set.

Int card; // The number of elements in the set.

Public:

Set () {card = 0;} // Constructor

Friend set operator * (set, set); // reload operator number *, used to calculate the intersection of a set, using an object as a value passing Parameter

// Friend set operator * (set &, set &) overload operator number *, used to calculate the intersection of sets and use the object reference as the value passing Parameter

...

}

First consider the implementation of set intersection

Set operator * (set set1, set set2)

{

Set res;

For (INT I = 0; I <set1.card; ++ I)

For (Int J = 0; j> set2.card; ++ J)

If (set1.elems = set2.elems [J])

{

Res. elems [res. Card ++] = set1.elems;

Break;

}

Return res;

}

Since the overload operator cannot operate the pointer independently, we must declare the number of operations as the set type rather than set *.

 

When * is used for intersection operations, the entire set is copied, which is very inefficient. We can use references to avoid this situation.

Set operator * (set & set1, set & set2)

{Set res;

For (INT I = 0; I <set1.card; ++ I)

For (Int J = 0; j> set2.card; ++ J)

If (set1.elems = set2.elems [J])

{

Res. elems [res. Card ++] = set1.elems;

Break;

}

Return res;

}

Iii. Reference return values

If a function returns a reference, the function call can also be assigned a value. Here is a function that has two reference parameters and returns a double-precision reference:

Double & MAX (double & D1, double & D2)

{

Return D1> D2? D1: D2;

}

Because the max () function returns a reference to the Double Precision number, we can use max () to add 1 to the large double precision number:

Max (x, y) + = 1.0;
 
Ii. References
 
Reference is a new language feature introduced by C ++. It is one of the important content commonly used in C ++. Correct and flexible use of reference can make the program concise and efficient. In my work, I found that many people only take it for granted. In some subtle occasions, it is easy to make mistakes. The reason is mostly because they have not figured out their origins. Therefore, I will discuss references in detail in this article, hoping to help you better understand and use references.

References

A reference is an alias of a variable (target). The referenced operation is exactly the same as the direct operation on a variable.

Declared method: type identifier & reference name = target variable name;

[Example 1]: int A; Int & RA = A; // defines reference Ra, which is a reference of variable A, that is, alias

Note:

(1) & this is not an address calculation, but an identifier.

(2) type identifier refers to the type of the target variable.

(3) When declaring a reference, it must be initialized at the same time.

(4) After the reference declaration is complete, it is equivalent that the target variable name has two names, namely, the original name and reference name of the target, and the reference name cannot be used as the alias of other variable names.

Ra = 1; equivalent to a = 1;

(5) declaring a reference is not a new variable. It only indicates that the reference name is an alias of the target variable name. It is not a data type, therefore, the reference itself does not occupy storage units, and the system does not allocate storage units to the reference. Therefore, finding the address for the reference is to find the address for the target variable. & RA and &.

(6) arrays cannot be referenced. An array is a collection composed of several elements, so an array alias cannot be created.

Reference Application

1. Reference as a parameter

An important role of reference is as a function parameter. In the previous C language, function parameter transfer was a value transfer. If a large piece of data is used as a parameter transfer, a pointer is often used, because this avoids the whole piece of data from being pushed to the stack, it can improve program efficiency. But now (in C ++), another option that is equally efficient (which is required in some special cases) is reference.

[Example 2 ]:

Void swap (Int & P1, Int & p2) // The parameter P1 and P2 of the function are referenced.
{Int P; P = p1; P1 = P2; P2 = P ;}

To call this function in a program, the call point of the corresponding main function can be directly called using the variable as the real parameter, without any special requirements on the real variable. For example, the swap function defined above can be written as follows:

Main ()
{
Int A, B;
Cin> A> B; // enter the values of A and B.
Swap (a, B); // directly call the swap function using variables A and B as real parameters.
Cout <A <<'' <B; // output result
}

When the above program is running, if the input data is 10 20 and then press enter, the output result is 20 10.

As shown in [Example 2:

(1) passing a reference to a function has the same effect as passing a pointer. In this case, the parameter of the called function becomes an actual parameter variable or an alias of the object in the original main function, therefore, the operations on the parameters in the called function are the operations on the corresponding target object (in the main function.

(2) using the reference parameter to pass the function does not generate a copy of the real parameter in the memory, it is directly to operate on the real parameter; while using the general variable to pass the function parameter, when a function call occurs, you need to allocate storage units to the parameters. The parameters are copies of the real variables. if the object is passed, the copy constructor will also be called. Therefore, when the data transmitted by a parameter is large, it is better to use reference than to transmit a parameter using a common variable.

(3) Although using pointers as function parameters can achieve the same effect as using references, in the called function, storage units must be allocated to the parameters, you need to use the '* pointer variable name' format to perform operations again, which can easily produce errors and the program reading is poor. On the other hand, at the call point of the main function, the variable address must be used as the real parameter. References are easier to use and clearer.

If you want to use references to improve program efficiency and protect the data transmitted to the function from being changed in the function, you should use regular references.

2. Frequent reference

Common Reference declaration method: const type identifier & reference name = target variable name;

The reference declared in this way cannot be modified by reference to the value of the target variable, so that the referenced target becomes const, achieving the security of reference.

[Example 3 ]:

Int;
Const Int & RA =;
Ra = 1; // Error
A = 1; // correct

This is not just to make the code more robust, but also some other needs.

[Example 4]: assume that the following function declaration is available:

String Foo ();
Void bar (string & S );

The following expression is invalid:

Bar (FOO ());
Bar ('Hello World ');

The reason is that both the Foo () and 'Hello world' strings generate a temporary object. In C ++, these temporary objects are of the const type. Therefore, the above expression tries to convert a const type object to a non-const type, which is invalid.