C++ Passing Operator as Parameter

Question

Having trouble finding any resources on this.

struct Beta {
    int foo;
    int bar;
    Beta(int aFoo, int aBar) : foo(aFoo), bar(aBar) {}

    operator Alpha() const { return Alpha(foo, bar); }
}
struct Alpha {
    float foo;
    float bar;
    Alpha(float aFoo, float aBar) : foo(aFoo), bar(aBar) {}
}

And now I have:

vector<Beta> betas;
vector<Alpha> alphas;
transform(beta.begin(), beta.end(), back_inserter(alphas), &Beta.operator Alpha());

But this fails so I'm wondering the proper way to do it.

Please confirm goal: Copy `betas` to `alphas`? Nothing fancy? — user4581301, Jun 15 '17 at 23:39
While what OP tried to do, I think, is impossible, I believe what they want to do is worth unlocking and answering... If they clean up the question. — user4581301, Jun 15 '17 at 23:44

score 1 · Accepted Answer · answered Jun 16 '17 at 00:50

The easiest and most readable solution is just to use a lambda. Below is a complete example:

#include <algorithm>

struct Alpha {
    float foo;
    float bar;
    Alpha(float aFoo, float aBar) : foo(aFoo), bar(aBar) {}
};

struct Beta {
    int foo;
    int bar;
    Beta(int aFoo, int aBar) : foo(aFoo), bar(aBar) {}

    operator Alpha() const { return Alpha(foo, bar); }
};

int main() {
    std::vector<Beta> betas;
    std::vector<Alpha> alphas;
    std::transform(betas.begin(), betas.end(), back_inserter(alphas), [](Beta b) { return Alpha(b); });
}

If you insist that you want to explicitly bind the operator instead, or just want to see what that syntax looks like, use this instead: For me with GCC and optimizations turned on, this yields exactly the same assembly output as the lambda version above:

using namespace std::placeholders; // For _1
std::transform(betas.begin(), betas.end(), back_inserter(alphas), std::bind(&Beta::operator Alpha, _1));

Thanks I knew the first one and kinda was just wondering what the syntax looked like. Thanks so much for the great answer. — Patrick Metcalfe, Jul 07 '17 at 18:41

user4581301 · Answer 2 · 2017-06-16T01:00:05.883

What you tried is not possible in C++. You can insert a layer of abstraction (Call a function that calls the operator), but someone's beaten me to that option. So let's look at Alpha knowing how to construct itself based on Beta instead.

struct Alpha
{
    ...
    // construct an Alpha from a Beta
    Alpha(const Beta& source) :
            foo(source.foo), bar(source.bar)
    {
    }
};

Now you can use std::vector::insert to construct Alphas from Betas.

alphas.insert(alphas.begin(), betas.begin(), betas.end());

Full code with test:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Beta
{
    int foo;
    int bar;
    Beta(int aFoo, int aBar) :
            foo(aFoo), bar(aBar)
    {
    }
};

struct Alpha
{
    float foo;
    float bar;
    Alpha(float aFoo, float aBar) :
            foo(aFoo), bar(aBar)
    {
    }
    Alpha(const Beta& source) :
            foo(source.foo), bar(source.bar)
    {
    }

};

int main()
{
    vector<Beta> betas
    {
      { 1, 1 },
      { 2, 2 },
      { 3, 3 } 
    };

    vector<Alpha> alphas;
    alphas.insert(alphas.begin(), betas.begin(), betas.end());
    for (const Alpha & a : alphas)
    {
        std::cout << a.foo << ',' << a.bar << std::endl;
    }
}

Note that while simpler, this might not be a viable option. Alpha may not know of the existence of Beta.

C++ Passing Operator as Parameter

2 Answers2