Type casting in C++ - Time & Space Complexity

Time Complexity: Type casting

O(n)

Understanding Time Complexity

When we use type casting in C++, it changes how data is interpreted but usually does not add extra loops or repeated steps.

We want to see how the time to run code changes when type casting is involved.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

int main() {
    double x = 3.14;
    int y = (int)x;  // type cast double to int
    int arr[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        int val = arr[i];  // type cast int to int (redundant)
        // do something simple
    }
    return 0;
}
    

This code casts a double to int once, then casts elements of an int array inside a loop.

Identify Repeating Operations

Look for loops or repeated steps.

• Primary operation: The for-loop runs 5 times.
• How many times: The type cast inside the loop happens 5 times, once per element.

How Execution Grows With Input

Imagine the array size grows from 10 to 100 to 1000.

Input Size (n)	Approx. Operations
10	10 type casts inside the loop
100	100 type casts inside the loop
1000	1000 type casts inside the loop

Each time the input size grows, the number of type casts inside the loop grows the same way.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly with the number of elements we process.

Common Mistake

[X] Wrong: "Type casting adds a lot of extra time because it's complicated."

[OK] Correct: Type casting is usually a simple, fast operation done once per item, so it doesn't slow down the program much by itself.

Interview Connect

Understanding how type casting affects time helps you explain your code clearly and shows you know what parts of your program take time.

Self-Check

"What if we replaced the for-loop with a nested loop that casts elements inside both loops? How would the time complexity change?"

Practice

1. What does static_cast<int>(3.14) do in C++?

easy

A. Leaves the value unchanged as 3.14

B. Converts the integer 3 to the floating-point number 3.14

C. Causes a runtime error

D. Converts the floating-point number 3.14 to the integer 3

Solution

1. Step 1: Understand static_cast usage

   static_cast<int> converts a value to an integer type explicitly.

2. Step 2: Apply static_cast to 3.14

   The floating-point number 3.14 is converted to integer by dropping the decimal part, resulting in 3.

3. Final Answer:

   Converts the floating-point number 3.14 to the integer 3 -> Option D

4. Quick Check:

   static_cast<int>(3.14) = 3 [OK]

Hint: static_cast truncates decimals when converting float to int [OK]

Common Mistakes:

• Thinking it rounds the number instead of truncating
• Confusing static_cast with dynamic_cast
• Expecting a runtime error from static_cast

2. Which of the following is the correct syntax for casting a double variable d to int using static_cast?

easy

A. int i = (int)static_cast(d);

B. int i = static_cast<int>(d);

C. int i = static_cast(d, int);

D. int i = static_cast<int>d;

Solution

1. Step 1: Recall static_cast syntax

   The correct syntax is static_cast<type>(expression).

2. Step 2: Match syntax with options

   int i = static_cast<int>(d); matches the correct syntax: int i = static_cast<int>(d);.

3. Final Answer:

   int i = static_cast<int>(d); -> Option B

4. Quick Check:

   Correct static_cast syntax = int i = static_cast<int>(d); [OK]

Hint: Use angle brackets for type in static_cast [OK]

Common Mistakes:

• Using parentheses instead of angle brackets for type
• Placing type after variable instead of inside <>
• Mixing C-style cast syntax with static_cast

3. What is the output of the following C++ code?

double x = 9.99;
int y = static_cast<int>(x);
std::cout << y << std::endl;

medium

A. 9.99

B. 10

C. 9

D. Compilation error

Solution

1. Step 1: Understand static_cast behavior on double to int

   static_cast truncates the decimal part, so 9.99 becomes 9.

2. Step 2: Predict output of std::cout

   The integer 9 is printed to the console.

3. Final Answer:

   9 -> Option C

4. Quick Check:

   static_cast<int>(9.99) = 9 [OK]

Hint: Casting double to int drops decimals, no rounding [OK]

Common Mistakes:

• Expecting rounding to 10 instead of truncation
• Confusing output type with original double
• Thinking static_cast causes compile error here

4. Identify the error in this code snippet:

float f = 3.5f;
int i = static_cast<int> f;
std::cout << i;

medium

A. Missing parentheses after static_cast<int>

B. Cannot cast float to int using static_cast

C. Variable i is not declared

D. Missing semicolon after float declaration

Solution

1. Step 1: Check static_cast syntax

   static_cast requires parentheses around the value to cast, like static_cast<int>(f).

2. Step 2: Identify missing parentheses

   The code misses parentheses after static_cast<int>, causing syntax error.

3. Final Answer:

   Missing parentheses after static_cast<int> -> Option A

4. Quick Check:

   static_cast<int>(f) needs parentheses [OK]

Hint: Always use parentheses after static_cast type [OK]

Common Mistakes:

• Omitting parentheses after static_cast
• Thinking static_cast can't convert float to int
• Ignoring compiler error messages

5. Given the code below, what will be the output?

int a = 65;
char c = static_cast<char>(a);
std::cout << c << std::endl;

Note: ASCII value 65 corresponds to 'A'.

hard

A. 'A'

B. Compilation error

C. 65

D. Undefined behavior

Solution

1. Step 1: Understand static_cast from int to char

   static_cast converts the integer 65 to its corresponding ASCII character 'A'.

2. Step 2: Predict output of std::cout

   Printing the char variable outputs the character 'A'.

3. Final Answer:

   'A' -> Option A

4. Quick Check:

   static_cast<char>(65) = 'A' [OK]

Hint: Casting int to char prints ASCII character [OK]

Common Mistakes:

• Expecting numeric 65 to print instead of 'A'
• Thinking casting int to char causes error
• Confusing char with string output