使用模板指向非静态成员函数的c++指针

C++ Pointer to Non-static Member Function Using Templates

本文关键字：函数 静态成员 c++ 指针      更新时间：2023-10-16

我有麻烦让成员函数指针工作(我不知道我想做什么是可能的)。我想设置一个成员变量(它是指向另一个类中的非静态函数的指针)，然后调用该函数。然后，我希望能够将其设置为另一个派生类中的另一个成员函数并调用它。这两个派生类是由模板创建的，如下所示。我能做到这一点吗?如果可以，我做错了什么?

// Forward declare these, their implementation is irrelevant to the question 
class A;
class B;
// declare a base class that contains a function log() that we want to call
class BaseClass {
   public:
      BaseClass() {}
      virtual ~BaseClass() {}
      virtual void log() {}  // want to call this via function pointers
};
//Using a template means we don't have to specify the type in the vector  
template<class T>
class TemplateVectorOfBaseClass : public BaseClass {
   protected:
      std::vector<T> peripherals;      
}
//  this specific implementation does stuff using Class A
template <int randomTemplateParameter>
class DerivedTemplateClassThatDoesStuffWithAs : public BaseClass
    public:
       DerivedTemplateClassThatDoesStuffWithAs() : TemplateVectorOfBaseClass<A>() {}
       void log() {do_something_here_involving_As();}
       int i[randomTemplateParameter];
};
//  this specific implementation does stuff using Class B
template <int randomTemplateParameter>
class DerivedTemplateClassThatDoesStuffWithBs : public BaseClass
    public:
       DerivedTemplateClassThatDoesStuffWithBs() : TemplateVectorOfBaseClass<B>() {}
       void log() {do_something_here_involving_Bs();}
       float f[randomTemplateParameter];  
};
// Class that contains both templates as member variables    
class ContainerClass {
   public:
      ContainerClass();
      DerivedTemplateClassThatDoesStuffWithAs dtca<5>;
      DerivedTemplateClassThatDoesStuffWithBs dtcb<10>;
      void (BaseClass::*log)();  // pointer to member function log()
    }
// usage
ContainerClass cc;
cc.container.log = &dtca.log;
cc.*log(); // should call vectorContainingAs.log()
cc.container.log = &dtcb.log;
cc.*log(); // should call vectorContainingBs.log()

我真的不能依赖你的代码，因为它充满了错误，所以这里是它应该如何工作的简化版本:

class A { } ;
class B { } ;    
class BaseClass {
public:
    virtual void log () {
        std::cout << "Log BaseClass." << std::endl ;
    }
};
template <class T>
class TVector : public BaseClass { } ;
template <int N>
class DTCA : public TVector <A> { 
public:
    virtual void log () { 
        std::cout << "Log DTCA." << std::endl ;
    }
} ;
template <int N>
class DTCB : public TVector <B> { 
public:
    virtual void log () {
        std::cout << "Log DTCB." << std::endl ;
    }
} ;
class Container {
public:
    DTCA <5> dtca ;
    DTDB <10> dtcb ;
    void (BaseClass::*log) () ;
} ;

我认为前一部分的错误是由于错误的复制/粘贴。你主要错误的地方是将方法赋值给指针的方式，以及在对象上调用方法的方式:

int main () {
    Container cc ;
    cc.log = &BaseClass::log ; // Store the log member function into cc.log
    (cc.dtca.*cc.log) () ; // Call it on dtca
    (cc.dtcb.*cc.log) () ; // Call it on dtcb
    return 0 ;
}
输出:

日志DTCA

。

日志DTCB

。

你不能从实例中获取方法的地址，你会得到这样的结果:

ISO c++禁止将绑定成员函数的地址作为指向成员函数的指针。

所以你把地址给方法，因为你的变量的类型是(BaseClass::*)()，你需要直接从BaseClass中获取它。然后，您需要使用BaseClass的实例或派生类来调用它。

相关文章：