C ++ BASICS (1)

InC ++Class, that is, the class of the custom type (referred to as the class), which has no difference with the structure at all, but is explained in the next article ), the reason for providing a class is actually because C ++ is extended from C, and the class is a very important concept proposed by C ++, the keyword struct is reserved only for compatibility with the C language.

For the time being, we can first consider that the great progress of the structure of the class is that the concept of member functions can be added, although the structure can also have member functions). Before learning about member functions, we should first look at a semantic requirement.

Operations and resources

The program is mainly composed of operations and operated resources, and the operator is the CPU, which is normal, but sometimes there are some needs, it must be manifested that a resource has operated on another resource and is temporarily called an operator. For example, in a game, it is often used to map monsters to Attack Players. Generally, this operation requires the operator to modify the operator or use the information recorded by the operator to complete the operation. For example, the attacking power of the monster determines the status of the player after the attack. This Semantics indicates that the operator has certain functions. To implement the preceding semantics, as previously mentioned in ing, the ing between monsters and players is structured as follows:

 
 

  
  
struct Monster { float Life; float Attack; float Defend; };  
  
  
struct Player { float Life; float Attack; float Defend; }; 
 
 

The above attack operations can be mapped to void MonsterAttackPlayer (Monster & mon, Player & pla );. Note that the function name is expected to be used to represent the operator, but it is similar to the previous article to name the cross-river scheme sln, because the semantics should be represented by the Type rather than the function name. Therefore, C ++ provides the concept of member functions.

Member Functions

As before, writing the declaration statement of a function in a type definition operator defines a member function, as shown below:

 
 

  
  
struct ABC { long a; void AB( long ); }; 
 
 

The above defines a ing element -- the first variable ABC: a, the type is long ABC:; and declares a ing element -- the second function ABC: AB, the type is void (ABC:) (long ). The Type modifier ABC: modifies the ABC: AB function here, indicating that it is the offset type of the function type, that is, a relative value. But because it is a function, the meaning is different from the variable, that is, it is still mapped to the address Code address in the memory), but because it is an offset type, that is, relative, that is, incomplete, therefore, function operators cannot be applied to it, such:

 
 

  
  
ABC::AB( 10 ); 
 
 

Here, it will be wrong, because ABC: AB is relative. Its relative content is not a memory address as a member variable, but a parameter of the structure pointer type. The parameter name is set to this, this is forcibly defined and will be explained later.

Note that because its name is ABC: AB, and the above is just to declare it, to define it, it is still the same as the previous function definition, as shown below:

 
 

  
  
void ABC::AB( long d ) { this->a = d; } 
 
 

Note that the name of the above function is ABC: AB, but like the member variables mentioned earlier, long ABC: a; cannot be written directly ;, in this case, you cannot directly write the Definition Statement of the function above. At least the name of the function is ABC: AB, which does not comply with the identifier rules). Instead, you must first define the custom type through the type definition character, write the statement later.

Note that the keyword "this" is used above, and its type is ABC *, which is automatically generated by the compiler. That is, the above function definition is actually equivalent

 
 

  
  
void ABC::AB( ABC *this, long d ) { this->a = d; } 
 
 

The reason why the declaration of this parameter should be omitted, and the compiler is responsible for the purpose of reflecting the semantics mentioned above, that is, the meaning of the member, in the Code) is also called ABC :: AB is the offset type of the function type. It is relative to this parameter:

 
 

  
  
ABC a, b, c;   
  
  
a.ABC::AB( 10 );   
  
  
b.ABC::AB( 12 );   
  
  
c.AB( 14 ); 
 
 

The above uses the member operator to call ABC: AB. Note that after execution,. a, B. a and c. the values of a are 10, 12, and 14 respectively, that is, ABC: AB is called three times, but the value of this parameter three times is different through the member operator, then, the member variable a of the three ABC variables can be modified. Note the above

 
 

  
  
a.ABC::AB( 10 ); 
 
 

Like member variables, since the left and right types must correspond to each other, you can

 
 

  
  
a.AB( 10 ); 
 
 

Note that When ABC: AB is defined above, it should be written in the function body.

 
 

  
  
this->a = d; 
 
 

Same as above, because the type must correspond to the relationship, that is, this must be a pointer to the corresponding custom type, so you can also omit this-> writing, and then there are

 
 

  
  
void ABC::AB( long d ) { a = d; } 
 
 

Note that the function of the member operator is not to return a number of the corresponding member variable type when it is a member variable, but to return a number of the function type, however, the difference is that this function type cannot be expressed in syntax, that is, C ++ does not provide any keyword or type modifier to indicate that the returned type VC provides the _ thiscall type modifier internally, but it cannot be used when writing code, only used internally by the compiler ).

