Conversión de datos en C++

Los tipos de datos definidos por el usuario están diseñados por el usuario para satisfacer sus requisitos, el compilador no admite conversiones automáticas de tipo para dichos tipos de datos , por lo tanto, el usuario debe diseñar las rutinas de conversión por sí mismo si es necesario.

Puede haber 3 tipos de situaciones que pueden surgir en la conversión de datos entre tipos de datos incompatibles:

• Conversión de tipo de datos primitivo a tipo definido por el usuario: para realizar esta conversión, la idea es usar el constructor para realizar la conversión de tipo durante la creación del objeto . A continuación se muestra el ejemplo para convertir int al tipo de datos definido por el usuario :
   

Ejemplo:

// C++ program to illustrate the
// type-conversion
#include <bits/stdc++.h>
using namespace std;
 
// Time Class
class Time {
    int hour;
    int mins;
 
public:
    // Default Constructor
    Time()
    {
        hour = 0;
        mins = 0;
    }
 
    // Parameterized Constructor
    Time(int t)
    {
        hour = t / 60;
        mins = t % 60;
    }
 
    // Function to print the value
    // of class variables
    void Display()
    {
        cout << "Time = " << hour
             << " hrs and "
             << mins << " mins\n";
    }
};
 
// Driver Code
int main()
{
    // Object of Time class
    Time T1;
    int dur = 95;
 
    // Conversion of int type to
    // class type
    T1 = dur;
    T1.Display();
 
    return 0;
}

Time = 1 hrs and 35 mins

• Conversión de objeto de clase a tipo de datos primitivo: en esta conversión, el tipo de origen es un objeto de clase y el tipo de destino es un tipo de datos primitivo. La forma normal de una función de operador de conversión sobrecargada , también conocida como función de conversión. A continuación se muestra la sintaxis para el mismo:

Sintaxis:

operator typename()
{
   // Code
}

• Ahora, esta función convierte un tipo de datos definido por el usuario en un tipo de datos primitivo . Por ejemplo, el operador double() convierte un objeto de clase en tipo double, el operador int() convierte un objeto de tipo clase en tipo int, y así sucesivamente. A continuación se muestra el programa para ilustrar lo mismo:
   

Ejemplo:

// C++ program to illustrate the
// above conversion
#include <bits/stdc++.h>
using namespace std;
 
// Tie Class
class Time {
    int hrs, mins;
 
public:
    // Constructor
    Time(int, int);
 
    // Casting operator
    operator int();
 
    // Destructor
    ~Time()
    {
        cout << "Destructor is called."
             << endl;
    }
};
 
// Function that assigns value to the
// member variable of the class
Time::Time(int a, int b)
{
    hrs = a;
    mins = b;
}
 
// int() operator is used for Data
// conversion of class to primitive
Time::operator int()
{
    cout << "Conversion of Class"
         << " Type to Primitive Type"
         << endl;
 
    return (hrs * 60 + mins);
}
 
// Function performs type conversion
// from the Time class type object
// to int data type
void TypeConversion(int hour, int mins)
{
    int duration;
 
    // Create Time Class  object
    Time t(hour, mins);
 
    // Conversion OR duration = (int)t
    duration = t;
    cout << "Total Minutes are "
         << duration << endl;
 
    // Conversion from Class type to
    // Primitive type
    cout << "2nd method operator"
         << " overloading " << endl;
 
    duration = t.operator int();
 
    cout << "Total Minutes are "
         << duration << endl;
 
    return;
}
 
// Driver Code
int main()
{
    // Input value
    int hour, mins;
    hour = 2;
    mins = 20;
 
    // Function call to illustrate
    // type conversion
    TypeConversion(hour, mins);
 
    return 0;
}

Conversion of Class Type to Primitive Type
Total Minutes are 140
2nd method operator overloading 
Conversion of Class Type to Primitive Type
Total Minutes are 140
Destructor is called.

