Clases autorreferenciales en C++

Una clase es un bloque de construcción en C++ que conduce a la programación orientada a objetos. Es un tipo definido por el usuario que contiene sus propios miembros de datos y funciones de miembro. Se puede acceder a estos creando una instancia de la clase de tipo. 

Las clases autorreferenciales son un tipo especial de clases creadas específicamente para una lista vinculada y una implementación basada en árboles en C++. Para crear una clase autorreferencial, declare un miembro de datos como un puntero a un objeto de la misma clase.

Sintaxis:

clase Self
{
      privado:
      int a;
      Auto *referencia;
}

A continuación se muestra el programa C++ para implementar clases autorreferenciales.

// C++ program to implement 
// self-referential class
#include<iostream>
using namespace std;
  
// Class definition
class Self
{
    public:
        int x;
        Self *srefer;
        Self(int a):srefer(nullptr),x(a){}
              
};
  
// Function to print 
// values
void print(Self *b)
{
    if(b == nullptr)
    return;
    do
    {
        cout << b->x << endl;
    }while((b = b->srefer));
}
  
// Driver code
int main()
{
    Self x(5), y(7), z(9);
    x.srefer = &y;
    y.srefer = &z;
    print(&x);
    return 0;
}

5
7
9

Puntos clave:

• Muchas estructuras de datos dinámicos de uso frecuente, como pilas , colas , listas vinculadas, etc., utilizan miembros autorreferenciales.
• Las clases pueden contener uno o más miembros que son punteros a otros objetos de la misma clase.
• este puntero contiene una dirección del siguiente objeto en una estructura de datos.

La representación pictórica de una lista enlazada que tiene un puntero al siguiente objeto de la misma clase se muestra a continuación:

Ejemplo:  A continuación se muestra el programa C++ para implementar una lista enlazada usando una clase. La clase debe contener un miembro puntero que apunte al siguiente Node de la lista. 

// C++ program to implement 
// self-referential class
#include<iostream>
using namespace std;
  
// Class Linked list
class list
{
    private:
    
        // data of a node
        int data;    
    
        // pointer to next node
        list *next;  
    public:
        list()
        {
            data = 0;
            next = NULL;
        }
        list(int dat)
        {
            data = dat;
            next = NULL;
        }
        ~list();
        int get()
        {
            return data;
        }
    
        // Function to insert node 
        // in linked list
        void insert(list *node);     
    
        // Function to display list
        friend void display(list *); 
};
     
// Inserts node function
// If the list is empty the first node 
// is created else the new node is 
// inserted at the end of the list.
void list::insert(list *node)
{
    // this node pointer to catch 
    // last node 
    list *last = this; 
    
    // if node->next!=NULL, it is not 
    // the last node
    while(last->next)  
        last = last->next;
    
    // make last node point to new node
    last->next = node;   
}
  
// Displays the doubly linked list 
// in both forward and reverse order 
// by making use of the series of 
// next and prev pointers.
void display(list *first)
{
    list *traverse;
    cout << "Elements of List are:";
    cout << endl;
    for(traverse = first; traverse;
        traverse = traverse->next)
        cout << traverse->data << " ";
    cout << endl;
}
  
// Driver code
int main()
{
    list *first = NULL;
    list *node;
    
    for (int i = 1; i < 5; i++)
    {
      node = new list(i);
      if(first == NULL)
        first = node;
      else
        first->insert(node);
    }
    
    // Display the elements of list
    display(first);
}

Elements of List are:
1 2 3 4