That is to say, when the right side of the member operator is a number of the function type offset type, a number of the function type is returned to indicate that the member operator can be applied ), the function type is the type given in the offset type, but this type cannot be displayed. A. AB returns a number, which is a function type. In VC, its type is void (_ thiscall ABC:) (long ), however, this type is invalid in C ++.

C ++ does not provide keywords like _ thiscall to modify the type, because this type requires the compiler to encounter function operators and member operators, such

 
 

  
  
a.AB( 10 ); 
 
 

The address on the left of the member operator should be passed in as the first parameter of the function call, and the other parameters given in the function operator should be passed in. That is, this type provides the compiler with some information to generate the correct code for the function operator and member operator at the same time, without modifying numbers, you must be able to cope with all situations ). That is, the type is used to modify numbers, and this type cannot modify numbers. Therefore, C ++ does not provide a keyword similar to _ thiscall.

As before, because ABC: AB maps an address rather than an offset value, you can

 
 

  
  
ABC::AB; 
 
 

But not

 
 

  
  
ABC::a; 
 
 

Because the latter is the offset value. Based on the type match, it is easy to know that there are also:

 
 

  
  
Void (ABC: * p) (long) = ABC: AB;
  
  
Or
  
  
Void (ABC: * p) (long) = & ABC: AB;
 
 

Then there will be:

 
 

  
  
void ( ABC::**pP )( long ) = &p; ( c.**pP )( 10.0f ); 
 
 

Brackets are added because the priority of function operators is higher. Recall that the previous article said that the conversion of pointer types only changes the type, and the value remains unchanged. The next article describes the changes in the value. Therefore, the following code can be used. This code is meaningless, here, we only need to deepen our understanding of member functions.

 
 

  
  
struct ABC { long a; void AB( long ); };  
  
  
void ABC::AB( long d )  
  
  
{  
  
  
　 this->a = d;  
  
  
}  
  
  
struct AB  
  
  
{  
  
  
　 short a, b;  
  
  
　 void ABCD( short tem1, short tem2 );  
  
  
　 void ABC( long tem );  
  
  
};  
  
  
void AB::ABCD( short tem1, short tem2 )  
  
  
{  
  
  
　 a = tem1; b = tem2;  
  
  
}  
  
  
void AB::ABC( long tem )  
  
  
{  
  
  
　 a = short( tem / 10 );  
  
  
　 b = short( tem - tem / 10 );  
  
  
}  
  
  
void main()  
  
  
{  
  
  
　 ABC a, b, c; AB d;  
  
  
　 ( c.*( void ( ABC::* )( long ) )&AB::ABC )( 43 );  
  
  
　 ( b.*( void ( ABC::* )( long ) )&AB::ABCD )( 0XABCDEF12 );  
  
  
　 ( d.*( void ( AB::* )( short, short ) )ABC::AB )( 0XABCD, 0XEF12 );  
  
  
} 
 
 

After the above execution, c. a is 0X00270004, B. a is 0X0000EF12, d. a is 0 XABCD, and d. B is 0 XFFFF. For function calls of c, because the address mapped by AB: ABC is directly converted to the type and used directly, the program will jump

 
 

  
  
a = short( tem / 10 ); 
 
 

Start execution, and the parameter tem maps the first address of the memory that passes the parameter, and then uses the long type to explain and get the tem as 43, and then runs.

Note:

 
 

  
  
b = short( tem - tem / 10 ); 
 
 

Actually

 
 

  
  
this->b = short( tem - tem / 10 ); 
 
 

The value of this is the address corresponding to c, but here it is considered to be AB * type because in function AB: ABC ), so this-> B normal ABC structure does not have B member variable), and B's offset is 2, therefore, after the preceding statement is executed, the result 39 is stored in the c address and the memory corresponding to 2, and the 16-bit binary data is stored in the short type.

For

 
 

  
  
a = short( tem / 10 ); 
 
 

Do the same thing, so the value of c. a is 0X0027004 decimal 39 to hexadecimal 0X27 ).

Similarly, for B's call, the program will jump to AB: ABCD, but when B's call code is generated, record the parameter 0XABCDEF12 in the memory of the passed parameter in the long format, and then jump to AB: ABCD. However, when AB: ABCD is compiled, the corresponding addresses of the tem1 and tem2 parameters are mapped based on the two short types. Therefore, it is easy to think that the value of tem1 is 0XEF12, the value of tem2 is 0 XABCD, but this is not the case.

Next Article>