Cast expressions

The cast operator is used for explicit type conversions. It converts the value of an expression to a specified type.

Read syntax diagramSkip visual syntax diagramCast expression syntax
 
>>-(--type--)--expression--------------------------------------><
 

C only The result of this operation is not an lvalue. C++ only The result of this operation is an lvalue if type is a reference; in all other cases, the result is an rvalue.

The following demonstrates the use of the cast operator to dynamically create an integer array of size 10:

#include <stdlib.h>

int main(void) {
   int* myArray = (int*) malloc(10 * sizeof(int));
   free(myArray);
   return 0;
}

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:

C++ only

In C++ you can also use the following in cast expressions:

Function-style notation converts the value of expression to the type type:

expression( type )

The following example shows the same value cast with a C-style cast, the C++ function-style cast, and a C++ cast operator:

#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;
}

The following is the output of the above example:

x1 = 98
x2 = 98
x3 = 98

The integer x1 is assigned a value in which num has been explicitly converted to an int with the C-style cast. The integer x2 is assigned a value that has been converted with the function-style cast. The integer x3 is assigned a value that has been converted with the static_cast operator.

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))

For C++, the operand of a cast expression 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.

End of C++ only

Related information