Implicit Type Conversions - part 2

#include <iostream>
using namespace std;
 
int main() {
float num = 98.76;
int x1 = (int) num;
int x2 = int(num);
int x3 = static_cast<int>(num);
 
cout < < "x1 = " << x1 << endl;
cout << "x2 = " << x2 << endl;
cout << "x3 = " << x3 << endl;
}

class A {
int a_int;
char* a_carp;
public:
operator int() { return a_int; }
operator char*() { return a_carp; }
};
 
class B : public A {
float b_float;
char* b_carp;
public:
operator float() { return b_float; }
operator char*() { return b_carp; }
};
 
int main () {
B b_obj;
//?  long a = b_obj;
char* c_p = b_obj;
}

The compiler would not allow the statement long a = b_obj. The compiler could either use A::operator int() or B::operator float() to convert b_obj into a long. The statement char* c_p = b_obj uses B::operator char*() to convert b_obj into a char* because B::operator char*() hides A::operator char*().

When you call a constructor with an argument and you have not defined a constructor accepting that argument type, only standard conversions are used to convert the argument to another argument type acceptable to a constructor for that class. No other constructors or conversions functions are called to convert the argument to a type acceptable to a constructor defined for that class. The following example demonstrates this:

class A {
public:
A() { }
A(int) { }
};
 
int main() {
A a1 = 1.234;
//? ?  A moocow = "text string";
}

The compiler allows the statement A a1 = 1.234. The compiler uses the standard conversion of converting 1.234 into an int, then implicitly calls the converting constructor A(int). The compiler would not allow the statement A moocow = “text string”; converting a text string to an integer is not a standard conversion.

Conversion by Constructor

A converting constructor is a single-parameter constructor that is declared without the function specifier explicit. The compiler uses converting constructors to convert objects from the type of the first parameter to the type of the converting constructor’s class. The following example demonstrates this:

class Y {
int a, b;
char* name;
public:
Y(int i) { };
Y(const char* n, int j = 0) { };
};
 
void add(Y) { };
 
int main() {
 
// equivalent to
// obj1 = Y(2)
Y obj1 = 2;
 
// equivalent to
// obj2 = Y("somestring",0)
Y obj2 = "somestring";
 
// equivalent to
// obj1 = Y(10)
obj1 = 10;
 
// equivalent to
// add(Y(5))
add(5);
}

The above example has the following two converting constructors:

* Y(int i)which is used to convert integers to objects of class Y.
* Y(const char* n, int j = 0) which is used to convert pointers to strings to objects of class Y.

The compiler will not implicitly convert types as demonstrated above with constructors declared with the explicit keyword. The compiler will only use explicitly declared constructors in new expressions, the static_cast expressions and explicit casts, and the initialization of bases and members. The following example demonstrates this:

class A {
public:
explicit A() { };
explicit A(int) { };
};
 
int main() {
A z;
//?  A y = 1;
A x = A(1);
A w(1);
A* v = new A(1);
A u = (A)1;
A t = static_cast<a>(1);
}</a>

The compiler would not allow the statement A y = 1 because this is an implicit conversion; class A has no conversion constructors.

A copy constructor is a converting constructor.

Conversion Functions

C++You can define a member function of a class, called a conversion function, that converts from the type of its class to another specified type.

-[-class-::] operator–[const][volatile]–conversion_type
-{–function_body–}-

A conversion function that belongs to a class X specifies a conversion from the class type X to the type specified by the conversion_type. The following code fragment shows a conversion function called operator int():

class Y {
int b;
public:
operator int();
};
Y::operator int() {
return b;
}
void f(Y obj) {
int i = int(obj);
int j = (int)obj;
int k = i + obj;
}

All three statements in function f(Y) use the conversion function Y::operator int().

Classes, enumerations, typedef names, function types, or array types cannot be declared or defined in the conversion_type. You cannot use a conversion function to convert an object of type A to type A, to a base class of A, or to void.

Conversion functions have no arguments, and the return type is implicitly the conversion type. Conversion functions can be inherited. You can have virtual conversion functions but not static ones.

Cast Expressions

The cast operator is used for explicit type conversions. This operator has the following form, where T is a type, and expr is an expression:

( T ) expr

It converts the value of expr to the type T. In C, the result of this operation is not an lvalue. In C++, the result of this operation is an lvalue if T is a reference; in all other cases, the result is an rvalue.

C++The remainder of this section pertains to C++ only.

A cast is a valid lvalue if its operand is an lvalue. In the following simple assignment expression, the right-hand side is first converted to the specified type, then to the type of the inner left-hand side expression, and the result is stored. The value is converted back to the specified type, and becomes the value of the assignment. In the following example, i is of type char *.

(int)i = 8? ? ? ? // This is equivalent to the following expression
(int)(i = (char*) (int)(8))

For compound assignment operation applied to a cast, the arithmetic operator of the compound assignment is performed using the type resulting from the cast, and then proceeds as in the case of simple assignment. The following expressions are equivalent. Again, i is of type char *.

(int)i += 8? ? ? ? // This is equivalent to the following expression
(int)(i = (char*) (int)((int)i = 8))

Taking the address of an lvalue cast will not work because the address operator may not be applied to a bit field.

You can also use the following function-style notation to convert the value of expr to the type T. :

expr( T )

A function-style cast with no arguments, such as X() is equivalent to the declaration X t(), where t is a temporary object. Similarly, a function-style cast with more than one argument, such as X(a, b), is equivalent to the declaration X t(a, b).

For C++, the operand can have class type. If the operand has class type, it can be cast to any type for which the class has a user-defined conversion function. Casts can invoke a constructor, if the target type is a class, or they can invoke a conversion function, if the source type is a class. They can be ambiguous if both conditions hold.

An explicit type conversion can also be expressed by using the C++ type conversion operator static_cast.

Example

The following demonstrates the use of the cast operator. The example dynamically creates an integer array of size 10:

#include <stdlib .h>
 
int main(void) {
int* myArray = (int*) malloc(10 * sizeof(int));
free(myArray);
return 0;
}</stdlib>

The malloc() library function returns a void pointer that points to memory that will hold an object of the size of its argument. The statement int* myArray = (int*) malloc(10 * sizeof(int)) does the following

* Creates a void pointer that points to memory that can hold ten integers.
* Converts that void pointer into an integer pointer with the use of the cast operator.
* Assigns that integer pointer to myArray. Because a name of an array is the same as a pointer to the initial element of the array, myArray is an array of ten integers stored in the memory created by the call to malloc().

[tags]standard type conversions, user defined conversion, conversion by constructor[/tags]

Popularity: 6%

You need to log on to convert this article into PDF

Related Blog Items

• Implicit Type Conversions
• C++ Advanced Tutorial - Lesson 10
• C Programming - Complicated Declaration Made Simple
• Why sizeof is an operator, not a function?
• C++ Basics Tutorial - Lesson 8

This entry was written by openasthra and posted on November 4, 2006 at 5:59 pm and filed under C++ Tidbits, Type Casting. Bookmark the permalink. Follow any comments here with the RSS feed for this post. Post a comment or leave a trackback: Trackback URL.