Question

嗯我正在阅读一些这方面的指南，但我无法弄清楚这一点，我如何在C ++中正确使用函数指针？

我有一个类，我想在完成它现在正在做的任何事情之后调用它，如下所示：

class WindowImages
{
    public:
        void Update()
        {
            for(unsigned int i = 0; i < _images.size(); i++)
            {
                //Do something
                _images[i]->MyFunctionPointer();
            }
        }
        void Add(Image* image, void (*func)(void))
        {
            image->function = func; //this is wrong
            _images.push_back(image);
        }         

    private:
        vector<Image*> _images;
}

class Image
{
    public:
        void ImageClicked();

        void *function(void);
};

void main()
{
    Image* image = new Image();

    WindowImages images;
    images.Add(image, image->ImageClicked);
}

我正在尝试将图像添加到矢量中，并传递一个函数作为参数，当图像类完成对每个图像执行的任何操作时将调用该函数。每个图像的功能不同，但它们都是 void function（）格式。

我一直在尝试一堆东西，但到目前为止什么都没有，我怎么能这样做？另外，如果你碰巧有一个更...初学者友好的教程或函数指针指南（甚至可能是C ++ 11 lambdas），那真的很有帮助！

Answer 1

您没有使用常规函数指针进行回调。您正在使用非静态成员函数指针，因此常规函数指针语法和调用机制不起作用。指针声明语法和用于调用非静态成员的机制之间存在显着差异。

要为Image类的成员声明一个指向成员的函数，该成员不带参数并返回void，语法将为：

void (Image::*function)().

使用对象指针时，使用两个特殊运算符->*之一调用成员函数，或者在使用对象引用时使用.*。例如：

// declare a pointer to Image member function
void (Image::*function)();

// assign address of member function
function = &Image::ImageClicked;

// uses ->* for access
Image *pObj = new Image();
(pObj->*function)();

// uses .* for access
Image image;
(image.*function)();

希望有所帮助

Answer 2

首先，我认为你的意图最好通过C ++多态来完成，尽管这是由function pointer发动机完成的。 C++ function pointer教程以下代码执行您要执行的操作。

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
void f1() {
    cout << "f1()" << endl;
}
void f2() {
    cout << "f2()" << endl;
}
void f3() {
    cout << "f3()" << endl;
}    
class A {
public:
    void (*fp)();
};

class B {
public:
    void add(A* a, void (*fp)()) {
        a->fp = fp;
        vec_a.push_back(a);
    }
    ~B() {
        for (int i = 0; i < vec_a.size(); ++i) {
            vec_a[i]->fp();
        }
    }
private:
    vector<A*> vec_a;
};

int main() {
    B *b = new B();
    A* a[3];
    a[0] = new A();
    a[1] = new A();
    a[2] = new A();
    b->add(a[0], f1);
    b->add(a[1], f2);
    b->add(a[2], f3);
    delete b;
}

输出

f1()
f2()
f3()

Answer 3

首先，我建议不要在C ++中使用函数指针。通常，使用虚拟类可以并且应该实现相同的功能。

使用函数指针时，我发现typedef对于保持组织有用非常有用。这个有点人为的例子大致完成了你想要做的事情......

#include <stdio.h>
#include <vector>

typedef void (*fptr_type) (int);

void printSquare (int i) {
   printf ("%d\n", i * i);
   return;
}

void printDouble (int i) {
   printf ("%d\n", 2 * i);
   return;
}

class IntFPtrClass {
   public:
      int intVal;
      fptr_type fptr;

      IntFPtrClass (int i, fptr_type f) : intVal(i), fptr(f) { }

   // Just to show that static methods can be used as function pointers.
   static void printPlusOne(int i) {
      printf ("%d\n", i + 1);
      return;
   }
};

int main (void)
{
   std::vector<IntFPtrClass> my_vector;

   my_vector.push_back (IntFPtrClass(3, printSquare));
   my_vector.push_back (IntFPtrClass(5, printDouble));
   my_vector.push_back (IntFPtrClass(7, IntFPtrClass::printPlusOne));

   for (int i = 0; i < my_vector.size(); ++i)
   {
      my_vector[i].fptr(my_vector[i].intVal);
   }

   return 0;
}

C ++函数指针作为参数和类？

3 个答案: