CODEWITHSUNDEEP
c++staticoperator-overloadingindexing
jameszhao00
jameszhao00

Reputation: 7301

C++ static operator overloading

Is it possible to overload C++ class operators in the static context? e.g.

class Class_1{ ... }
int main()
{

    Class_1[val]...

}

Upvotes: 8

Views: 13113

Answers (5)

eh9
eh9

Reputation: 7430

As of C++23, it's possible to overload static operator(). As for other operators:

There are other operators that are currently required to be implemented as non-static member functions - all the unary operators, assignment, subscripting, conversion functions, and class member access. We do not believe that being able to declare any of these as static will have as much value, so we are not pursuing those at this time.

A compiler indicates support for this feature with __cpp_static_call_operator.

Upvotes: 0

Johannes Schaub - litb
Johannes Schaub - litb

Reputation: 507225

If you are looking for metaprogramming using the built-in operator: Such a thing isn't possible - the built-in operators operate on runtime values, not on compile time values.

You may use boost::mpl for that, and instead of using the built-in operators, use its templates, like at for op[], plus<a, b> for op+ etc. 

int main() {
    using boost::mpl::vector;
    using boost::mpl::at_c;
    using boost::mpl::plus;
    using boost::mpl::int_;

    typedef vector<int, bool, char, float> Class_1;
    typedef vector< int_<1>, int_<2> > Numeric_1;

    at_c<Class_1, 0>::type six = 6;
    typedef plus<at_c<Numeric_1, 0>::type 
                ,at_c<Numeric_1, 1>::type>::type r;
    int i3[r::value] = { 4, 5, 6 };
    return ((i3[0] + i3[1] + i3[2]) * six) == 90;
}

Upvotes: 14

moonshadow
moonshadow

Reputation: 89135

No, operators cannot be static members of a class. Use a regular static function instead.

Upvotes: 1

Samir Talwar
Samir Talwar

Reputation: 14330

I don't believe it's possible, though I could be wrong on this front. I'd like to ask why you'd want to do this though. Rather than performing operations on a class instead of instances, perhaps you just require one instance throughout your application? In this case, you should probably be using the singleton pattern.

Upvotes: 5

Khaled Alshaya
Khaled Alshaya

Reputation: 96889

If you mean the operator operates on a class, the No. That does not make sense, it is like saying operator + may operator on int or double. Operators are syntactic sugar for functions and they operate on varibles(values) not types.

Upvotes: 3

Related Questions