C + + reference, inline function, function overload summary of ambiguity _c++

1. References

1.1 Concepts of references

In the C + + language, you can define references. The references are defined as follows:

Type name & Reference name = A variable name of the same type;

For example: int n;

int &r=n;//r is a reference, you can say that the type of R is int &,r refers to the variable n, or R becomes a reference to N.

A reference to a variable is one thing, the equivalent of an alias for that variable. Note that it is important to initialize a reference when it is defined, otherwise the compilation does not pass, and usually a variable is used to initialize the reference, and after initialization it references the variable and no longer references another variable. You can also use a reference to initialize another reference so that two references refer to the same variable. A reference cannot be initialized with a constant, nor can it be initialized with an expression (unless the return value of the expression is a reference to a variable). In summary, references can only reference variables.

References of type T & are fully compatible with variables of type T and can be assigned to each other.

The sample programs referenced are as follows:

2. #include <iostream>
4. using namespace Std;
6. int main ()
8. {
10. int n=4;
12. int &r=n; R refers to N, since R and N are the same thing.
14. R = 4; modifying r is modifying n
16. cout<<r<<endl; Output 4
18. cout<<n<<endl; Output 4
20. n = 5; modifying n is modifying R
22. cout<<r<<endl; Output 5
24. int &r2 = r; R2 and R refer to the same variable n
26. cout<<r2<<endl; Output 5
28. return 0;
30. }

1.2 Reference as the return value of a function

The return value of a function can be a reference, such as the following program:

2. #include <iostream>
4. using namespace Std;
6. int n = 4;
8. int & Setvalue ()
10. {
12. return n; Returns a reference to n
14. }
16. int main ()
18. {
20. Setvalue () = 40; The return value is a referenced function call expression that can be used as an lvalue
22. cout<<n<<endl; Output 40
24. int &r = Setvalue ();
26. cout<<r<<endl; Output 40
28. return 0;
30. }

1.3 Parameter pass-through value

A "pass value" means that a function's formal parameter is a copy of the argument, and the change of the parameter does not affect the argument during the execution of the function. Take a look at the example:

2. #include <iostream>
4. using namespace Std;
6. void Swap (int a,int b)
8. {
10. int temp;
12. Temp=a;
14. A=b;
16. B=temp;
18. cout<<a<<b<<endl;
20. }
22. int main ()
24. {
26. int a=4,b=5;
28. Swap (A, b);
30. cout<<a<<b<<endl;
32. return 0;
34. }

The output of the above program is:

5 4

4 5

In the swap function, the value of the formal parameter, a, or a is indeed interchanged, but A/b in main maintains the original value, that is, the change of the formal parameter does not affect the argument.

1.4 Parameter Passing Reference

In the way of reference, the formal parameter is a reference to the corresponding argument, that is, the formal parameter and the corresponding argument is one thing, then the change of the parameter will change the value of the argument. For example:

2. #include <iostream>
4. using namespace Std;
6. void Swap (int &a,int &b)
8. {
10. int tmp;
12. TMP = A;a = B;B = tmp;
14. }
16. int main ()
18. {
20. int n1=100,n2=50;
22. Swap (N1,N2);
24. cout<<n1<<n2<<endl; Output 50 100
26. }

After entering the swap function, a refers to the n1,b reference to the change in n2,a,b that affects the value of N1,N2.

2. Inline functions

The use of functions can reduce the volume of code, but also bring the cost of running time, if a function inside the statement is very small, the execution time is very short, then call this function time can not be ignored, in the C + + language, "inline" is a good solution to the problem of function call overhead. A function that adds "inline" is called an inline function, for example:

inline int max (int a,int b);

The effect of adding inline is equivalent to inserting the statement code of the function into the call place at compile time, reducing the access time after allocating space to the variable, but the inline is only suitable for short functions, and for more functions of the statement, if the use of inline, equivalent to pay to increase the volume of several times the cost , but the speed is only increased by one out of 10,000, not worth the candle, sometimes the function looks very simple, but contains the loop to use many times, to consume a lot of time, also not suitable for inline functions. So the intrinsic feature of the inline function is that the code is simple and executes quickly.

3. Overloading of functions

The C + + language does not allow variable names, but allows multiple functions to take the same name, as long as the parameter table is different, which is called the overload of the function. Equivalent to the same thing to accomplish different functions.

So when invoking a function of the same name, how does the compiler call which function? Very simply, the compiler is judged by the number and type of arguments in the function invocation statement. Because the parameter table of an overloaded function is different, it is called whenever a statement of the calling function gives an argument and a parameter table match. For example:

2. #include <iostream>
4. using namespace Std;
6. int max (int a,int b)
8. {
10. cout<<max1<<endl;
12. }
14. Double Max (double a,double b)
16. {
18. cout<<max2<<endl;
20. }
22. Double Max (double a,double b,double c)
24. {
26. cout<<max3<<endl;
28. }
30. int main ()
32. {
34. Max (3,4); Call int max (int, int)
36. Max (2.4,6.0); Call Double Max (double, double)
38. Max (1.2,3.4,5); Call Double Max (double, double, double)
40. Max (n/a); Call Double Max (double, double, double)
42. Max (3,1.5); Ambiguity!!!!!!!
44. return 0;
46. }

Ambiguity analysis: In line 21st, the compiler calls int max (int, int), as long as the 1.5 is coerced, the call to double Max (double, double) is also possible, at which point the compiler does not know which function to invoke, and therefore two is ambiguous.

There are two functions with the same name and different number of parameters, but the parameters of the function with many parameters can also be used by default, two semantics may occur, for example:

int sum (int a,int b,int c=0);

int sum (int n,int m);

This is called:

sum (in);

At this point the compiler does not know whether to call the first function as a parameter (1,2,0) or call the second function, resulting in two semantics!

C + + reference, inline function, function overload summary of ambiguity _c++