{"id":4536,"date":"2025-07-14T11:40:33","date_gmt":"2025-07-14T08:40:33","guid":{"rendered":"https:\/\/www.certbolt.com\/certification\/?p=4536"},"modified":"2025-12-31T13:39:53","modified_gmt":"2025-12-31T10:39:53","slug":"empowering-custom-types-a-comprehensive-exploration-of-operator-overloading-in-c","status":"publish","type":"post","link":"https:\/\/www.certbolt.com\/certification\/empowering-custom-types-a-comprehensive-exploration-of-operator-overloading-in-c\/","title":{"rendered":"Empowering Custom Types: A Comprehensive Exploration of Operator Overloading in C++"},"content":{"rendered":"

In the sophisticated landscape of C++ programming, where the expressive power of object-oriented paradigms converges with granular control over system resources, operator overloading emerges as a quintessential feature. This powerful mechanism empowers developers to redefine the intrinsic behavior of standard operators when applied to user-defined data types, such as classes and structures. Far from merely being a syntactic convenience, operator overloading profoundly enhances code clarity, promotes reusability, and facilitates a more intuitive interaction with custom objects, allowing them to emulate the seamless manipulation afforded to built-in data types. This exhaustive treatise will delve into the profound intricacies of operator overloading, dissecting its core philosophy, elucidating its diverse forms, distinguishing it from related concepts like function overloading, meticulously detailing the panorama of overloadable and non-overloadable operators, and critically assessing its advantages, disadvantages, and the indispensable best practices for its judicious application within the robust architecture of C++ programs.<\/span><\/p>\n

Deconstructing the Essence: What Constitutes Operator Overloading in C++?<\/b><\/p>\n

At its heart, operator overloading in C++ is a polymorphic feature that grants programmers the ability to furnish special meanings to standard operators (like +, -, *, \/, ==, <<, >>, etc.) when these operators are invoked with instances of user-defined data types. Without operator overloading, applying a binary operator such as + to two custom objects would result in a compilation error, as the compiler would lack an inherent understanding of how to perform addition (or any other operation) on complex, programmer-defined entities. Operator overloading bridges this semantic gap, allowing custom objects to participate in expressions with a natural, intuitive syntax, akin to how built-in types interact.<\/span><\/p>\n

The fundamental rationale underpinning the inclusion of operator overloading in C++ is multifaceted:<\/span><\/p>\n

Elevating Code Readability and Intuitiveness: Perhaps the most compelling argument for operator overloading is its profound impact on code readability. Imagine managing complex number arithmetic without the ability to use + or -. One would be relegated to verbose function calls like complex1.add(complex2) or matrix1.multiply(matrix2). Operator overloading transforms these into complex1 + complex2 or matrix1 * matrix2, making the code significantly more intuitive, resembling standard mathematical notation, and thereby reducing the cognitive load on the reader.<\/span><\/p>\n

Enhancing Usability of User-Defined Types: By permitting custom data types to behave congruously with intrinsic types, operator overloading dramatically enhances their usability. Objects can be added, subtracted, compared, streamed, or dereferenced using familiar symbols, leading to more fluid and natural programming paradigms. This consistency fosters a more cohesive and less fragmented codebase.<\/span><\/p>\n

Simplifying Complex Expressions: For intricate computational models involving user-defined objects, operator overloading can drastically simplify expressions. Instead of chaining multiple method calls, a single expression involving overloaded operators can encapsulate sophisticated logic, leading to more compact and elegant solutions. This is particularly evident in domains like linear algebra, scientific computing, or graphical transformations where operations on custom classes like Vector or Matrix can be expressed very naturally.<\/span><\/p>\n

Promoting Code Reusability and Maintainability: Well-designed operator overloads contribute to code reusability. Once an operator’s behavior is defined for a class, it can be consistently applied wherever objects of that class are manipulated. This reduces redundant function definitions and fosters a more maintainable codebase, as changes to an operator’s behavior are centralized.<\/span><\/p>\n

In this example, the operator+ member function is implemented within the Complex class. When c1 + c2 is encountered, the compiler invokes c1.operator+(c2), performing component-wise addition of the real and imaginary parts. The result is a new Complex object representing their sum, demonstrating how operator overloading enables a natural and mathematically familiar syntax for user-defined types.<\/span><\/p>\n

The Overloadable Spectrum: Can All Operators in C++ Be Redefined?<\/b><\/p>\n

While operator overloading is a powerful feature in C++, it is not universally applicable to every single operator within the language’s extensive repertoire. The vast majority of operators can be overloaded, but a carefully curated set of exceptions exists. These exceptions are deliberate design choices by the C++ language architects to preserve fundamental language syntax, semantics, and performance characteristics.<\/span><\/p>\n

No, unequivocally, not all operators can be overloaded in C++. A select few are explicitly forbidden from redefinition to prevent potential ambiguities, maintain core language integrity, or because their behavior is intrinsically tied to low-level compiler functionality.<\/span><\/p>\n

The Imperative for Non-Overloadability: Understanding the Exclusions<\/b><\/p>\n

The deliberate decision to prevent overloading for certain operators in C++ is rooted in fundamental principles of language design, aiming to preserve core syntax, maintain semantic consistency, and avoid ambiguity. These exclusions are not arbitrary but rather strategic choices that underpin the predictability and robustness of the C++ programming model.<\/span><\/p>\n

:: (Scope Resolution Operator): This operator is a cornerstone of C++’s name lookup mechanism. It provides a deterministic way to access members within a specific scope (e.g., std::cout, ClassName::staticMember). Allowing it to be overloaded would introduce profound ambiguity in how names are resolved, potentially breaking the entire scoping and inheritance model of the language. Its behavior is fixed at compile time and is fundamental to how the compiler interprets code.<\/span><\/p>\n

. (Direct Member Access Operator): The dot operator provides direct access to the members (variables and functions) of an object. It’s a syntactic primitive that dictates how we interact with instances of classes and structures. Overloading . would fundamentally alter how member access works, leading to confusion and inconsistency. While -> (arrow operator) can be overloaded for smart pointers, . remains inviolable to ensure direct, unambiguous member access.<\/span><\/p>\n

.* (Pointer-to-Member Operator): This operator facilitates access to class members through pointers to members, a more advanced C++ feature. Similar to the direct member access operator, allowing .* to be overloaded would disrupt its core function of de-referencing a pointer-to-member, which is crucial for certain meta-programming patterns. Its behavior is deeply ingrained in the language’s type system for member pointers.<\/span><\/p>\n

?: (Ternary Conditional Operator): The ternary operator embodies a unique short-circuiting evaluation semantic. Only one of its two expressions (expr1 or expr2) is ever evaluated based on the condition. Overloading this operator would inevitably necessitate a change to this fundamental evaluation order or introduce complex, non-standard short-circuiting behaviors. This would break the predictability of conditional expressions and introduce profound logical ambiguities, making it incredibly difficult to reason about program flow.<\/span><\/p>\n

sizeof Operator: The sizeof operator is a compile-time construct. It determines the memory footprint of a type or variable entirely at compile time, without needing to execute any runtime code. Its result is fixed and known before the program even runs. Allowing sizeof to be overloaded would imply that its behavior could be dynamic or dependent on runtime conditions, which fundamentally contradicts its nature as a compile-time query.<\/span><\/p>\n

typeid Operator: typeid is integral to C++’s Runtime Type Identification (RTTI) system. It provides a mechanism to query an object’s actual type at runtime. Like sizeof, its behavior is deeply tied to the compiler and runtime environment’s internal type information. Overloading typeid would undermine the built-in, consistent, and reliable means of performing dynamic type checks, which is essential for polymorphic programming and dynamic casting.<\/span><\/p>\n

alignof Operator: Introduced in C++11, alignof returns the alignment requirement of a type, also a compile-time constant. Its purpose is to query memory alignment constraints, a low-level detail determined by the compiler and target architecture. Overloading it would contradict its compile-time, informational role.<\/span><\/p>\n

co_await Operator (C++20): This operator is a fundamental component of C++’s coroutines feature, designed for asynchronous programming. co_await performs a suspension and resumption of a coroutine, a highly specialized and compiler-managed control flow mechanism. Its behavior is deeply intertwined with the coroutine transformation process performed by the compiler. Overloading it would break the core mechanics of how coroutines are handled and would be semantically nonsensical in the context of user-defined behavior.<\/span><\/p>\n

In essence, these operators are excluded from overloading to preserve the foundational grammar, semantic clarity, and predictable behavior of the C++ language. Their core functionalities are deemed too critical and too deeply embedded in the language’s fundamental machinery to be subject to user-defined reinterpretation.<\/span><\/p>\n

The Tenets of Redefinition: Rules and Idioms for Operator Overloading in C++<\/b><\/p>\n

While operator overloading provides immense flexibility, it must be exercised with discipline to ensure that the code remains clear, intuitive, and robust. Adhering to established rules and idioms is crucial for effective and maintainable operator overloading in C++.<\/span><\/p>\n

Preserve Original Semantics (The Principle of Least Astonishment): This is perhaps the most crucial idiom. When overloading an operator, its custom behavior for your user-defined type should, wherever possible, align with the intuitive meaning of the operator for built-in types. For instance, overloading + to perform subtraction would be highly counterintuitive and lead to astonishing and error-prone code. Strive to make the operator’s behavior predictable and consistent with widely accepted mathematical or logical conventions.<\/span><\/p>\n

Only Overload Existing Operators: You cannot invent new operator symbols. You can only redefine the behavior of operators that already exist within the C++ language. For example, you cannot create an ** operator for exponentiation, as it’s not a standard C++ operator.<\/span><\/p>\n

Cannot Alter Precedence or Associativity: Overloading an operator does not change its fundamental precedence or associativity rules. For example, * will always have higher precedence than +, regardless of how they are overloaded. a + b * c will always be evaluated as a + (b * c). This ensures consistent parsing of expressions.<\/span><\/p>\n

Cannot Alter Arity (Number of Operands): The number of operands an operator takes (its arity) cannot be changed. Binary operators (like +, *) must always take two operands, and unary operators (like ++, !) must always take one. You cannot, for example, overload + to work with three operands.<\/span><\/p>\n

At Least One Operand Must Be a User-Defined Type: An operator function can only be overloaded if at least one of its operands is an object of a user-defined class or structure. You cannot overload operators for fundamental data types (e.g., you cannot redefine how int + int works). This rule prevents users from fundamentally altering the behavior of built-in types, which would lead to chaos and inconsistency across the language.<\/span><\/p>\n

Member Function vs. Non-Member (Friend) Function:<\/b><\/p>\n

Member Function: Overloaded as a member function, the left-hand operand is implicitly *this. For binary operators, it takes one explicit parameter (the right-hand operand). For unary operators, it takes no explicit parameters. This is suitable when the operation primarily affects the object itself.<\/span><\/p>\n

Non-Member (Friend) Function: Overloaded as a non-member function (often a friend function for access to private members), it takes all operands as explicit parameters. This is essential when the left-hand operand is not an object of the class (e.g., std::cout << myObject) or when the operation conceptually treats both operands equally.<\/span><\/p>\n

= (Assignment), [] (Subscript), () (Function Call), -> (Member Access) Must Be Member Functions: These four operators must be overloaded as non-static member functions. They cannot be overloaded as non-member or friend functions. This is a language rule to ensure consistency and proper behavior for fundamental object operations.<\/span><\/p>\n

Default Overloads for = and &: The assignment operator (=) and the address-of operator (&) are implicitly provided by the compiler with default member-wise copy semantics if you do not define them yourself. For &, this default behavior is almost always sufficient. For =, a custom copy assignment operator is often necessary when a class manages dynamic resources.<\/span><\/p>\n

Consider const Correctness: For operators that do not modify the object (e.g., ==, +, <<), they should ideally be declared as const member functions. This allows them to be invoked on const objects and clearly communicates their non-modifying nature.<\/span><\/p>\n

Symmetric Operations: For binary operators like +, ==, *, etc., consider whether you need symmetric behavior. If you overload Complex::operator+ as a member function, complex_obj1 + complex_obj2 works. But built_in_type + complex_obj1 (e.g., 5 + complex_obj1) will not work unless you define operator+ as a non-member (friend) function. Often, non-member overloads provide greater flexibility for mixed-type operations.<\/span><\/p>\n

Return by Value vs. Reference:<\/span><\/p>\n

For arithmetic operators (+, -, *, \/), it is common to return a new object by value, representing the result of the operation (e.g., Complex operator+(const Complex& other) { return Complex(…); }).<\/span><\/p>\n

For assignment operators (+=, -=, etc.), return *this by reference (ClassName& operator+=(const ClassName& other) { …; return *this; }) to allow chaining (e.g., a += b += c).<\/span><\/p>\n

For ++ and — (prefix), return *this by reference. For postfix, return a const copy of the object before incrementing\/decrementing.<\/span><\/p>\n

For comparison operators (==, !=, etc.), return bool.<\/span><\/p>\n

For stream operators (<<, >>), return a reference to the istream or ostream object.<\/span><\/p>\n

By conscientiously applying these rules and idioms, developers can ensure that their overloaded operators are not only functional but also intuitive, predictable, and easily maintainable within complex C++ applications.<\/span><\/p>\n

Unary Operator Overloading: Acting on a Single Operand<\/b><\/p>\n

Unary operators, as their name suggests, operate on a single operand (e.g., ++operand, —operand, !operand). Overloading these operators for user-defined types allows for intuitive manipulation and transformation of individual objects. Unlike binary operators, unary operators are almost always overloaded as member functions, as they inherently act upon the state of a single object.<\/span><\/p>\n

Syntax:<\/span><\/p>\n

C++<\/span><\/p>\n

class MyClass {<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ For prefix unary operators (e.g., -obj, !obj, ++obj)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0ReturnType operator op () const; \/\/ For non-modifying ops (e.g., !)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0MyClass& operator op ();\u00a0 \u00a0 \u00a0 \/\/ For modifying ops (e.g., prefix ++, —)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ For postfix unary operators (e.g., obj++, obj—) — takes a dummy int parameter<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0MyClass operator op (int); \/\/ Note: dummy int parameter for postfix distinction<\/span><\/p>\n

};<\/span><\/p>\n

Example: Negation Operator (- operator) for a Number class: Consider a simple Number class and overloading the unary — operator to negate its value.<\/span><\/p>\n

C++<\/span><\/p>\n

#include <iostream><\/span><\/p>\n

class Number {<\/span><\/p>\n

private:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0int value;<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number(int v = 0) : value(v) {}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0void display() const {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0std::cout << «Value: » << value << std::endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ Overloading unary ‘-‘ operator as a member function<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number operator-() const {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\/\/ Returns a new Number object with the negated value<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return Number(-value);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ Overloading prefix increment (++)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number& operator++() { \/\/ Prefix: increments and returns a reference to *this<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0++value;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return *this;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ Overloading postfix increment (++)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number operator++(int) { \/\/ Postfix: takes a dummy int, returns old value by value<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0Number temp = *this; \/\/ Save current state<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0++value; \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \/\/ Increment *this<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return temp; \u00a0 \u00a0 \u00a0 \u00a0 \/\/ Return saved state<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number num1(10);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Original «; num1.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number num2 = -num1; \/\/ Invokes num1.operator-()<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Negated «; num2.display(); \/\/ Expected: Value: -10<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number num3(5);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Original «; num3.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number num4 = ++num3; \/\/ Prefix increment: num3 becomes 6, num4 becomes 6<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «After prefix increment, num3: «; num3.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «num4 (result of prefix increment): «; num4.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number num5(7);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Original «; num5.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0Number num6 = num5++; \/\/ Postfix increment: num6 becomes 7, num5 becomes 8<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «After postfix increment, num5: «; num5.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «num6 (result of postfix increment): «; num6.display();<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n

In this illustration, Number::operator-() is a const member function because it does not modify the original num1 object; instead, it returns a new Number object with the negated value. The prefix operator++() modifies the object and returns a reference to the modified object, while the postfix operator++(int) returns a copy of the object’s state before modification, reflecting the semantic difference between prefix and postfix increment. The dummy int parameter is a C++ language convention to distinguish the postfix version.<\/span><\/p>\n

Special Operators: Expanding Object Functionality<\/b><\/p>\n

Beyond the standard arithmetic, relational, and logical operators, C++ allows for the overloading of several «special» operators that provide unique functionalities, enabling user-defined types to behave in highly flexible and powerful ways.<\/span><\/p>\n

Overloading the [] (Subscript Operator): The subscript operator allows objects of a class to be accessed using array-like syntax (e.g., myObject[index]). This is indispensable for implementing custom container classes, allowing direct element access with bounds checking or custom logic. The [] operator must be implemented as a non-static member function.<\/span>
\n<\/span>C++<\/span>
\n<\/span>#include <iostream><\/span><\/p>\n

#include <vector><\/span><\/p>\n

#include <stdexcept> \/\/ For std::out_of_range<\/span><\/p>\n

class DynamicArray {<\/span><\/p>\n

private:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::vector<int> elements;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0size_t size;<\/span><\/p>\n

public:<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0DynamicArray(size_t s) : size(s) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0elements.resize(s, 0);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ Overload [] for read\/write access<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0int& operator[](size_t index) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if (index >= size) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0throw std::out_of_range(«Index out of bounds for non-const access.»);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return elements[index];<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ Overload [] for read-only access (for const objects)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0const int& operator[](size_t index) const {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0if (index >= size) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0throw std::out_of_range(«Index out of bounds for const access.»);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0return elements[index];<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0size_t getSize() const { return size; }<\/span><\/p>\n

};<\/span><\/p>\n

int main() {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0DynamicArray arr(5);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0arr[0] = 10; \/\/ Uses int& operator[](size_t)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0arr[4] = 50;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Element at index 0: » << arr[0] << std::endl; \/\/ Uses const int& operator[](size_t)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Element at index 4: » << arr[4] << std::endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0const DynamicArray constArr(3);<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\/\/ constArr[0] = 10; \/\/ ERROR: cannot assign to a const object<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0std::cout << «Const array element at index 0: » << constArr[0] << std::endl; \/\/ Uses const int& operator[](size_t)<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0try {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0arr[5] = 100; \/\/ This will throw an exception<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0} catch (const std::out_of_range& e) {<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0std::cerr << «Error: » << e.what() << std::endl;<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

\u00a0\u00a0\u00a0\u00a0return 0;<\/span><\/p>\n

}<\/span><\/p>\n