Question

用几句话说我的问题是我有两个不同的单个类方法，我希望有一个第三个方法可以指向我的第一个或第二个方法。简化的代码如下所示：

typedef void(*func)(void);  // The type isn't good I believe

class Foo
{
  private:
  void f1(void){return;}
  void f2(void){return;}


  public:
  Foo();
  ~Foo();
  void& f(void); // what should be the returned type here ? func& ? void& ? 

  void associate_f(int a)
  {
    if (a==1)
      f = f1; // or anything like that
    else
      f = f2;
  }
};

int main()
{
  Foo * foo = new Foo();
  foo->associate_f(1);
  return 0;
}

如果有其他方法可以做同样的伎俩，我想知道它们！

Answer 1

对于这种情况，我宁愿对Template Method Pattern使用虚拟多态性：

class FooBase
{
  protected:
  virtual void inner() = 0;

  public:
  Foo();
  ~Foo();
  void f(void) {
      inner();
  } 
};

class Foo1 : public FooBase {
    void inner() {}
}

class Foo2 : public FooBase {
    void inner() {}
}

int main()
{
  Foo * foo1 = new Foo1();
  foo1->f();
  Foo * foo2 = new Foo2();
  foo2->f();
  return 0;
}

Answer 2

您正在尝试存储指向成员函数的指针，因此您需要使用pointers to member functions。

class Foo
{
public:
    typedef void(Foo::*func_ptr)(void);

private:
    void f1(void) { return; }
    void f2(void) { return; }

    func_ptr f_ptr;

public:
    void f(void) {
        (this->*f_ptr)();
    }

    void associate_f(int a)
    {
        if (a == 1)
            f_ptr = &f1;
        else
            f_ptr = &f2;
    }

};

int main()
{
    Foo foo;
    foo.associate_f(1);
    foo.f();    // Calls f1()
    return 0;
}

上一个示例将让f()调用相关的函数。如果您尝试返回指向它的指针，最简单的方法是使用std::function将this与成员函数捆绑在一起。

示例：

#include <functional>

class Foo
{
private:
    void f1(void) { return; }
    void f2(void) { return; }


public:
    std::function<void()> f(void) {
        return f_ptr;
    }

    void associate_f(int a)
    {
        if (a == 1)
            f_ptr = [this]() {f1();};
        else
            f_ptr = [this]() {f2();};
    }

private:
    std::function<void()> f_ptr;
};

int main()
{
    Foo foo;
    foo.associate_f(1);
    foo.f();    // Returns a "reference" to f1();
    return 0;
}

Answer 3

直到他为自己的问题辩护，才会直接忽略OP。就像，也许他有一些理由想要搞乱函数指针等等，但他没有描述过。

struct Foo {
    void f() {
        switch(selector) {
        case 1: f1(); break;
        default: f2(); break;
        }
    }

    void associate_f(int selector_) {
        selector = selector_;
    }

private:
    void f1() {}
    void f2() {}

    int selector;
}

Answer 4

使用下面的typedef无法正常工作。

typedef void(*func)(void);

它将func定义为一种不带任何内容并返回void的函数。你需要的是一个成员函数指针的类型。

class Foo
{
   private:

      using function_ptr = void (Foo::*)(void);

      function_ptr f;

   ...

};

此处发布的代码已更新为使用成员函数指针。

class Foo
{
   private:

      using function_ptr = void (Foo::*)(void);

      void f1(void){return;}
      void f2(void){return;}

   public:

      Foo() {}
      ~Foo() {}
      function_ptr f;

      void associate_f(int a)
      {
         if (a==1)
            f = &Foo::f1;
         else
            f = &Foo::f2;
      }
};

int main()
{
  Foo * foo = new Foo();
  foo->associate_f(1);
  return 0;
}

您可以在http://en.cppreference.com/w/cpp/language/pointer获取有关指向成员变量和成员函数的指针的更多详细信息。

如何在C ++中创建指向（或引用）同一类的另一个成员函数的成员函数

4 个答案: