Special Operators in C++

C++ is a strong and flexible programming language that provides a large range of operators to modify data and carry out various operations. Among these operators are the so-called "special operators", which are special in their functionality and necessary for more complex programming jobs. In this article, we will learn the use of special operators in C++ with their function, syntax, and examples with outputs in this post.

What Are Special Operators?

The special operator is a subset of the more prevalent arithmetic, assignment, and relational operators in C++. Special operators are used for a variety of applications. They give programmers the means to carry out tasks that ordinary operators might find challenging. The special operators are like;

Ternary conditional operator (?:),
The comma operator (,),
The scope resolution operator (::),
The sizeof operator (sizeof),
The pointer-to-member operator (.* and ->*)
The member selection operator (. and ->)

1. The Ternary Conditional Operator (? :)

The "conditional operator" or "ternary operator", sometimes known as the ternary conditional operator. It is mainly utilized in conditional statements. It enables you to write condensed conditional statements by assessing a condition and returning one of two values depending on whether the condition is true or false.

Syntax:

It has the following Syntax:

Example:

#include <iostream>
using namespace std;

int main() {
    int x = 10, y = 20;
    int max_num = (x > y) ? x : y;
    
    cout << "The maximum number is: " << max_num << endl;
    
    return 0;
}

Output:

The maximum number is: 20

Explanation:

In this case, is (x > y) ? x : y; determines whether x is greater than y. If true, it gives max_num the value of x; if false, it gives max_num the value of y. This operator is very helpful to write concise and legible code.

2. The Comma Operator (,)

In C++, you can evaluate several expressions that are separated by commas from left to right by using the comma operator. It gives back the rightmost expression's value.

Syntax:

It has the following syntax:

Example:

#include <iostream>
using namespace std;

int main() {
    int x = 5, y = 10, z = 15;
    int result = (x++, y++, x + y + z);
    
    cout << "Result: " << result << endl;
    
    return 0;
}

Output:

Result: 30

Explanation:

This example computes the total of x, y, and z after using the comma operator to increment x and y. Because of how x and y change before the addition, the outcome is 30.

3. The Scope Resolution Operator (::):

When local and global variables conflict, the C++ scope resolution operator is used to access members of a class or namespace or to access static members of a class.

Syntax:

It has the following syntax:

Example:

#include <iostream>
using namespace std;

class MyClass {
public:
    static int x;
};

int MyClass::x = 42;

int main() {
    int x = 10;
    
    cout << "Local x: " << x << endl;
    cout << "Class x: " << MyClass::x << endl;
    
    return 0;
}

Output:

Local x: 10
Class x: 42

4. The Sizeof Operator (sizeof):

In C++, the sizeof operator is used to calculate an object's or data type's size in bytes. When working with arrays or dynamically allocated memory, it is extremely helpful.

Syntax:

It has the following syntax:

sizeof(data_type);
sizeof(object);

Example:

#include <iostream>
using namespace std;

int main() {
    cout << "Size of int: " << sizeof(int) << " bytes" << endl;
    cout << "Size of double: " << sizeof(double) << " bytes" << endl;
    
    return 0;
}

Output:

Size of int: 4 bytes
Size of double: 8 bytes

Another example:

#include <iostream>
using namespace std;
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    
    cout << "Size of arr: " << sizeof(arr) << " bytes" << endl;
    
    return 0;
}

Output:

Size of arr: 20 bytes

5. The Pointer-to-Member Operators (.* and ->*)

In C++, you can access members of a class via pointers to objects or pointers to member functions by using the pointer-to-member operators.

Syntax for . operator:

It has the following syntax:

Syntax for -> operator:

It has the following syntax:

Example: 1

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;
    int y;
};

int main() {
    MyClass obj;
    obj.x = 10;
    obj.y = 20;

    MyClass* ptr = &obj;
    int MyClass::*member_ptr = &MyClass::x;

    cout << "Using .* operator: " << obj.*member_ptr << endl;
    cout << "Using .* operator with pointer: " << ptr->*member_ptr << endl;

    return 0;
}

Output:

Using .* operator: 10
Using .* operator with pointer: 10

Example: 2

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;
    int y;
};

int main() {
    MyClass obj;
    obj.x = 10;
    obj.y = 20;

    MyClass* ptr = &obj;
    int MyClass::*member_ptr = &MyClass::y;

    cout << "Using ->* operator: " << ptr->*member_ptr << endl;

    return 0;
}

Output:

Using ->* operator: 20

6. The Member Selection Operators (. and ->)

If you want to access members of a class or structure, use the member selection operators in C++, which include the dot. operator and the arrow -> operator.

Syntax:

It has the following syntax:

object.member;
pointer_to_object->member;

Example:

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;
    int y;
};

int main() {
    MyClass obj;
    obj.x = 10;
    obj.y = 20;

    cout << "Using . operator: " << obj.x << endl;

    return 0;
}

Output:

Using . operator: 10

Another example:

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;
    int y;
};

int main() {
    MyClass* ptr = new MyClass;
    ptr->x = 10;
    ptr->y = 20;

    cout << "Using -> operator: " << ptr->y << endl;

    delete ptr;

    return 0;
}

Output:

Using -> operator: 20

Explanation:

In this example, we use the new operator to dynamically allocate a MyClass object, and the -> operator to access its y member. To prevent memory leaks, don't forget to use delete to release the memory.

Conclusion:

In this article, we have covered the special operators in C++ and their numerous applications. These operations are essential for creating understandable, concise, and effective code for a variety of programming tasks.

You'll get a deeper grasp of C++ and be better prepared to manage challenging programming tasks by mastering the ternary conditional operator, comma operator, scope resolution operator, sizeof operator, and pointer-to-member operators. The member selection operators are additionally essential for interacting with classes and structures.

These special operators will be useful tools in your programming toolkit as you learn more about C++ and create more complex applications. To build confidence in using these operators successfully in your code, keep in mind that you should practise and experiment with them.

Next TopicPrim's Algorithm in C++

← prev next →