Creating the very long arrow operator --->

#cpp

Article::Article

In my previous article, I used the long arrow -->, but it is possible to use an arrow even bigger! Your dreams are now a reality, let's make an entrance for the very long arrow --->

How? The same way that --> is a combination of -- and >, the very long arrow ---> is the combination of -- and ->.

Reminders about operator ->

The operator -> and its overload are a bit special. For the rest of the article I will assume that you know how it works. If that's not the case, I recommend you to read:

this article if you read French
otherwise the first response of this Stack Overflow thread

Implementation

Basic

The first step is to define two classes: Base and Extension. Then overload the operator -- of Base to create and return an object of type Extension. After that, overload the operator -> of Extension to return a pointer to itself. The last step is to add a member function to Extension. It is now possible to use a very long arrow --->. Here's the code:

#include <utility>
#include <iostream>

struct Base {};

struct Extension
{
    const Extension* operator->() const
    {
        return this;
    }

    void print() const
    {
        std::cout << "long arrow" << std::endl;
    }
};

Extension operator--(const Base&, int)
{
    return Extension{};
}

int main()
{
    Base base;
    base--->print();
}

Compiler explorer link

Possible usage

The previous example is totally useless, let's see a possible usage of what you can do with it: extend a class without touching it.

Let's imagine I want to add a simple method to std::string, like something to transform it from upper case to lower case. It is possible to do this:

#include <cctype>
#include <string>
#include <iostream>
#include <algorithm>

struct StringExtension
{
    StringExtension* operator->()
    {
        return this;
    }

    void to_lower()
    {
        auto lower = [](unsigned char c) { return std::tolower(c); };
        std::transform(str.begin(), str.end(), str.begin(), lower);
    }

    std::string& str;
};

StringExtension operator--(std::string& str, int)
{
    return StringExtension{ str };
}

int main()
{
    std::string str = "HELLO";
    str--->to_lower();
    std::cout << str << std::endl;
}

Compiler explorer link

The logic is simple: create a class with all the member function we want to add with a reference to the class you want to extend. Overload the operator -> of this new class to return a pointer to itself and then overload the operator -- of the class you want to extend returning an object of the extension class. That's it.