C++函数指针赋值报错：expected unqualified-id before '=' token

1. 直接编译错误原因 #

错误行provideService_proxy = init_RealService (product);中，provideService_proxy是你定义的类型别名（typedef的函数指针类型），不是类的成员变量，编译器无法将其识别为可赋值的变量，因此抛出expected unqualified-id before '=' token错误。

2. 深层问题：成员函数指针的误用 #

你试图用普通函数指针指向非静态成员函数，这是错误的——非静态成员函数隐含一个this指针参数，普通函数指针无法容纳这个额外参数，必须使用成员函数指针类型。

修复后的完整代码 #

#include "iostream"
#include "string"
using namespace std;

// needed preprocessor to prevent loop include
#ifndef ISHOP
#define ISHOP
#include "string"

class IShop{
    public:
    IShop(){};
    virtual void provideService(std::string product) = 0;
    virtual ~IShop(){};
};
#endif

class RealShop: public IShop {
    public:
    RealShop(){};
    virtual ~RealShop(){};
    virtual void provideService(std::string product) override{
       cout<<"    shop is building "<<product<<" in warehouse"<<endl;
        if (specialOrder_ == true){
            specialService("Minh");
        }
        collectMaterial(); 
    } ;
    private:
    static const bool specialOrder_ = true;
    void collectMaterial(){
        cout<<"    collect material to build product"<<endl;
    };
    void specialService(std::string customerName){
        std::cout<<"provide custom order to customer "<<customerName<<std::endl;
        customerName_ = customerName;
    };     // newly added
    std::string customerName_;
};

class ShopProxy : public IShop {
    public:
    ShopProxy(){};
    virtual ~ShopProxy(){};
    virtual void provideService(std::string product) override {
        if ( realShop_ == nullptr  ) {                  
            std::cout<<"Proxy creates RealShop on request"<<std::endl;     
            service_func_ = init_RealService(product);
        } 
        else{
            std::cout<<"Proxy can provide service"<<std::endl;
            // 通过对象指针调用成员函数指针
            (realShop_->*service_func_)(product);                     
        }
    };
    
    private:
    // 定义RealShop类的成员函数指针类型
    typedef void (RealShop::*provideService_proxy)(std::string product);
    // 声明成员变量存储函数指针
    provideService_proxy service_func_;

    provideService_proxy init_RealService(std::string product){
        realShop_ = new RealShop();
        // 返回成员函数地址，无需强制转换
        return &RealShop::provideService;
    };

    RealShop * realShop_ = nullptr;    // safe initialization of pointer
};

int main()
{
    std::string requestProduct1 = "a doll";
    IShop * myShopProxy = new ShopProxy();
    // myShopProxy creates RealShop
    myShopProxy->provideService(requestProduct1);
    // myShopProxy already has RealShop, and can provide service.
    std::string requestProduct2 = "a toy";
    myShopProxy->provideService(requestProduct2);

    // delete myShopProxy will delete RealShop and data saved in memory
    delete myShopProxy;

    // create new proxy
    IShop * myShopProxy2 = new ShopProxy();
    // myShopProxy has to create new RealShop again and reload data.
    myShopProxy2->provideService(requestProduct1);

    delete myShopProxy2;
}

关键修复点 #

• 添加成员变量：在ShopProxy类中声明provideService_proxy类型的成员变量service_func_，用于存储成员函数地址，替代直接使用类型名赋值的错误写法。
• 修正函数指针类型：将普通函数指针改为RealShop类的成员函数指针类型typedef void (RealShop::*provideService_proxy)(std::string product);，匹配非静态成员函数的特性。
• 正确调用成员函数指针：使用(realShop_->*service_func_)(product)的语法调用成员函数指针，必须通过对象/对象指针来调用，且括号不可省略。
• 移除不安全的强制转换：成员函数地址可以直接赋值给对应类型的成员函数指针，无需reinterpret_cast，避免未定义行为。

内容的提问来源于stack exchange，提问作者Minh Pham