C++ 转换方法签名

typedef void（uu thiscall*LPVOIDPROC）（void）

如何消除此错误C2440:“类型强制转换”：无法从“void（\u thiscall ClassB:：*）（void）”转换为“LPVOIDPROC”？我不想将LPVOIDPROC签名限制为仅限于ClassB。这应该是任何类，引用的过程不应该是静态的。

我建议您参考这个。您的类型

LPVOIDPROC

是指向函数的指针，它与指向成员函数的指针不同。当您尝试强制转换

ClassB:：Proc

时，您试图将指针转换为成员函数，这是一个无效的操作

您应该看看

boost:：function

，它提供的正是您想要的。如果你不想求助于boost，你也可以使用functor来封装你的函数。例如：

struct VoidProcFunctor {
    virtual void call() = 0;
};

class ClassB;
struct BProcFunctor : VoidProcFunctor {
    BProcFunctor(ClassB* b) : b_(b) {}
    void call();
private:
    ClassB* b_;        
}

class ClassA
{
public:
    VoidProcFunctor* m_pProc;

    void SetProc(VoidProcFunctor* pProc)  { m_pProc = pProc; }

    void OnSomeEvent() { m_pProc->call(); }
};

class ClassB
{
    ClassA* pCA;

    void Proc() { /* ... */ }

    void Init()
    {
        // Assume pCA != NULL
        // warning! this is not the best design possible
        BProcFunctor* bproc = new BProcFunctor(this);
        pCA->SetProc(bproc);
    }
};

void BProcFunctor::call() { b_->proc() }

---

非静态方法需要一个“this”指针，没有“this”指针就不能调用它，因此将它转换为C函数指针是没有意义的

考虑创建一个具有

• 引用ClassB实例的数据成员
• 一个（）操作符（尽管我更喜欢使用清晰名称的方法）使用ClassB实例作为指针调用ClassB:：Proc

不要将函数指针传递给类a，而是创建一个X的实例（其datamember已填入ClassB）并将其传递给类a。 类a应该调用x（），而不是调用函数指针

类X甚至可以使用模板来编写，因此，如果有多个类出现这种情况，则只能编写一次

我认为在C#中，可以使用委托更干净地完成，但我将此留给C#和.Net专家。

解决方法：

typedef void (* CLASSPROC) (void *); 

template<class T, void (T::*proc)()>
void class_proc(void * ptr) 
{
 (static_cast<T*>(ptr)->*proc)();
}

class ClassA 
{ 
 CLASSPROC m_pProc;
 void    * m_pInstance;

public:
 void SetProc(void *pInstance, CLASSPROC pProc)  { 
          m_pInstance = pInstance; 
          m_pProc = pProc; 
     } 

 void OnSomeEvent() { m_pProc(m_pInstance); } 
};

class ClassB 
{ 
 ClassA* pCA; 

 void Proc() { /* ... */ } 

 void Init() 
 { 
  // Assume pCA != NULL 
  pCA->SetProc(this, class_proc<ClassB, &ClassB::Proc>);      
 } 
};

typedef void（*CLASSPROC）（void*）；
模板
无效等级程序（无效*ptr）
{
（静态铸造（ptr）->*proc）（）；
}
甲级
{ 
CLASSPROC m_pProc；
void*m_pInstance；
公众：
void SetProc（void*pInstance，CLASSPROC-pProc）{
m_pInstance=pInstance；
m_pProc=pProc；
} 
void OnSomeEvent（）{m_pProc（m_pInstance）；}
};
B类
{ 
A类*pCA；
void Proc（）{/*…*/}
void Init（）
{ 
//假设pCA！=NULL
pCA->SetProc（该类程序）；
} 
};

您需要将

Proc

方法作为静态方法

永远不要强制转换函数指针。最终可能导致堆栈损坏。不要这样做

不要向非静态成员函数传递指针。它们使用不同的呼叫约定，不兼容

在您的情况下，使“Proc（）”为静态可能会解决问题

---

Uf方法不是静态的-如何将类实例传递到ClassA？OP说这应该是任何类，引用的过程不应该是静态的。

typedef void (* CLASSPROC) (void *); 

template<class T, void (T::*proc)()>
void class_proc(void * ptr) 
{
 (static_cast<T*>(ptr)->*proc)();
}

class ClassA 
{ 
 CLASSPROC m_pProc;
 void    * m_pInstance;

public:
 void SetProc(void *pInstance, CLASSPROC pProc)  { 
          m_pInstance = pInstance; 
          m_pProc = pProc; 
     } 

 void OnSomeEvent() { m_pProc(m_pInstance); } 
};

class ClassB 
{ 
 ClassA* pCA; 

 void Proc() { /* ... */ } 

 void Init() 
 { 
  // Assume pCA != NULL 
  pCA->SetProc(this, class_proc<ClassB, &ClassB::Proc>);      
 } 
};