Unit 3: C++ Operators and Type Casting: An Exam-Ready Guide

Operators in C++

Introduction to Operators

Operators are symbols that tell the compiler to perform specific mathematical or logical manipulations. C++ is rich in built-in operators and provides the following types of operators:

• Arithmetic Operators: Used for mathematical calculations (e.g., +, -, *, /, %).
• Relational Operators: Used for comparisons (e.g., ==, !=, >, <, >=, <=).
• Logical Operators: Used to combine or negate boolean expressions (e.g., &&, ||, !).
• Bitwise Operators: Used to perform operations on individual bits (e.g., &, |, ^, ~, <<, >>).
• Assignment Operators: Used to assign values to variables (e.g., =, +=, -=).
• Conditional (Ternary) Operator: A shorthand for an if-else statement (? :).
• Increment/Decrement Operators: Used to increase or decrease a value by one (++, --).
• Special Operators: Includes sizeof, comma operator (,), and the member dereferencing operators (., ->) and scope resolution operator (::) which are discussed in detail below.

Scope Resolution Operator (::)

Understanding the Scope Resolution Operator

Definition: The scope resolution operator (::) in C++ is used to identify and access the scope to which an identifier (like a variable or function) belongs. It helps in resolving ambiguities when names are duplicated in different scopes.

When there are multiple scopes (e.g., a global scope and a local scope within a function or a class scope), the compiler needs a way to distinguish between identically named entities. The scope resolution operator provides this mechanism.

Uses of Scope Resolution Operator

• Accessing a global variable when there is a local variable with the same name: If a local variable has the same name as a global variable, the local variable hides the global one. The :: operator can be used to explicitly access the global variable.
• Defining a function outside a class: When a member function is defined outside its class declaration, the scope resolution operator is used to tell the compiler which class the function belongs to.
• Accessing static members of a class: Static members (variables or functions) belong to the class rather than an object. They can be accessed using the class name followed by the scope resolution operator.
• Accessing members of a base class from a derived class: In inheritance, if a derived class member hides a base class member with the same name, the :: operator can be used to access the base class member.

Example: Accessing a global variable

int global_var = 10; // Global variableint main() {    int global_var = 20; // Local variable with the same name    std::cout << "Local variable: " << global_var << std::endl;    std::cout << "Global variable: " << ::global_var << std::endl;    return 0;}

Explanation: In this example, global_var inside main() refers to the local variable. To access the global global_var, we use ::global_var.

Member Dereferencing Operators (. and ->)

The Dot Operator (.)

Definition: The dot operator (.) is used to access members (data members or member functions) of a structure or class when working directly with an object of that type.

When you have an actual object (an instance of a class or struct), you use the dot operator to directly call its methods or access its public data members.

Example: Using the dot operator