Conversion of Class Type to Primitive Type
Total Minutes are 140
2nd method operator overloading 
Conversion of Class Type to Primitive Type
Total Minutes are 140
Destructor is called.

Ahora, la función convertirá el vector en magnitud escalar. El operador double() se puede utilizar como: 
 

double len = double(S1);
            Or,
double len = S1;
where S1 is an object of type vector.

Conversión de un tipo de clase a otro tipo de clase: en este tipo, un tipo de clase se convierte en otro tipo de clase. Se puede hacer de 2 formas:

1. Usando el constructor

2. Uso del operador de fundición de sobrecarga

1. Usando el constructor:

En la clase Destination usamos el método constructor  

//Objects of different types 
ObjectX=ObjectY;
Here ObjectX is Destination object and ObjectY is source object

Ejemplo:

#include<iostream>
using namespace std;
//cgs system
class CGS
 {
     int mts; //meters
     int cms; //centimeters
     public:
       void showdata()
   {
       cout<<"Meters and centimeters in CGS system:";
       std::cout << mts<<" meters "<<cms<<" centimeters" << std::endl;
   }
   CGS(int x,int y) // parameterized constructor
   {
       mts=x;
    cms=y;
   }
    int getcms()
   {
       return cms;
   }
   int  getmts()
   {
       return mts;
   }
 
 };
  class FPS
 {
   int feet;
   int inches;
   public:
   FPS() // default constructor
   {
       feet=0;
       inches=0;
   }  
  FPS(CGS d2)
   {
       int x;
       x=d2.getcms()+d2.getmts()*100;
       x=x/2.5;
       feet=x/12;
       inches=x%12;
    }
   void showdata()
   {
       cout<<"feet and inches in FPS system:";
       std::cout << feet<<" feet "<<inches<<" inches" << std::endl;
   }
 };
 
 int main()
 {
     CGS d1(9,10);
     FPS d2;
     d2=d1;
     d1.showdata(); //to display CGS values
     d2.showdata(); //to display FPS values
     return 0;
 }

Meters and centimeters in CGS system:9 meters 10 centimeters
feet and inches in FPS system:30 feet 4 inches

2. Uso del operador de fundición de sobrecarga 

// Objects of different types
objectX = objectY;

• Aquí usamos el operador de conversión de sobrecarga en la clase de origen, es decir, la clase de destino de sobrecarga en la clase de origen
   

Vea el siguiente ejemplo en el que tenemos dos clases Hora y Minuto respectivamente y convertiremos una clase Hora en otra clase Minuto.

En el siguiente ejemplo, la clase de minutos es la clase de destino y la clase de tiempo es la clase de origen

entonces necesitamos sobrecargar la clase de destino en la clase de origen

Aquí no deberíamos decir el tipo de devolución, pero devolvemos el objeto de clase sobrecargado 

es decir, valor devuelto sin especificar el tipo de retorno
 

// C++ program to illustrate the
// above conversion
#include <bits/stdc++.h>
using namespace std;
//minutes class
class Minute {
     
 
public:
   int mins;
    // Constructors
    Minute()
    {
        mins = 0;
    }
 
    // Function to print the value of
    // hours and minutes
    void show()
    {
        cout << "\nTotal Minute : " << mins << endl;
    }
};
 
// Time Class
class Time {
    int hr, mins;
 
public:
    // Constructors
    Time(int h, int m)
    {
        hr = h;
        mins = m;
    }
    Time()
    {
        cout << "\nTime's Object Created";
    }
    operator Minute  () //overloading minute class
    {
        Minute m;
        m.mins = (hr * 60) + mins;
        return m;
    } //driver code
 
    // Function to print the value of
    // hours and minutes
    void show()
    {
        cout << "Hour: " << hr << endl;
        cout << "Minute : " << mins << endl;
    }
};
 
// Minutes Class
int main()
{
    Time T1(3,40);
    Minute m;
    m=T1; //minute class is destination and Time class is source class
    T1.show();
    m.show();
    return 0;
}

Hour: 3
Minute : 40

Total Minute : 220