Describes the differences between C ++ local classes and C ++ Nested classes.

If the relationship between the nested type and its external type requires the accessible semantics of members, the C ++ nested class is required. The nested type should not execute tasks for types other than its declared type, C ++ local classes allow classes, structures, and interfaces to be divided into multiple small blocks and stored in different source files. This implementation is easy to develop and maintain.

C ++ local class:
Classes defined in a function are called local classes. In a local class, only objects and functions in its peripheral scope can be associated, because the variables in the peripheral scope are irrelevant to the objects in the department class. Local classes cannot be inherited by external entities. When defining a local class, note that static member functions cannot be described in the local class, and all member functions must be defined in the class body. In practice, local classes are rarely used. The following is an example of a local class.

 
 

  
  
Int;
  
  
Void fun ()
  
  
{
  
  
Static int s;
  
  
Class
  
  
{
  
  
Public:
  
  
Void init (int I ){S=I;}
  
  
};
  
  
A m;
  
  
M. init (10 );
  
  
}
  
  
 
  
  
 
  
  
Another use of local classes is to implement type conversion. The following code:
  
  
 
  
  
Class Interface
  
  
{
  
  
Public:
  
  
Virtual void Fun () = 0;
  
  
};
  
  
 
  
  
Template<ClassT, class P> 
  
  
Interface * MakeAdapter (const T & obj, const P & arg)
  
  
{
  
  
Int x;
  
  
Class Local: public Interface
  
  
{
  
  
Public:
  
  
Local (const T & obj, const P & arg)
  
  
: Obj _ (obj), arg _ (arg ){}
  
  
Virtual void Fun ()
  
  
{
  
  
X=100;
  
  
Obj _. Call (arg _);
  
  
}
  
  
Private:
  
  
T obj _;
  
  
P arg _;
  
  
};
  
  
Return new Local (obj, arg );
  
  
}
 
 

C ++ nested class:
The class defined in a class is called the C ++ nested class, and the class defining the nested class is called the peripheral class. The purpose of defining a nested class is to hide the class name and reduce the global identifier, so as to limit whether users can use this class to create objects. This improves the class abstraction capability and emphasizes the master-slave relationship between two classes (peripheral class and nested class. The following is an example of a nested class:

 
 

  
  
　class A  
  
  
 {  
  
  
 public:  
  
  
class B  
  
  
 {  
  
  
public:  
  
  
…  
  
  
private:  
  
  
…  
  
  
};  
  
  
void f();  
  
  
private:  
  
  
int a;  
  
  
} 
 
 

Several descriptions of Nested classes:
1. From the perspective of scope, the nested class is hidden in the peripheral class, and the class name can only be used in the peripheral class. If you use this class name within the scope of the peripheral class, you need to apply a name restriction.

2. From the perspective of access permission, the nested class name has the same access permission rules as the object member name of its peripheral class. You cannot access private member functions of nested class objects or create objects for nested classes in the private section of the peripheral class.

3. The member functions in the C ++ nested class can be defined in the external body of the class.

4. The members in the nested class are not members of objects in the peripheral class, and vice versa. The member functions of the nested class have no access to the members of the peripheral class, and vice versa. When analyzing the access relationships between Nested classes and peripheral classes, the nested classes are often treated as non-nested classes. In this way, the preceding Nested classes can be written in the following format:

 
 

  
  
class A  
  
  
{  
  
  
public:  
  
  
void f();  
  
  
private:  
  
  
int a;  
  
  
};  
  
  
 
  
  
class B  
  
  
{  
  
  
public:  
  
  
…  
  
  
private:  
  
  
…  
  
  
}; 
 
 

As you can see, nested classes are only syntactically embedded.

5. The friends stated in the C ++ nested class do not have access to the members of the peripheral class.

6. If the nested class is complex, you can only describe the nested class in the peripheral class. The detailed content about nesting can be defined in the file domain of the peripheral class in vitro.

1. Differences between standard input implementation methods in C and C ++
2. How does the C ++ compiler allocate storage space for Const constants?
3. Basic Conception and method of C ++ Class Library Design
4. Several Methods for converting C ++ Language
5. How to better compile C ++ code