How to link different types of objects to the C ++ linked list

It seems that you have noticed that, no matter how defined, it is likeC ++ linked listInObjectAre of the same type. In fact, this is also necessary. Otherwise, what is the type of the return value of a function such as the data in the returned node? However, human requirements are endless. The purpose of putting different object chains in a linked list is to make it easy to use. Now we must remember this principle. The subsequent discussions are based on this principle.

The principle of achieving this goal is actually very simple. You only need to change different types of objects to the same type. See the following structure definition:

 
 

  
  
struct Mobject  
  
  
{  
  
  
       void *p;  
  
  
       int ObjectType;  
  
  
}; 
 
 

When an object is linked to a linked list, the pointer pointing to this object is assigned to p, and the object type is recorded. When this node is obtained, the object type indicated by p is determined based on the ObjectType value, so as to restore the pointer type and obtain the original object.

The generalized table mentioned later actually uses this method. Obviously, the objects supported by such Mobject are pre-determined. You will maintain the ObjectType list by yourself, and each time you add a type of support, you need to give an alternative value in the ObjectType list, and then give this type of case statement in the corresponding switch (ObjectType. It's annoying, right? Another method is provided below. In fact, it's still the principle. The difference is that the annoying work is handed over to the compiler.

Do you still remember the principles highlighted in the front? Why do we put different types of objects in a linked list? Obviously, we want to achieve this: for example, we store triangle, straight line, circle, and other graphical parameters in a linked list. We want to use Draw () for a node () method to reproduce the image. Get () is used to obtain the parameters of the image. Put () is used to modify the parameters of the image. It can be seen that these different objects actually have the same behavior, but the implementation method is different.

The polymorphism of C ++ can achieve our vision. For more information, see related C ++ books (I am reading C ++ programming ideas). See the following example:

 
 

  
  
#ifndef Shape_H   
  
  
#define Shape_H   
  
  
class Shape     
  
  
{   
  
  
public:   
  
  
       virtual void Input() = 0;   
  
  
       virtual void Print() = 0;   
  
  
       Shape(){};   
  
  
       virtual ~Shape(){};   
  
  
};   
  
  
#endif   
 
 

Description: defines an abstract base class, which has two behaviors: Input () is the Input image parameter, and Print () is the Print Image parameter. It is easy to explain the problem.

 
 

  
  
# Ifndef Point_H  
  
  
# Define Point_H  
  
  
ClassPoint 
  
  
{ 
  
  
Public: 
  
  
VoidPut () 
  
  
{ 
  
  
Cout <"X coordinate :"; 
  
  
Cin> x; 
  
  
Cout <"Y coordinate :"; 
  
  
Cin> y; 
  
  
} 
  
  
VoidGet () 
  
  
{ 
  
  
Cout <endl <"X coordinate :"<X; 
  
  
Cout <endl <"Y coordinate :"<Y; 
  
  
} 
  
  
Virtual~ Point (){}; 
  
  
Private: 
  
  
IntX; 
  
  
IntY; 
  
  
}; 
  
  
# Endif  
 
 

Description: class definition and implementation of a vertex.

 
 

  
  
# Ifndef Circle_H  
  
  
# Define Circle_H  
  
  
# Include "Shape. h"  
  
  
# Include "Point. h"  
  
  
ClassCircle:PublicShape 
  
  
{ 
  
  
Public: 
  
  
VoidInput () 
  
  
{ 
  
  
Cout <endl <"Input circle Parameters"; 
  
  
Cout <endl <"Enter the coordinates of the center point :"<Endl; 
  
  
Center. Put (); 
  
  
Cout <endl <"Input radius :"; 
  
  
Cin> radius; 
  
  
} 
  
  
VoidPrint () 
  
  
{ 
  
  
Cout <endl <"The circle parameter is"; 
  
  
Cout <endl <"Coordinates of the center point :"<Endl; 
  
  
Center. Get (); 
  
  
Cout <endl <"Radius :"<Radius; 
  
  
} 
  
  
Virtual~ Circle (){}; 
  
  
Private: 
  
  
IntRadius; 
  
  
Point center; 
  
  
}; 
  
  
# Endif  
 
 

Description: class definition and implementation of a circle. Inherits the behavior of the Shape class.

 
 

  
  
# Ifndef Line_H  
  
  
# Define Line_H  
  
  
# Include "Shape. h"  
  
  
# Include "Point. h"  
  
  
ClassLine:PublicShape 
  
  
{ 
  
  
Public: 
  
  
VoidInput () 
  
  
{ 
  
  
Cout <endl <"Parameters of the input line"; 
  
  
Cout <endl <"Coordinate of input endpoint 1 :"<Endl; 
  
  
Point1.Put (); 
  
  
Cout <endl <"Coordinate of input endpoint 2 :"<Endl; 
  
  
Point2.Put (); 
  
  
} 
  
  
VoidPrint () 
  
  
{ 
  
  
Cout <endl <"The straight line parameter is"; 
  
  
Cout <endl <"Coordinate of endpoint 1 :"; 
  
  
Point1.Get (); 
  
  
Cout <endl <"Coordinate of endpoint 2 :"; 
  
  
Point2.Get (); 
  
  
} 
  
  
Virtual~ Line (){}; 
  
  
Private: 
  
  
Point point1; 
  
  
Point point2; 
  
  
}; 
  
  
# Endif 
 
 

Description: Linear class definition and implementation. Inherits the Shape action.

 
 

  
  
#ifndef ListTest_H   
  
  
#define ListTest_H   
  
  
#include     
  
  
#include "List.h"   
  
  
#include "Circle.h"   
  
  
#include "Line.h"   
  
  
void ListTest_MObject()   
  
  
{   
  
  
       List   a;    
  
  
       Shape *p1 = new Circle;   
  
  
       Shape *p2 = new Line;   
  
  
       p1->Input();   
  
  
       p2->Input();   
  
  
       a.Insert(p1);   
  
  
       a.Insert(p2);   
  
  
       Shape *p = *a.Next();   
  
  
       p->Print();   
  
  
       delete p;   
  
  
       a.Put(NULL);   
  
  
       p = *a.Next();   
  
  
       p->Print();   
  
  
       delete p;   
  
  
       a.Put(NULL);   
  
  
}   
  
  
#endif   
 
 

Note: This is a test function. You can add # include "ListTest. h" to the header of the cpp file containing main (), and then call ListTest_Mobject (). This is a simple example. It can be seen that deleting a linked list node requires two steps: delete the object indicated by the pointer in the data field of the linked list node before deleting the linked list node. Also, pay attention to this issue when you analyze such a linked list. Otherwise, your program will run a little less memory at a time (this may not be the case, it is said that the operating system can reclaim the dynamic memory when the program is terminated, but the subsequent conclusion is correct ), if it is a function that is frequently called, your system will be paralyzed after running for a period of time. Therefore, it is best to use such a linked list to derive a new linked list class to implement corresponding operations. For example:

 
 

  
  
class ShapeList : public List     
  
  
{   
  
  
public:   
  
  
       BOOL SL_Remove()   
  
  
       {   
  
  
              Shape *p = *Get();   
  
  
              delete p;   
  
  
              return Remove();   
  
  
       }  
  
  
};  
 
 

Gossip: I wonder if you are not familiar with this statement Shape * p = * a. Next (); p-> Print (); I don't know much about it, but I still think it's a bit cool. Then try this statement * a. Next ()-> Print (); can it be compiled.

1. Introduction to object-oriented programming in C ++
2. Practical application skills of C ++ linked list operations
3. Interpret and analyze the C ++ linked list
4. Analysis of the C ++ Object Model
5. Programmers must read the summary of c ++ pen questions