Question

无法在此找到任何资源。

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) {}
}

现在我有：

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

但这失败了，所以我想知道正确的方法。

Answer 1

最简单，最易读的解决方案就是使用lambda。以下是一个完整的例子：

#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); });
}

如果您坚持要显式绑定运算符，或者只想查看该语法是什么样的，请使用此代码：对于启用GCC和优化的情况，这会产生完全与上面的lambda版本相同的汇编输出：

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

Answer 2

你在C ++中尝试的是不可能的。你可以插入一个抽象层（调用一个调用操作符的函数），但有人打败了我的选择。因此，让我们看看Alpha知道如何基于Beta来构建自己。

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

现在，您可以use std::vector::insert从Alpha构建Beta。

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

带有测试的完整代码：

#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;
    }
}

请注意，虽然更简单，但这可能不是一个可行的选择。 Alpha可能不知道Beta的存在。

C ++将运算符作为参数传递

2 个答案: