¿Cómo convertir una clase a otro tipo de clase en C++?

Requisito previo: conversión de tipo en C++ , C++ avanzado | Operadores de conversión
A través de la conversión de clases, uno puede asignar datos que pertenecen a un tipo de clase en particular a un objeto que pertenece a otro tipo de clase. 
Ejemplo: 
Sean dos clases ‘A’ y ‘B’. Si queremos asignar los detalles que pertenecen a la clase ‘A’ a un objeto de la clase ‘B’, esto se puede lograr de la siguiente manera: 
 

B(objeto de clase B) = A(objeto de clase A) 
donde ‘=’ ha sido sobrecargado para objetos de clase tipo ‘B’.

La conversión de clase se puede lograr mediante la función de conversión que se realiza mediante el uso de la sobrecarga del operador.
Ejemplo: 
 

#include <bits/stdc++.h>
using namespace std;
 
// Source class, i.e
// class that will be converted to another class
class Class_type_one {
    string a = "GeeksforGeeks";
 
public:
    // Member function which returns
    // string type data
    string get_string()
    {
        return (a);
    }
 
    // Member function to display
    void display()
    {
        cout << a << endl;
    }
};
 
// Destination class, i.e
// Class type to which source class will be converted
class Class_type_two {
    string b;
 
public:
    // Operator overloading which accepts data
    // of the Destination class and
    // assigns those data to the source class
    // Here it is for the conversion of
    // Class_type_two to Class_type_one
    void operator=(Class_type_one a)
    {
        b = a.get_string();
    }
 
    // Member function for displaying
    // the data assigned to b.
    void display()
    {
        cout << b << endl;
    }
};
 
int main()
{
    // Creating object of class Class_type_one
    Class_type_one a;
 
    // Creating object of class Class_type_two
    Class_type_two b;
 
    // CLass type conversion
    // using operator overloading
    b = a;
 
    // Displaying data of object
    // of class Class_type_one
    a.display();
 
    // Displaying data of object
    // of class Class_type_two
    b.display();
 
    return 0;
}

GeeksforGeeks
GeeksforGeeks

Conversión de clase a clase usando el constructor en la clase de destino:

Una clase de origen se puede convertir en una clase de destino mediante el uso de un constructor en la clase de destino que hace referencia a la clase de origen.

Clase_destino(clase_fuente &objeto)

{

// asignaciones de miembros de la clase de destino

//con miembros de la clase fuente usando el objeto de la clase fuente 

}

#include <bits/stdc++.h>
using namespace std;
 
// Source class, i.e
// Class which will be converted to another
class Class_type_one {
    string a = "GeeksforGeeks";
 
public:
    // Member function which returns
    // string type data
    string get_string()
    {
        return (a);
    }
 
    // Member function to display
    void display()
    {
        cout << a << endl;
    }
};
 
// Destination class, i.e
// class to which source class will be converted
class Class_type_two {
    string b;
 
public:
     // a default constructor to
     //create object of this class
     Class_type_two()
     {
        
     }
    //here we are using constructor
    //which takes reference of object
    //of source class i.e. Class_type_one
    //as its argument
    Class_type_two (Class_type_one& a)
    {
        b = a.get_string();
    }
 
    // Member function for displaying
    // the data assigned to b.
    void display()
    {
        cout << b << endl;
    }
};
 
int main()
{
    // Creating object of class Class_type_one
    Class_type_one a;
 
    // Creating object of class Class_type_two
    Class_type_two b;
 
    // CLass type conversion
    // using operator overloading
    b = a;
 
    // Displaying data of object
    // of class Class_type_one
    a.display();
 
    // Displaying data of object
    // of class Class_type_two
    b.display();
 
    return 0;
}

GeeksforGeeks
GeeksforGeeks

Conversión de clase a clase usando el operador de conversión:

La conversión de clase a clase también es posible utilizando el operador de conversión en la clase de origen. El tipo de operador será el de clase destino.

Un operador de conversión será una función miembro de la clase de origen y devolverá el objeto de la clase de destino.

operador clase_destino()

{

destino_clase obj;

//asignación de miembros de la clase de destino con miembros de la clase de origen

//esta función es miembro de la clase fuente, por lo tanto, puede acceder a sus otros miembros de datos

devolver objeto

}

#include <bits/stdc++.h>
using namespace std;
//Forward declaration of
//destination class
class Class_type_two;
// Source class, i.e
// Class which will be converted to another
class Class_type_one {
    string a = "GeeksforGeeks";
 
public:
    // Member function which returns
    // string type data
    string get_string()
    {
        return (a);
    }
 
    // Member function to display
    void display()
    {
        cout << a << endl;
    }
  //declaration of casting
  //operator for class conversion
  //note that it will be of type destination class
  operator Class_type_two();
     
};
 
// Destination class, i.e
// class type to which source class will converted
class Class_type_two {
     
 
public:
     string b;
     
    // Member function for displaying
    // the data assigned to b.
    void display()
    {
        cout << b << endl;
    }
};
//here we define our casting operator
Class_type_one::operator Class_type_two()
{
  Class_type_two obj;
  obj.b=a;
  return obj;
   
}
 
int main()
{
    // Creating object of class Class_type_one
    Class_type_one a;
 
    // Creating object of class Class_type_two
    Class_type_two b;
 
    // CLass type conversion
    // using operator overloading
    b = a;
 
    // Displaying data of object
    // of class Class_type_one
    a.display();
 
    // Displaying data of object
    // of class Class_type_two
    b.display();
 
    return 0;
}

GeeksforGeeks
GeeksforGeeks