Type Conversion in C++

Step 1 - EXTRACT (Given data)

• Source class: Meter with data members meter (m) and centimeter (cm).
• Destination class: Distance with data members feet and inch.
• Conversion factors:
  • $1\ \text{m} = 3.3\ \text{feet}$
  • $1\ \text{cm} = 0.4\ \text{inch}$
• Task: write a program converting an object of one class to a Distance object; explain type conversion and two ways of converting between user-defined types.

No numeric input is missing. (The specific test values like $5\text{ m}, 50\text{ cm}$ are chosen for demonstration.)

Step 2 - SOLVE

1. What is Type Conversion?

Type conversion is the process of changing a value of one data type into another data type. For built-in types (e.g., int to float), the compiler performs conversions automatically. But for user-defined types (class objects), the compiler does not know the conversion rule, so the programmer must define it explicitly.

Three kinds exist:

• basic to class type
• class to basic type
• class to class type (the focus here)

2. Two Ways of Converting One User-Defined Object to Another

Method 1 - Constructor in the Destination class: A single-argument (conversion) constructor is written in the destination class taking a source object as argument.

class Destination {
public:
    Destination(Source s) { /* extract and assign */ }
};

On Destination d = s; the compiler calls this constructor.

Method 2 - Overloaded Casting (Conversion) Operator in the Source class: A conversion function operator Destination() is written in the source class.

class Source {
public:
    operator Destination() { Destination t; /* fill t */ return t; }
};

On Destination d = s; the compiler calls this operator.

Rule: the conversion routine is placed in the destination class (constructor) or in the source class (operator function), never split.

3. Program (both methods)

#include <iostream>
using namespace std;

class Distance {              // Destination class
    float feet, inch;
public:
    Distance(float f = 0, float i = 0) { feet = f; inch = i; }
    void display() {
        cout << "Feet : " << feet << " ft, Inch : " << inch << " in" << endl;
    }
};

class Meter {                 // Source class
    float meter, centimeter;
public:
    Meter(float m = 0, float cm = 0) { meter = m; centimeter = cm; }

    void display() {
        cout << "Meter: " << meter << " m, cm: " << centimeter << " cm" << endl;
    }

    // Method 2: conversion (casting) operator in source class
    operator Distance() {
        // 1 m = 3.3 feet, 1 cm = 0.4 inch
        return Distance(meter * 3.3f, centimeter * 0.4f);
    }
};

int main() {
    Meter m1(5, 50);           // 5 m, 50 cm
    m1.display();

    Distance d1 = m1;          // calls operator Distance()
    d1.display();

    return 0;
}

(Alternatively, Method 1 uses a Distance(Meter m) constructor with feet = m.getMeter()*3.3; inch = m.getCentimeter()*0.4;.)

4. Verification of Calculation (for 5 m, 50 cm)

$$\text{feet} = 5 \times 3.3 = 16.5\ \text{ft}$$ $$\text{inch} = 50 \times 0.4 = 20.0\ \text{in}$$

Output:

Meter: 5 m, cm: 50 cm
Feet : 16.5 ft, Inch : 20 in

Pass by Reference in C++

Definition

Pass by reference is a method of passing arguments to a function where the address (location) of a variable is passed to the function. When a function is called by reference, the formal arguments become references to the actual arguments. This means any changes made to the formal parameters inside the function directly affect the actual arguments in the calling function.

In contrast, pass by value sends a copy of the data, so the original variable remains unchanged.

Passing Arguments by Reference Using Reference Variables

In C++, a reference variable is an alias (another name) for an existing variable. It is declared using the & symbol. When used as a function parameter, the formal parameter becomes a reference to the actual argument -- no copy is made, and changes inside the function reflect in the original variable.

Syntax:

return_type function_name(data_type &param1, data_type &param2);

Example: Swapping Two Numbers Using Pass by Reference

#include <iostream>
using namespace std;

// Function using reference variables as parameters
void swap(int &a, int &b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;

    cout << "Before swap: x = " << x << ", y = " << y << endl;

    swap(x, y);   // x and y are passed by reference

    cout << "After swap:  x = " << x << ", y = " << y << endl;

    return 0;
}

Output:

Before swap: x = 10, y = 20
After swap:  x = 20, y = 10

Explanation

Key Points

• The & symbol in the parameter list makes the parameter a reference variable.
• The formal argument and actual argument share the same memory location.
• No separate copy of the variable is created, unlike pass by value.
• This is useful when a function needs to modify the original variable or when passing large objects to avoid overhead of copying.

Exception Handling in C++ with try...catch

What is an Exception?

An exception is an unusual or abnormal event (error condition) that occurs during the execution of a program and disrupts the normal flow of the program's instructions. Examples include division by zero, file not found, invalid memory access, and array index out of bounds.

Exceptions provide a way to transfer control from one part of a program to another. C++ exception handling is built upon three keywords: try, catch, and throw.

Why is Exception Handling Better to Use?

Key benefits:

• Keeps the normal logic and error-handling logic separate
• Prevents abnormal program termination
• Allows recovery from runtime errors
• Makes code more readable and maintainable

Three Keywords of Exception Handling

1. try -- Defines a block of code to be tested for errors while it is being executed. A block that may raise an exception is placed inside a try block (called protected code).
2. throw -- Used to throw (signal) an exception when a problem is detected.
3. catch -- Catches the exception thrown by the try block and handles it. The catch keyword indicates the catching of an exception.

Syntax

try {
    // protected code
    // code that might throw an exception
    throw exception_value;
}
catch (type variable) {
    // exception handler
    // code to handle the exception
}

A try/catch block is referred to as protected code.

Example: Division by Zero

#include <iostream>
using namespace std;

int divide(int a, int b) {
    if (b == 0) {
        throw "Division by zero is not allowed!";  // throw exception
    }
    return a / b;
}

int main() {
    int x = 10, y = 0;

    try {
        // protected code
        int result = divide(x, y);
        cout << "Result: " << result << endl;
    }
    catch (const char* msg) {
        // exception handler
        cout << "Exception caught: " << msg << endl;
    }

    cout << "Program continues after exception handling." << endl;

    return 0;
}

Output:

Exception caught: Division by zero is not allowed!
Program continues after exception handling.

How it Works (Step by Step)

Step 1: divide(10, 0) is called inside the try block
Step 2: Inside divide(), b == 0, so throw is executed
Step 3: Control immediately transfers to the matching catch block
Step 4: catch(const char* msg) catches the thrown string
Step 5: Error message is displayed
Step 6: Program continues normally after the catch block

Summary

Exception handling ensures that even when errors occur at runtime, the program can handle them gracefully and continue execution rather than crashing abruptly.