struct Person {    std::string name;    int age;};int main() {    Person p1;    p1.name = "Alice"; // Accessing member 'name' using the dot operator    p1.age = 30;      // Accessing member 'age' using the dot operator    std::cout << "Name: " << p1.name << ", Age: " << p1.age << std::endl;    return 0;}

The Arrow Operator (->)

Definition: The arrow operator (->) is used to access members (data members or member functions) of a structure or class through a pointer to an object of that type. It effectively dereferences the pointer and then accesses the member in one step.

When you have a pointer that points to an object, you cannot use the dot operator directly with the pointer. Instead, you use the arrow operator. It is a convenience operator equivalent to dereferencing the pointer first and then using the dot operator (e.g., (*pointer).member is equivalent to pointer->member).

Example: Using the arrow operator

struct Person {    std::string name;    int age;};int main() {    Person* p2 = new Person(); // Pointer to a Person object    p2->name = "Bob"; // Accessing member 'name' using the arrow operator    p2->age = 25;    // Accessing member 'age' using the arrow operator    std::cout << "Name: " << p2->name << ", Age: " << p2->age << std::endl;    delete p2; // Don't forget to free dynamically allocated memory    return 0;}

Comparison: Dot vs. Arrow Operator

Type Casting

Introduction to Type Casting

Definition: Type casting is a mechanism in C++ to explicitly convert a variable or an expression from one data type to another. It allows the programmer to override the default type conversions that the compiler might perform.

Casting is crucial when operations involve different data types, especially to ensure correct calculation or to prevent data loss. It can be performed implicitly by the compiler or explicitly by the programmer.

Implicit Type Casting (Coercion)

Definition: Implicit type casting, also known as type coercion, is an automatic type conversion performed by the compiler without any explicit instruction from the programmer. This usually happens when converting a smaller data type to a larger data type to prevent data loss.

The compiler performs implicit conversions when it determines that the conversion is safe and makes logical sense. These conversions typically occur in the following scenarios:

• Type Promotion: Converting a smaller integral type (like char, short, int) to a larger integral type (like long, long long) or a floating-point type (float to double).
• Assignment Conversion: When assigning a value of one type to a variable of another type, if the target type can accommodate the source type without loss of data, an implicit conversion occurs.
• Arithmetic Conversions: In expressions involving operands of different types, the compiler often promotes the smaller type to the larger type before performing the operation.
• Function Call Conversions: When passing arguments to functions, if the argument type does not match the parameter type, an implicit conversion may occur if a suitable conversion exists.

Example: Implicit Type Casting

int int_val = 10;double double_val = int_val; // int implicitly converted to double (promotion)std::cout << "double_val: " << double_val << std::endl; // Output: 10.0double result = 7.0 / 2; // int 2 is implicitly converted to double 2.0 before divisionstd::cout << "result: " << result << std::endl; // Output: 3.5

Explicit Type Casting

Definition: Explicit type casting, also known as type conversion, is performed by the programmer using specific casting operators. It is used when the compiler cannot implicitly convert types safely, or when a programmer wants to force a conversion that might involve potential data loss.

Explicit casts are necessary when you need to convert a larger type to a smaller type, or when you want to interpret a value of one type as another. These conversions carry a risk of data loss or misinterpretation if not handled carefully.

C-style Type Casting

This is a traditional way of casting derived from C. It's concise but less safe than C++ specific casts as it performs a combination of conversions without explicit checks.

Syntax: (target_type) expression

Example: C-style cast

double pi = 3.14159;int integer_pi = (int)pi; // Explicit C-style cast: double to intstd::cout << "integer_pi (C-style): " << integer_pi << std::endl; // Output: 3 (fractional part lost)

C++ Functional Style Casting

This syntax resembles a function call and is also inherited from C, though it can be used in C++.

Syntax: target_type(expression)

Example: C++ functional style cast

float my_float = 123.45f;int my_int = int(my_float); // Explicit C++ functional-style cast: float to intstd::cout << "my_int (Functional): " << my_int << std::endl; // Output: 123

static_cast (C++ specific cast operator)

static_cast is the most commonly used C++ casting operator for general type conversions. It performs conversions that are implicitly defined and allowed by the language, and it provides compile-time checking for type safety.

Syntax: static_cast<target_type>(expression)

It can be used for conversions between related types (e.g., numeric type conversions, conversions within an inheritance hierarchy, conversions from void* to other pointers, etc.). It is generally safer and more explicit than C-style casts because it indicates the specific type of conversion being performed and has stricter rules.

Example: static_cast

double temperature = 98.6;int whole_temperature = static_cast<int>(temperature); // Explicit static_cast: double to intstd::cout << "whole_temperature (static_cast): " << whole_temperature << std::endl; // Output: 98int num1 = 10, num2 = 3;double division_result = static_cast<double>(num1) / num2; // Convert num1 to double before divisionstd::cout << "division_result: " << division_result << std::endl; // Output: 3.33333

Important Note: While C-style and functional-style casts are simpler, static_cast is preferred in modern C++ because it makes the intent of the conversion clearer and allows the compiler to perform more robust checks, leading to safer code.