Question

我有一个类，我需要一个可以为每个对象定义的函数。我希望能够在定义所述对象的向量时定义每个对象的特定功能。我的对象的这些向量将构成库的一部分。这是我尝试做的一个不成功的例子：

#include <iostream>
#include <vector>

class FunctionEater {

public:

    virtual double func() {}

    FunctionEater(double (*Func)) {

        func = Func;    // Not sure of the correct syntax here
    }
};

std::vector<FunctionEater> gorgers {

    {
        double () {    // Not sure of the syntax here, or if there is even syntax to do this

            double result = 0.794 * 739.775;
            return result;
        }
    },

    {
        double () {

            double temp1 = 0.794 * 739.775;
            double result = temp1 + 0.62;
            return result;
        }
    }
}

int main()
{
    double snackCrumbs = gorgers[0].func();
    double gorgePoop = gorgers[1].func();

    std::cout << snackCrumbs << std::endl << gorgePoop << std::endl;
}

因此，我努力弄清楚或找到大量文档的两件事情如下：

如何在定义gorgers []
如何接受我作为（* Func）传递给构造函数的函数，并将其存储为virtual double func（）

我希望能够在对象定义中定义函数。我花了很多时间研究如何最好地编写对象向量，并且在这种情况下最容易使用的方式似乎是在一个块中定义每个对象的每个方面，同时定义它们包含在载体中。

我承认，在使用虚函数时我也不知道（* Func）是否正确，但这是我第一次使用函数指针时的改编。我也很乐意接受可能比我尝试使用的方法更好的替代建议。

提前感谢您提供的任何帮助，如有必要，我很乐意编辑或更新我的问题。

皮特

Answer 1

您想要的是您的语言提供更好的功能支持。幸运的是，你正在使用c ++！

在c ++ 11之后，我们有lambda和std::function个对象，它们代表运行时多态函数对象。

lambda的定义如下：

auto yourSecondFunc = [](){
        double temp1 = 0.794 * 739.775;
        double result = temp1 + 0.62;
        return result; 
};

我一直懒惰并在那里使用自动，但实际上，我们可以将它分配给std::function对象：

std::function<double()> yourSecondFunc = [](){
        double temp1 = 0.794 * 739.775;
        double result = temp1 + 0.62;
        return result; 
};

std::function<double()>表示该函数不带参数并返回double。但请注意，lambda的类型不是std::function对象，但它不是讨论它的地方。

因此，您可以在std::function<double()>课程中存储FunctionEater：

class FunctionEater {

public:

    std::function<double()> func;

    FunctionEater(const std::function<double()>& f) {

        func = f;
    }

    void callMe() { double res = func(); } // how a function object is used
};

然后，你的矢量变为：

std::vector<FunctionEater> gorgers {
    FunctionEater { []() 
      {
        double result = 0.794 * 739.775;
        return result;
      }
    },
    FunctionEater { []() 
      {
        double temp1 = 0.794 * 739.775;
        double result = temp1 + 0.62;
        return result;
      }
    }
};

你的main？它实际上是一样的：

int main()
{
    double snackCrumbs = gorgers[0].func();
    double gorgePoop = gorgers[1].func();

    std::cout << snackCrumbs << std::endl << gorgePoop << std::endl;
}

Answer 2

正确的语法是：

#include <iostream>
#include <vector>
#include <functional>

struct FunctionEater
{
    using Func = double (*)();
    //using Func = std::function<double()>;

    template<typename F>
    FunctionEater(F f): func(f) {}

    Func func;
};

std::vector<FunctionEater> const gorgers = {
    []{ return 0.794 * 739.775; },
    []{ return 0.794 * 739.775 + 0.62; }
};

int main()
{
    double snackCrumbs = gorgers[0].func();
    double gorgePoop = gorgers[1].func();

    std::cout << snackCrumbs << std::endl << gorgePoop << std::endl;
}

您可以使用Func的任一定义。函数指针的开销较小，但只能使用无捕获的lambda。 std::function更加灵活。

NB。我不确定为什么在没有FunctionEater的模板构造函数的情况下向量初始化不起作用，但我发现在这种情况下，必须显式转换向量初始化器（要么Func或{{FunctionEater 1}}）。

在构造对象时定义成员函数

2 个答案: