Is it possible to get the function pointer of a built-in standard operator?

Question

I want to refer to function pointers of built-in operators, but I don't know how to specify the specific type overloads.

I have the following template class signature:

template<typename ParamsType, typename FnCompareType>
class MyAction
{
public:
    MyAction(ParamsType& arg0, ParamsType& arg1, FnCompareType& fnCpmpare) 
    : arg0_(arg0), arg1_(arg1), fnCompare_(fnCpmpare) {}

    bool operator()()
    {
        if((*fnCompare_)(arg0_,arg1_)
        {
            // do this
        }
        else
        {
            // do s.th. else
        }
    }

private:
    ParamsType& arg0_;
    ParamsType& arg1_;
    FnCompareType& fnCompare_;
}

And want to use a syntax like this:

void doConditional(int param1, int param2)
{
    MyAction<int,&::operator>=> action(param1,param2);
    if(action())
    {
        // Do this
    }
    else
    {
        // Do that
    }
}

But that doesn't compile:

error: ‘::operator>=’ has not been declared

What can I do to refer to such intrinsic static operations?

Answer 1

You can use the same solution as used in C++ standard library:

std::sort (numbers, numbers+5, std::greater<int>());

where greater is

template <class T> struct greater : binary_function <T,T,bool> {
    bool operator() (const T& x, const T& y) const {return x>y;}
};

in your case http://www.cplusplus.com/reference/functional/greater_equal/

About reference of built operator.

You can reference existing operator< for any class (of course if they are not private, protected or your class/function not friend). But opeator< for builtin types (bool, short, int, double) it is not possible reference. Event if not look at C++ standard you can see from my text above.

Answer 2

An extension to the solution provided by fghj, that would work for assignment type operators, such as +=/-=, etc would be to wrap these similarly to the standard variants. You could then do:

#include <iostream>

template <typename T>
struct assign_plus {
    void operator() const (T& a, const T& b){
        a += b;
    }
};

template <typename T>
struct assign_minus {
    void operator() const (T& a, const T& b){
        a -= b;
    }
};


template<template <class T> class O> requires requires(int& a, const int& b){
    { O<int>{}(a,b) };
}
void example(int& a, const int& b){
    O<int>{}(a,b);
}

int main(){
    int a = 5;
    int b = 6;
    example<assign_plus>(a,b);
    std::cout << a << "\n";
    example<assign_minus>(a,b);
    std::cout << a << "\n";
    return 0;
}

where the constraint could be kept/removed given c++20 compatibility. These constraints then also could be extended to require that a += b is valid (for custom types for example).