C++ Type Conversion

# C++ Type Conversion

#### In this tutorial, we will learn about the basics of C++ type conversion with the help of examples.

C++ allows us to convert data of one type to that of another. This is known as type conversion.

There are two types of type conversion in C++.

1. Implicit Conversion
2. Explicit Conversion (also known as Type Casting)

## Implicit Type Conversion

The type conversion that is done automatically done by the compiler is known as implicit type conversion. This type of conversion is also known as automatic conversion.

Let us look at two examples of implicit type conversion.

### Example 1: Conversion From int to double

``````// Working of implicit type-conversion

#include <iostream>
using namespace std;

int main() {
// assigning an int value to num_int
int num_int = 9;

// declaring a double type variable
double num_double;

// implicit conversion
// assigning int value to a double variable
num_double = num_int;

cout << "num_int = " << num_int << endl;
cout << "num_double = " << num_double << endl;

return 0;
}``````

Output

```num_int = 9
num_double = 9```

In the program, we have assigned an `int` data to a `double` variable.

``num_double = num_int;``

Here, the `int` value is automatically converted to `double` by the compiler before it is assigned to the num_double variable. This is an example of implicit type conversion.

### Example 2: Automatic Conversion from double to int

``````//Working of Implicit type-conversion

#include <iostream>
using namespace std;

int main() {

int num_int;
double num_double = 9.99;

// implicit conversion
// assigning a double value to an int variable
num_int = num_double;

cout << "num_int = " << num_int << endl;
cout << "num_double = " << num_double << endl;

return 0;
}``````

Output

```num_int = 9
num_double = 9.99```

In the program, we have assigned a `double` data to an `int` variable.

``num_double = num_int;``

Here, the `double` value is automatically converted to `int` by the compiler before it is assigned to the num_int variable. This is also an example of implicit type conversion.

Note: Since int cannot have a decimal part, the digits after the decimal point is truncated in the above example.

### Data Loss During Conversion (Narrowing Conversion)

As we have seen from the above example, conversion from one data type to another is prone to data loss. This happens when data of a larger type is converted to data of a smaller type.

## C++ Explicit Conversion

When the user manually changes data from one type to another, this is known as explicit conversion. This type of conversion is also known as type casting.

There are three major ways in which we can use explicit conversion in C++. They are:

1. C-style type casting (also known as cast notation)
2. Function notation (also known as old C++ style type casting)
3. Type conversion operators

### C-style Type Casting

As the name suggests, this type of casting is favored by the C programming language. It is also known as cast notation.

The syntax for this style is:

``(data_type)expression;``

For example,

``````// initializing int variable
int num_int = 26;

// declaring double variable
double num_double;

// converting from int to double
num_double = (double)num_int;``````

### Function-style Casting

We can also use the function like notation to cast data from one type to another.

The syntax for this style is:

``data_type(expression);``

For example,

``````// initializing int variable
int num_int = 26;

// declaring double variable
double num_double;

// converting from int to double
num_double = double(num_int);``````

### Example 3: Type Casting

``````#include <iostream>

using namespace std;

int main() {
// initializing a double variable
double num_double = 3.56;
cout << "num_double = " << num_double << endl;

// C-style conversion from double to int
int num_int1 = (int)num_double;
cout << "num_int1   = " << num_int1 << endl;

// function-style conversion from double to int
int num_int2 = int(num_double);
cout << "num_int2   = " << num_int2 << endl;

return 0;
}``````

Output

```num_double = 3.56
num_int1   = 3
num_int2   = 3```

We used both the C style type conversion and the function-style casting for type conversion and displayed the results. Since they perform the same task, both give us the same output.

### Type Conversion Operators

Besides these two type castings, C++ also has four operators for type conversion. They are known as type conversion operators. They are:

• `static_cast`
• `dynamic_cast`
• `const_cast`
• `reinterpret_cast`

We will learn about these casts in later tutorials.

Recommended Tutorials:
{"ft_lang_label":"__label__en","ft_lang_prob":0.8043908,"math_prob":0.97815746,"size":4277,"snap":"2020-24-2020-29","text_gpt3_token_len":979,"char_repetition_ratio":0.20571028,"word_repetition_ratio":0.22206506,"special_character_ratio":0.24947393,"punctuation_ratio":0.11369863,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9983663,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-07-04T19:28:26Z\",\"WARC-Record-ID\":\"<urn:uuid:f87a4e23-2938-4333-8110-20ae16f57d4a>\",\"Content-Length\":\"177032\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:43e03e36-4c9c-4eae-9736-8c903aae6f8c>\",\"WARC-Concurrent-To\":\"<urn:uuid:ce5f0d02-a938-4713-9f89-dc665e809952>\",\"WARC-IP-Address\":\"195.181.168.47\",\"WARC-Target-URI\":\"https://cdn.programiz.com/cpp-programming/type-conversion\",\"WARC-Payload-Digest\":\"sha1:2AOAIOZTOQUITEHQKUFNBJ5YBLA5YEP3\",\"WARC-Block-Digest\":\"sha1:IOPVX6AXYLCGD2JEPSG7TYQ32XHSFOV6\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-29/CC-MAIN-2020-29_segments_1593655886516.43_warc_CC-MAIN-20200704170556-20200704200556-00457.warc.gz\"}"}