C++ program to convert primitive type to object

The primitive data types in C are data types predefined by the language itself; such as int, float, double, etc. Objects are instances of classes, and since C is an object-oriented language, conversion between primitive data types and objects is necessary. Classes serve as architectural plans for data types. While this doesn't describe any data specifically, it does specify what the class name means, i.e. what an object of that class looks like and what operations can be performed on it.

In the C language compiler, the conversion between primitive data types to objects is not clearly defined, so to convert primitive data types into objects, the programmer must define a mechanism. How a primitive type is converted to a specific object is defined in the constructor of a user-defined class. Let's take an example to understand this issue better.

The problem we are solving is converting weight in grams to kilograms and grams. To do this, we define a user-defined class weight with two integer members kg and gm. "kg" is the kilogram value of the given weight and "gm" is the remaining weight less than one kilogram to be converted. The algorithm to solve this problem is given below.

grammar

The syntax for conversion is as follows -

class Myclass{
   private:
   int classVal;
   public:
   MyClass(){
      classVal = 0;
   }
   MyClass(int val) {
      classVal = val;
   }
};
int main() {
   Myclass m;
   int val = <integer value>;
   m = val;
   return 0;
}

algorithm

• Put the input weights into integer variables.
• Create an object of class weight.
• Assign integer value to class object;
• Call the show function of the object.

In the constructor of the defined class, perform the following operations:

• Divide the input value by 1000 to get the kilogram (kg) value as the quotient.
• Divide the input value by 1000 to get the remainder in grams (gm).

As mentioned earlier, all conversion mechanisms must be defined within the constructor. The constructor must be parameterized, and the original source value must be passed to the constructor as a parameter. The source code of the problem is as follows.

Example

#include <iostream>
using namespace std;
//converts weight in grams to kgs and grams
class Weight
{
   private:
      int kg, gm;
   public:
   //default constructor
   Weight()
   {
      kg = 0;
      gm = 0;
   }
   //paramaeterized constructor
   Weight(int ip)
   {
      this->kg = ip / 1000;
      this->gm = ip % 1000;
   }
   //shows the output
   void show()
   {
      cout << "The weight is " << this->kg << " kgs and " << this->gm << " grams." << endl;
   }
};
int main()
{
   //weight in grams
      int ip = 1085;
   //conversion done here
      Weight w;
      w = ip;
      w.show();
   return 0;
}

Output

The weight is 1 kgs and 85 grams.

In the example, the input is inside the main function and is "ip". There is also an object of class weight "w". We just assigned an integer value to a class object and invoked an implicit call to the parameterized constructor of that object. The functions defined in the constructor have been executed, and finally the output is displayed by calling the show function.

in conclusion

In this example, the conversion from a primitive type to a user-defined class object is done using an implicit call to the constructor. This is fine until the constructor requires multiple primitive values ​​to instantiate the object. Therefore, we have to call the constructor explicitly and then pass the original value as parameter to the object constructor. The opposite is true for conversion from object to primitive type, which requires a more complex process to complete.

The above is the detailed content of C++ program to convert primitive type to object. For more information, please follow other related articles on the PHP Chinese website!