Most programs process information of many types. Sometimes all the operations “stay within a type.” For example, adding an int
to an int
produces an int
. It’s often necessary, however, to convert data of one type to data of another type. This can happen in assignments, in calculations, in passing values to functions and in returning values from functions. The compiler knows how to perform certain conversions among fundamental types. You can use cast operators to force conversions among fundamental types.
But what about user-defined types? The compiler cannot know in advance how to convert among user-defined types, and between user-defined types and fundamental types, so you must specify how to do this. Such conversions can be performed with conversion constructors—constructors that can be called with a single argument (we’ll refer to these as single-argument constructors). Such constructors can turn objects of other types (including fundamental types) into objects of a particular class.
A conversion operator (also called a cast operator) also can be used to convert an object of one class to another type. Such a conversion operator must be a non-static
member function. The function prototype
MyClass::operator string() const;
declares an overloaded cast operator function for converting an object of class MyClass
into a temporary string
object. The operator function is declared const
because it does not modify the original object. The return type of an overloaded cast operator function is implicitly the type to which the object is being converted. If s
is a class object, when the compiler sees the expression static_cast<string>(s)
, the compiler generates the call
s.operator string()
to convert the operand s
to a string
.
Overloaded cast operator functions can be defined to convert objects of user-defined types into fundamental types or into objects of other user-defined types. The prototypes
MyClass::operator int() const;
MyClass::operator OtherClass() const;
declare overloaded cast operator functions that can convert an object of user-defined type MyClass
into an integer or into an object of user-defined type OtherClass
, respectively.
One of the nice features of cast operators and conversion constructors is that, when necessary, the compiler can call these functions implicitly to create temporary objects. For example, if an object s
of a user-defined class appears in a program at a location where a string
is expected, such as
display(s); // argument expected to be a string object
the compiler can call the overloaded cast-operator function operator
string
to convert the object into a string
and use the resulting string
in the expression. With this cast operator provided for a class, the function display
does not have to be overloaded with a version that receives an object of your class as an argument.
When a conversion constructor or conversion operator is used to perform an implicit conversion, C++ can apply only one implicit constructor or operator function call (i.e., a single user-defined conversion) to try to match the needs of another overloaded operator. The compiler will not satisfy an overloaded operator’s needs by performing a series of implicit, user-defined conversions.