Любую простую операцию (a + b, a - b, a * b, ..., a[b], a(b), и т.п.) можно перегрузить для произвольных типов. Чаще всего это используется для сравнения элементов (операторы "<", "==", "!=", и т.п.), также их очень удобно использовать в геометрии (например, запись c = a - b, где a, b, c -- вектора, выглядит понятно и компактно). Итак, будем рассматривать для примера структуру точка, она же -- вектор:

struct pt
{
    int x, y;
};

Сделаем так, чтобы можно было вычитать один вектор из другого -- очень частая операция, -- просто написав "-":

pt operator-(pt a, pt b)
{
    pt ans;
    ans.x = a.x - b.x;
    ans.y = a.y - b.y;
    return ans;
}

Так мы перегрузили оператор "-". Выглядит очень похоже на функцию. Действительно, pt -- возвращаемый тип, дальше вместо названия функции -- ключевое слово operator и сама операция ("-"). Затем принимаемые аргументы (в большинстве случаев их два), затем, собственно тело оператора, как и у функции.
Теперь можно вычитать вектора, как числа:

pt a, b;
//инициализируем a, b
pt c = a - b;

Какие еще есть простые операции над векторами? Для начала сложение, пишется почти так же:

pt operator+(pt a, pt b)
{
    pt ans;
    ans.x = a.x + b.x;
    ans.y = a.y + b.y;
    return ans;
}

Унарный минус должен принимать только один аргумент:

pt operator-(pt a)
{
    pt ans;
    ans.x = -a.x;
    ans.y = -a.y;
    return ans;
}

(ничего страшного в том, что у нас теперь два "operator-" нет, так как они принимают разные параметры).
Теперь произведение. Тут проблема в том, что их два, а знак "*" -- один. Кто как решает эту проблему, у меня operator* -- векторное, а operator/ -- скалярное. Может, это не самый красивый способ, но для примера сойдет. Итак, векторное произведение:

int operator*(pt a, pt b)
{
    return a.x * b.y - a.y * b.x;
}

Теперь проверка на то, что точка C лежит на прямой, проходящей через точки A и B, пишется очень коротко:

if ((C - A) * (B - A) == 0) //C лежит на A--B
else //C не лежит на A--B
    
(мы берем векторное произведение векторов AC (C - A) и AB (B - A) и проверяем на равенство нулю)

Можно переопределять операторы между разными типами. Например, умножение вектора на число (целое):

pt operator*(pt a, int k)
{
    pt ans;
    ans.x = a.x * k;
    ans.y = a.y * k;
    return ans;
}

Теперь можно писать

pt A;
int k;
...
pt B = A * k;

НО! написать

pt С = k * A;

не получится, так как для этого нужен 

pt operator*(int k, pt a)

то есть, в другом порядке.

Порядок выполнения операций вроде остается тем же, но лучше все-таки поставить лишние скобки =).