Question

好吧，我的主要是：

void somefunction();
int main()
{
    //bla bla bla
    SomeClass myclass = SomeClass();
    void(*pointerfunc)() = somefunction;
    myclass.addThingy(pointerfunc);

    //then later i do
    myclass.actionWithDiffrentOutcomes();
}

void somefunction()
{
    //some code
}

并在课堂上：

class SomeClass()
{
    public:
        void addThingy(void (*function)());
        void actionWithDiffrentOutcomes();
    private:
        std::vector<void (**)()> vectoroffunctions;
}
SomeClass::addThingy(void (*function)())
{
    vectoroffunctions.push_back(&function);
}
SomeClass::actionWithDiffrentOutcomes()
{
    (*vectoroffunctions[0])();;
}

我对指针有点新意，但我阅读了我的c ++书籍，Google搜索，分机。这似乎是正确的，编译，运行，但当我调用“actionWithDiffrentOutcomes（）”时，我得到访问冲突。我不知道该怎么做。这似乎是正确的，但事情显然是错误的。那么当定义在另一个类中时，如何从类中调用函数？

我这样做是因为我无法将每个选项硬编码到switch语句中。

Answer 1

您的代码几乎是正确的。你的向量错误地指向指向函数的指针，而不是简单地指向函数。 addThingy正在将function指针的地址添加到vector，但该指针超出了下一行的范围。

按如下方式更改您的代码：

//Store pointers to functions, rather than
//pointers to pointers to functions
std::vector<void (*)()> vectoroffunctions;

SomeClass::addThingy(void (*function)())
{
    //Don't take the address of the address:
    vectoroffunctions.push_back(function);
}

此外，您在其余代码中存在大量语法错误，这些错误应该会阻止代码编译。

Answer 2

问题在于：

vectoroffunctions.push_back(&function);

您要添加本地变量的地址。从函数返回后，局部变量将被销毁。向量存储的地址指向被破坏的对象，这就是运行时出现“访问冲突”错误的原因。

要解决此问题，请执行以下操作：

首先改变这个

std::vector<void (**)()> vectoroffunctions;

到此：

std::vector<void (*)()> _functions; //vector of function-pointer-type
                                    //I changed the name also!

实际上与：

相同

std::vector<void()> _functions; //vector of function-type

现在这样做：

_functions.push_back(function); //add copy!

为了使其更灵活，您可以将模板与std::function一起使用为：

class A
{
    public:
        template<typename Function>
        void add(Function && fn) 
        {  
            _functions.push_back(std::forward<Function>(fn)); 
        }
        void invoke_all()
        {
           for(auto && fn : _functions)
                fn();
        }
    private:
        std::vector<std::function<void()>> _functions;
};

现在你可以用它来存储函数和函子：

void myfunction() { std::cout << "myfunction" << std::endl ; }

struct myfunctor
{
       void operator()() { std::cout << "myfunctor" << std::endl ; }
};

A a;
a.add(myfunction);   //add function
a.add(myfunctor());  //add functor!
a.invoke_all();

输出（Online Demo）：

myfunction
myfunctor

希望有所帮助。

Answer 3

使用typedefs时，函数指针更加清晰：

typedef void (*RequiredFunction)();

然后你可以像这样声明addThingy()：

    void addThingy(RequiredFunction function);

并且vectoroffunctions喜欢这样：

    std::vector<RequiredFunction> vectoroffunctions;

addThingy的定义是：

void SomeClass::addThingy(RequiredFunction function)
{
    vectoroffunctions.push_back(function);
}

您的main()看起来更像是：

int main()
{
    SomeClass sc;
    RequiredFunction pointerfunc = somefunction;
    sc.addThingy(pointerfunc);
    sc.actionWithDiffrentOutcomes();
}

犯错误的*和&更少！

C ++从函数定义为main的类中的函数指针向量中调用函数

3 个答案: