Operators

There are different types of operators in C++. More detail can be studied at this article.

Various Operators

1. Arithmetic

void arithmatic() {
  int x = 0;
  
  x = x + 1;
  x = x - 1;
  x = x * 2;
  x = x / 3;
  x = x % 2;
  
  x++;
  x--;
}

Bitwise Operators

void bitwise() {
  int x = 0;
  
  x = x | 0b0001;
  x = x & 0b0000;
  x = x ^ 0b0001;
}

void great_example_of_xor_operator() {
  int a = 1;
  int b = 0;
  
  // Check if a and b are exclusive from each other
  if ((a == 1 && b == 0) || (a == 0 && b == 1)) {
    // ...
  }
  
  // We can actually do this:
  if (a xor b)
  // or
  if (a ^ b)
}

2. Assignment

void assignment() {
  int x = 0;
  
  x = x + 3; // full form
  x += 3;    // shortcut

  x -= 3;
  x *= 3;
  x /= 3;
  x %= 3;
  x &= 3;
  x |= 3;
  x ^= 3;
  x >>= 3;
}

3. Comparison

void comparison() {
  int x = 0;
  int y = 1;
  
  if (x == y)
  if (x != y)
  if (x > y)
  if (x < y)
  if (x >= y)
  if (x <= y)
}

4. Logical

void logical() {
  int x = 0;
  int y = 1;
  
  if (x == 1 && y == 1)
  if (x == 1 || y == 1)
  if (! (x == 1 && y == 1) )
}

Operator Overloading

The operators would be boring if they were only applied to integers as demonstrated in the examples above. We can actually inform the C++ compiler what operators should do for our classes. Let's reuse the Vector of integers we built before and define some interesting operators.

// file: vector.hh

class Vector {
private:
    int* m_array;   // Pointer to dynamically allocated array
    int m_max_size; // Max size of the vector
    int m_size;     // Current size of the vector

public:
    Vector(int max_size);
    ~Vector();
  
    bool push_back(int value);
    int pop_back();
  
    Vector operator+=(const Vector& other) const; // operator +=
    Vector operator+(const Vector& other) const; // operator +

    bool operator==(const Vector& other) const;  // operator==
    bool operator!=(const Vector& other) const;  // operator!=
  
    Vector operator*=(int multiply_with); // * operator to multiply all integers by a number
 
    // ...
};

// operator+ definition
Vector Vector::operator+=(const Vector& other) const {
    // allocate memory that can hold data from both vectors
    Vector result(this->m_max_size + other.m_max_size);
 
    for (int i = 0; i < m_size; ++i) {
        result.push_back(m_array[i]);
    }
    for (int i = 0; i < other.m_size; ++i) {
        result.push_back(other.m_array[i]);
    }
 
    return result;
}

Vector Vector::operator+(const Vector& other) const {
    Vector result(*this);
    result += other;
    return result;
}

// operator== definition
bool Vector::operator==(const Vector& other) const {
    const bool is_equal = true;

    if (m_size != other.m_size) {
        return !is_equal;
    }

    for (int i = 0; i < m_size; ++i) {
        if (m_array[i] != other.m_array[i]) {
            return !is_equal;
        }
    }

    return is_equal;
}

// operator!= definition
bool Vector::operator!=(const Vector& other) const {
    return !(*this == other);
}

Vector operator*=(int multiply_with) {
  for (int i = 0; i < m_size; ++i) {
    m_array[i] *= multiply_with;
  }
  return *this;
}

Here is how the operators may be used:

void vector_plus_operator_example() {
  puts("Let's practice strings");

  Vector v1(6);
  v1.push_back(1);
  v1.push_back(2);
  v1.push_back(3);

  Vector v2(3);
  v1.push_back(4);
  v1.push_back(5);
  v1.push_back(6);

  // Use our operator to add contents of two vectors
  v1 = v1 + v2;
  v1.print();
}

void vector_multiply_operator_example() {
  Vector v1(6);
  v1.push_back(1);
  v1.push_back(2);
  v1.push_back(3);

  // Multiply operator in action
  v1 *= 5;
  v1.print();
}

Exercises

Vector library operators

Let's implement a few more operators for your vector library. Typically, the [ ] operator is implemented such that it returns a reference to one of the elements of the vector, but in our case, we will return a read-only value.

class Vector {
private:
    int* m_array;   // Pointer to dynamically allocated array
    int m_max_size; // Max size of the vector
    int m_size;     // Current size of the vector

public:
    Vector(int max_size);
    ~Vector();
  
    // First implement an "at()" API
    // Return an element at a particular index
    int at(int index);
  
    // Secondly, implement the [] operator:
    const int operator[](int index);
}

String library operators

Implement the following string operators, and also write unit-test code in main.cpp to test that the code you wrote actually functions correctly.

class string
{
    std::unique_ptr<char[]> m_string;
    int m_max_length;

public:
    string(int max_length);
    string(const char *c_string);
    
    // ------------------------------------
    // Implement the following operators
    // ------------------------------------
  
    // Adds two strings together
    string operator+=(const string& other) const;
    // "hello world" - "world" = "hello"
    string operator-=(const string& other) const;

    // "hello" * 2 = "hellohello"
    string operator*=(int how_many_times) const;

    // Implement shift operators to trim beginning or end of string
    // 0b1101 >> 1 ==> 0b0110
    // "hello" >>= 1 ==> "hell"
    // "hello" >>= 3 ==> "he"
    string operator>>=(int shift_right_by) const;

    // similar to python for slice operation
    string operator<<=(int shift_right_by) const;

    // All comparison operators are applicable
    // string s1("hello"); string s2("world")
    // if (s1 == s2)
    // if (s1 != s2)
    bool operator!=(const string &compare_with) const { 
        return !(*this == compare_with);
    }
    bool operator==(const string &compare_with) const {
        // todo
        return false;
    }
  
    // Implement comparison operators
    bool operator<=(const string &compare_with) const;
    bool operator>=(const string &compare_with) const;
    bool operator<(const string &compare_with) const;
    bool operator>(const string &compare_with) const;
    bool operator!=(const char* compare_with) const;
    bool operator==(const char* compare_with) const;
}