Shulou(Shulou.com)05/31 Report--

This article introduces the knowledge of "how to use C++ quotation and what is the underlying principle". Many people will encounter this dilemma in the operation of actual cases. then let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Quote

A reference does not define a new variable, but gives a nickname to an existing variable. The compiler does not open up memory space for the reference variable, which shares the same memory space as the variable it references.

For example, Lu Zhishen is also called a "flower monk". The flower monk here is the same person as Lu Zhishen. The flower monk is Lu Zhishen's citation. To put it bluntly, citation is actually a nickname.

Considerations for referenc

1. References must be initialized

Int main () {int a tint & b = a;}

At this time b is the nickname of a.

The following uninitialized approach is wrong

Int main () {int & bbank / reference must be initialized, not initialized here. }

two。 A variable can have multiple references

In life, we may have multiple names. At home, your parents may call you by your nickname, while outside, others may call you by your full name or nickname.

In fact, a variable can have multiple nicknames, that is, it can have multiple references.

Int main () {int a tint & Bauda int & Centra;}

Here, b and c are nicknames for a, and the three variables benerary cpene an all point to the same block of memory space.

3. Once one entity is referenced, no other entity can be referenced.

Figuratively speaking, you and your own brother can't use the same name.

The following figure c is a reference to a, so now he cannot make a reference to b.

Reference as parameter

Before we talk about references as parameters, we need to understand the difference between parameter values and parameter references.

1. Parameter transfer value

The argument in the following figure passes a, and parameter b receives and modifies it, but argument an is not affected in the end. Why?

It turns out that when the parameter passes value, the parameter will produce a copy of the parameter data, that is to say, the parameter and the parameter point to the same space, so the modification of the parameter will not affect the parameter.

two。 Citing and passing parameters

The following figure refers to the parameters, and the modification of the parameters has an impact on the actual parameters. We can boldly speculate that the formal parameters and the actual parameters are a piece of space.

It turns out that when referencing parameters, the parameter is no longer a copy of the parameter, but a reference to the parameter, that is to say, the parameter and the parameter point to the same memory space, and the change of the parameter will affect the parameter.

The advantages and disadvantages of passing values and citations of actual parameters

1. Arguments pass values:

Disadvantages: the formal parameter will generate a copy of the actual parameter data, and when the amount of data is very large, it will affect the running speed of the program to a certain extent.

Advantages: because the parameter is a copy of the argument, the operation of the parameter will not affect the parameter, which can prevent the data of the parameter from being contaminated.

two。 Actual participation biography quote

Disadvantages: the operation of the parameter will have an impact on the argument, and the wrong operation of the parameter will cause the parameter data to be modified.

Advantages: because the formal parameter is the reference of the actual parameter, it can improve the running speed of the program.

Reference to return value of function

Before understanding the return value of a reference, we still have to understand the difference between passing a value return and passing a reference return. In fact, the principle is roughly the same as above.

1. Return by passing a value

When returning to c, instead of returning the body of c, it copies c in a temporary space, so what is returned is actually this temporary space. Then ret copies a space with the same data as this temporary space again.

This piece is a bit like a Russian doll and needs to be understood by drawing more pictures. I was a little confused at first, too. Draw more pictures and it will be clear.

But here comes the question: where is this temporary copy space stored?

When c is small (4 bytes or 8 bytes), it is usually stored in a register.

When c is large, the temporary variable is placed on top of the stack frame of the function.

Next, we prove it by observing the disassembly of the code:

After analyzing the assembly of this code, after entering the add function, we first give the value of a to eax, then add the value of b to a, and then give the value of eax to c. Finally, c is returned, and a temporary copy is made when c is returned, and c gives its own value to the register eax.

Finally, back to the main function, eax gives the value to ret.

Return by passing reference

What's going on here is pass reference and return, which means that ret is actually an alias for c. Passing a reference returns an ontology, not a copy. Because c is a local variable, after the end of the function, the stack frame is destroyed and the space of the local variable is reclaimed by the system. At this point, ret may access the contents of c again, which may cause illegal access, and the value of c may have been modified.

Figuratively speaking: you originally bought a house, and later you sold it to someone else, and later you want to enter the house again, but this house no longer belongs to you, and your operation into the house is an illegal visit.

Therefore, when passing a reference returns, the returned object cannot be recycled by the system on the output function. That is, the returned variable cannot be a local variable.

Referenced permissions

1. The permissions of references can be reduced.

Int main () {int a = 10 Const int & b = a Tincedanza / reduction of authority}

Here the variable an is readable and writable, and b is a reference to a. B can only read the memory space of a, but cannot modify it. This is the reduction of permissions, which is OK in C++.

two。 Referenced permissions cannot be magnified

Int main () {const int a = 10int & b = a politics / reduction of permissions}

Here, the space pointed to by the variable a can only be read and cannot be modified, while the reference b of a can be modified to make the permission enlarged. This syntax is wrong in C++.

Summary: references can reduce permissions, but not magnify permissions

Quoting classic pen test questions

Does the code (1) and (2) in the following figure work properly?

Double dancers 11.1 witint adept; (1) int & ret=d; (2)

Answer: (1) can run through, (2) No.

The code (1) is a normal implicit type conversion.

Before we understand the cause of the error in code (2), we need to review some knowledge:

The situation in which temporary variables are generated

1. Type conversion

Double dudes 11.1

Int axid

The type of d is double,a, the type is int, and the type is different. As shown in the following figure, when implicit type conversion occurs, you need to store the value of d in a temporary variable of type int, and then assign the value of this temporary variable to a.

two。 Plastic lifting

Int axi10

Char caterpillar b'

If (a > c) {

}

Instead of comparing c directly with a, C is assigned to a temporary variable of int, through which it is compared to a.

About right valu

Conclusion: the right value is constant and can not be modified.

The right value here cannot be understood literally (the value to the right of the formula). The following cases generally belong to the right value.

1. The result of the expression: for example: 5-3-8, where 8 is the right value.

two。 Constant: for example, aq5, where 5 is the right value.

3. Some temporary variables generated by implicit type conversions. Such as

Int a

Double d

Dempa

Here the temporary variable generated by the implicit type conversion is also a right value.

After understanding these fundamentals, we begin to learn why the code int & ret=d; (2) is wrong.

The variable referenced here is actually a temporary space, and the right value of the temporary space cannot be modified. This way of referencing is essentially a magnification of permissions, so the compilation cannot be passed.

The underlying principle cited is int main () {int a / int & b = a / t * p = & a;}

See the disassembly of this code in debug mode here.

The lea here means to take an address. As can be seen from the assembly code, when the reference is implemented, the reference and the pointer are implemented in the same way, so it is said that the underlying layer of the reference is implemented through the pointer.

This is the end of the content of "how to use C++ quotation and what is the underlying principle". Thank you for your reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.