Ошибка ожидаемого неквалифицированного идентификатора перед токеном '=' при назначении указателя функции на адрес другой функции

Это объявление typedef

typedef void (* provideService_proxy )(std::string product);

объявляет имя provideService_proxy как псевдоним для типа void ( * )( std::string ). Он не объявляет никаких объектов типа указателя.

Таким образом, используя это имя typedef в качестве объекта в операторе выражения

provideService_proxy = init_RealService (product);

выдает ошибку.

Обратите внимание, что вам нужно объявить указатель на функцию-член, а не на отдельную функцию.

В моей программе есть несколько ошибок:

Во-первых, я запутался и забыл объявить указатель на функцию-член:

void (* provideService_proxy )(std::string product) = nullptr;

Вместо этого у меня был только тип данных указателя функции по этой строке:

typedef void (* provideService_proxy )(std::string product)

Во-вторых, чтобы присвоить адрес RealShop::provideService(string) указателю на функцию, мне нужен более простой и явно определенный указатель на функцию как:

void (RealShop::* provideService_proxy )(std::string) = nullptr ;

Чтобы сохранить адрес RealShop::provideService(string), я должен сделать следующее:

realShop_ = new RealShop();
provideService_proxy = &RealShop::provideService;          
(realShop_->*provideService_proxy)(product);

Чтобы вызвать RealShop::provideService(string) через указатель функции, мне нужно сделать:

(realShop_->*provideService_proxy)(product);

Это моя последняя программа:

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

// needed preprocessor to prevend 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(){
        cout<<"RealShop constructor"<<endl;
    };
    virtual ~RealShop(){
        cout<<"RealShop destructor"<<endl;
    };
    virtual void provideService(std::string product) override{
       cout<<"    shop is building "<<product<<endl;
    } ;
};

class ShopProxy : public IShop {
    public:
    ShopProxy(){
        cout<<"**ShopProxy constructor**"<<endl;

    };
    virtual ~ShopProxy(){ 
        cout<<"**ShopProxy destructor**"<<endl;
        delete realShop_;
    };
    virtual void provideService(std::string product) override {
        if ( realShop_ == nullptr  ) {                  
                
            //create RealShop, call RealShop to do service
            // provideService_proxy = (void (*)(std::string))init_RealService (product);            
            init_RealService (product);
        } 
        else{
            std::cout<<"Proxy can provide service"<<std::endl;
            // RealShop is available in Proxy's memory.
            // don't have to request another function call, and add to stack
            // save stack memory by using function pointer. 
            (realShop_->*provideService_proxy)(product);                 
        }
    };
    
    private:
    // typedef void (* functPtr )(std::string product);
    // void (* provideService_proxy )(std::string product) = nullptr;
    void (RealShop::* provideService_proxy )(std::string) = nullptr ;
    void init_RealService ( std::string product ){
        std::cout<<"Proxy creates RealShop on request"<<std::endl; 
        realShop_ = new RealShop();
        std::cout<<"init_RealService saves realShop_->provideService to function pointer"<<endl; 
        provideService_proxy = &RealShop::provideService;          
        (realShop_->*provideService_proxy)(product);
    };

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

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

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

    // create new proxy
    std::string requestProduct3 = "REQUEST 3: a fan";
    IShop * myShopProxy2 = new ShopProxy();
    // myShopProxy has to create new RealShop again and reload data.
    myShopProxy2->provideService(requestProduct3);

    delete myShopProxy2;
}

Спасибо @Vlad From Moscow за помощь!