Summary of C ++ learning points (II)

In the previous article, we have already introducedC ++The first half of the learning points summary is the C ++ learning points summary.) In this section, we will continue to introduce the second half:

16. The implementation of inline functions is similar to that of macros. When an inline function appears, expand the function to avoid the function calling from the stack, such as the stack, and improve the efficiency. But the cost of inline functions is: The Code increases. Inline functions are suitable for member functions and free functions. The functions implemented in the class are automatically inline functions. Inline must be defined on The Implementation of The function. For example, inline int PlusOne (int) is invalid. A friend function is automatically implemented as an inline function in the class body.

17. # include

 
 

  
  
#define DEBUG(X) cout<<#X"="<  
 
 

# X indicates that X is output as a string.

18. assert (0! = 0); if the condition in assert is false, the program is exited during running and the row number of the error code is reported. (# Include)

19. The static object calls its own destructor only when main ends or exit () is called. This means that it is very dangerous to call exit () in the destructor of an object and may enter an endless loop. Call abort () to exit the function. The static object destructor will not be called. We can use atexit () to specify the operations to be performed when jumping out of main or calling exit. Functions registered with atexit can be called before the destructor of all objects.

 
 

  
  
Void exit_fn2 (void)
  
  
{
  
  
Printf ("Exit function #2 called \ n ");
  
  
} // Processing functions
  
  
Atexit (exit_fn2 );
 
 

20. global variables actually use static storage. The construction of static variables is called before entering main, and its destructor is called at the end of main. Variable names are defined in a small scope (c ++ ):

 
 

  
  
// *. Cpp
  
  
Int a; // static variable, but extern int a; that is, it is global and externally visible
  
  
Static int B; // static variable. The opposite is static and extern, which is only valid in *. cpp and invisible to other units (files. The function definition is the same as above.
  
  
Main ()
  
  
{}
 
 

The static member variables of the class can be assigned the following values: int X: s = 23; (in *. cpp, both public and private can be used)

21. namespace: Define a namespace, and then use unsing to convert the current type context to the location specified by the namespace.

 
 

  
  
namespace math  
  
  
{  
  
  
enum sign{positive, negative};  
  
  
class integer{  
  
  
int i;  
  
  
sign s;  
  
  
public:  
  
  
interger(int I=0): i(i) {………}  
  
  
sign Sign() {………}  
  
  
…………………..  
  
  
};//end class  
  
  
interger A, B, C;  
  
  
interger divide(interger, interger);  
  
  
}//no ;  
  
  
void q()  
  
  
{  
  
  
using namespace math;  
  
  
interger A; //hides math::A  
  
  
A.Sign(negative);  
  
  
Math::A.Sign(positive);  
  
  
} 
 
 

22. Generally, for the flaot f (int a, int B) function, some c ++ compilers generate the name of _ f_int_int after compilation, and some c compilers generate the name of _ f. Therefore, when linking c library functions in c ++, use extern "C" to tell the compiler to compile functions according to the c Rules. Similar to extern "C" {# include "myhead. h"}, c ++ also supports extern "C ++ "{}.

23. When calling a function, passing a reference also forces the pointer to the stack.

24. The order in which constructor, destructor, value assignment constructor, and overloaded = are called: (all three functions have been implemented)

A) X x; X a = x;

 
 

  
  
result:  
  
  
X:construct  
  
  
X:copy_struct   
 
 

B) X x; X a; a = x;

 
 

  
  
Result:  
  
  
X:construct  
  
  
X:construct  
  
  
X:copy_stru  
  
  
operator =  
  
  
X:destruct 
 
 

If no constructor is assigned, the result is:

 
 

  
  
X:construct  
  
  
X:construct  
  
  
operator =  
  
  
X:destruct　  
 
 

(If X a = x directly, do not use a General constructor to call the copy constructor)

Pointer to the member function of the class: Set int X: a (void ){}

 
 

  
  
X x;  
  
  
int (X:: *pf)(void)= &X::a;  
  
  
(x.*pf)();  
 
 

Pointer to the member variable: Set int I; to the member variable of X

 
 

  
  
int X::*pm = &X::i;  
  
  
X x;