Scribd
Upload
57 views4 pages

9 - Data Conversion

This document discusses data conversion between different data types in C++. It covers: - Implicit and explicit conversion between basic data types like int, float, etc. using casts. - Conversion between user-defined objects and basic types by writing custom constructors and conversion operators. An example shows converting between a Distance class and float meters. - Conversion between C-strings and std::string objects using constructors and a conversion operator, allowing conversion in both directions.

Uploaded by

Azhar Jamil
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
57 views4 pages

9 - Data Conversion

This document discusses data conversion between different data types in C++. It covers: - Implicit and explicit conversion between basic data types like int, float, etc. using casts. - Conversion between user-defined objects and basic types by writing custom constructors and conversion operators. An example shows converting between a Distance class and float meters. - Conversion between C-strings and std::string objects using constructors and a conversion operator, allowing conversion in both directions.

Uploaded by

Azhar Jamil
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
You are on page 1/ 4

AJ/Handout 9 -1- Object-Oriented Programming

Lesson 9

Objectives

Data Conversion

 Conversion between Basic data types


 Conversion between Objects and Basic data types

 Conversion from Basic to User-Defined & User-Defined to Basic data type

 Conversion between C-String and string Objects

We have seen in many situations that the ‘=’ assignment operator for assigning a basic data type to
other and also an object being assigned to other object. Now we will see the situations where
different data types (user define, basic, object etc) can be converted to each other as well. Starting
the discussion from the topic below we shall proceed to next cases.

Conversion between Basic data types

Implicit Cast: such kind of cast is take place automatically. This is carried out by calling some
special routines by compiler to convert the given basic data type. Simple rule for the implicit cast
is that if the size of the variable on right side of ‘=’ is less than or equal to that of left hand side.
For example a character can be stored in integer, an integer to double and etc. These conversions
are called implicit because they are not apparent in the program.

Explicit Cast: sometimes we want to force the compiler to convert one type to another. To
do this we use the cast operator. For instance, to convert float to integer, we can say
intvar = static_cast <int> (floatvar); this will provide and explicit conversion. It is obvious that
static_cast <int> () is intended to convert from float to int. However, such conversions use the
same built-in routines as implicit conversions.

Conversion between Objects and Basic types


Now our requirement is to make a conversion between user data type (Objects) and Basic
types. For this we can’t rely on built-in routines since compiler does not know the required
operation unless we tell it. In other words we have to write these routines ourselves. This program
will show this conversion.

#include<iostream>
using namespace std;
///////////////////////////
class Distance
{
private:
const float MTF; //meter to feet
int feet;
float inches;
public:
Distance() : feet(0), inches (0.0), MTF (3.280833F)
AJ/Handout 9 -2- Object-Oriented Programming

{}
Distance (float meters) : MTF(3.280833F)
{
float fltfeet = MTF * meters;
feet = int (fltfeet);
inches = 12 * (fltfeet - feet);
}
Distance (int ft, float in) : feet(ft), inches(in), MTF(3.280833F)
{}
void getdist()
{
cout<<”Enter Feet:”; cin>>feet;
cout<<”Enter Inches:”; cin>>inches;
}
void showdist() const
{cout<<feet<<”\”<<inches;}

operator float() const //conversion operator


{
float fracfeet = inches/12; //converts Distance to meter
fracfeet +=static_cast<float>(feet); //add the feet
return fracfeet/MTF; //convert to meter
}
};
////////////////////////////////////
void main()
{
float mtrs;
Distance dist1=2.35F; //uses one arg ctor for converting meter to Distance
Cout<<”Dist 1: ”; dist1.showdist();

Mtrs = static_cast<float>(dist1); //uses conversion operator for Distance to meters


Cout<<”Dist 1:”<<mtrs;

Distance dist2(5,10.25);

Mtrs= dist2; //uses conversion operator


Cout<<”Dist2:”<<mtrs;

// Dist2=mtrs; //causes an error


}
Here basically two things performed
1) From Basic to User-Defined
Here we have the lines in above program like

Distance (float meters) : MTF(3.280833F)


{
float fltfeet = MTF * meters;
feet = int (fltfeet);
inches = 12 * (fltfeet - feet);
}
AJ/Handout 9 -3- Object-Oriented Programming

Here we can see that ultimately meter is converted to feet and inches (Distance type Object) and
assigned to the Object made by this constructor. That is, Distance dist1=2.35;

2) From User-Define to Basic


Now the same program is being capable of doing this just going the other way round. There is a
trick to do this carried out by an operator called a conversion operator. In the listing,
operator float() const //conversion operator
{
float fracfeet = inches/12; //converts Distance to meter
fracfeet +=static_cast<float>(feet); //add the feet
return fracfeet/MTF; //convert to meter
}
this operator takes the value of the Distance object of which it is member, converts it to a float
value representing meters, and returns this value. This operator can be called with an explicit cast.
Mtrs = static_cast<float>(dist1); or simply
Mtrs = dist2;
Both forms convert the Distance object to its equivalent float value in meters.

Conversion between C-String and string Objects


Here is another example of conversion that uses a one-argument constructor and conversion
operator.
//strconv.cpp
//conversion between ordinary string and C++ string class
#include <iostream>
using namespace std;
#include<string.h>
////////////////////////////////
class String
{
private:
enum {SZ = 80};
char str[SZ];
public:
String()
{str[0] = ‘\0’;}
String(char s[] )
{strcpy(str,s);}
void display () const
{cout << str;}
operator char* ()
{return str;}
};
/////////////////////////////////////
void main()
{
String s1;
char xstr[] = “William”;
s1 = xstr; //uses one argument constructor to convert C-string to String
s1.display();

String s2 = “Shakespeare”; //uses 1 arg ctor to initialize String same approach


AJ/Handout 9 -4- Object-Oriented Programming

cout<<static_cast<char*>(s2); //use conversion operator to convert String to C-string


//before sending to << operator
}
Here ‘*’ in this expression means pointer to. It means pointer to char, which is very similar to
array of type char. Thus “char*” is similar to “char []”
Note that we can’t use an implicit assignment statement to convert a String to a C-string
xstr = s2; while in subsequent lectures we shall see its possibility.

You might also like