At the Kona committee meeting, it was voted (by someone, probably LEWG, I forget the story, I wasn’t in the room) to eliminate the overloaded operator() from C++2a std::span. Now it has only operator[].

The overloaded operator() was there merely for consistency with std::mdspan, which isn’t slated for C++2a.

std::mdspan needed an overloaded operator() because it couldn’t use overloaded operator[] because operator[] is a purely binary operator: s[a] means s.operator[](a), but s[a,b] means s.operator[]((a,b)) which means the same thing as s.operator[](b) because that’s what the comma operator does.

According to the minutes of the Kona meeting (again I wasn’t in the room), Corentin Jabot’s P1161R2 “Deprecate uses of the comma operator in subscripting expressions” (October 2018) was forwarded to CWG for inclusion in C++2a. This is great news!

Because the next thing that could happen, after a period of deprecation, is that C++2b might finally allow multi-argument operator[] overloads, the same way C++98 allowed multi-argument operator() overloads. Then mdspan (which is slated for C++2b) could use a multi-argument operator[]: you could index a single span as s[a] and a multi-dimensional mdspan as s[a,b]. (Of course then we’d really have to argue about whether C++ has multidimensional arrays or just single-dimensional arrays of arrays. I think the right answer is the latter. But anyway…)

Talking about multi-argument operator overloads over breakfast made me think up the following code snippet.

#include <type_traits>

struct A {
    int value = 0;
    A(int v): value(v) {}

    template<class... Ts,
             class = std::enable_if_t<(std::is_same_v<Ts, A> && ...)>>
    A operator+(Ts... ts) {
        return A((this->value + ... + ts.value));
    }
};

A a = 1;
A b = a;
A c = a + b;
A d = a + b + c;
A e = a + b + c + d;

Here I’ve given A a variadic overloaded operator+ that accepts any number of A objects and adds them together using a C++17 fold-expression. And Clang is totally happy with this code.

But if your coworker wrote this code, hoping for some expression-templatey kind of thing, they’d be sadly mistaken! This example might make clearer what’s going on: we have here an operator+ that can accept a variadic number of parameters, but the compiler will never give it more than the usual two at a time. All we’ve done by making it variadic is we’ve permitted the same operator to be called as both a binary operator (a+b) and a unary operator (+a). There’s no such thing in C++ as a “ternary operator +”!

See also: the prefix-or-postfix-I-don’t-care increment operator.