在将成员函数作为函数变量传递时无效使用非静态成员函数 C++

Question

我知道有人问过类似的问题，但我不能指责我的问题。我有一个 class 具有以下方法（它用于多线程编程）：

  void ServerUtil::WaitForRequst(void (*ProcessRequest)(shared_ptr<TCP> tcp), shared_ptr<struct sockaddr_in> serv_addr){


 TCPPort tcp_port(serv_addr, true);
 struct sockaddr_in client_addr; //FIXME: add these to a vector so their is a way to track clients


 int i = 0;
 while(i < m_thread_max){
     std::shared_ptr<TCP> tcp = std::make_shared<TCP>(serv_addr, &client_addr, tcp_port, true);
     std::shared_ptr<std::thread> t = std::make_shared<std::thread>(std::bind(ProcessRequest, tcp));;
     m_vector_threads.push_back(t);
     i++;
 }


 for(int j = 0; j < m_vector_threads.size();j++)
     m_vector_threads.at(j)->join();
    }

}

现在我已经用以下 .h 文件创建了一个服务器 class：

class服务器{ public:

Server(shared_ptr<ServerUtil> serv_util, shared_ptr<struct sockaddr_in> serv_addr);
virtual void ProcessCommand(char &command) = 0;
//ProcessRequest is the primary thread(client) handler
virtual void ProcessRequest(shared_ptr<TCP> tcp) = 0;
bool SendAck(shared_ptr<TCP> tcp);
bool ReceiveAck(shared_ptr<TCP> tcp);
bool CloseConnection(shared_ptr<TCP> tcp);

protected:
shared_ptr<ServerUtil> m_serv_util;
shared_ptr<struct sockaddr_in> m_serv_addr;

};

现在针对相关问题的以下 .cpp 文件：

    Server::Server(shared_ptr<ServerUtil> serv_util, shared_ptr<struct sockaddr_in> serv_addr){

    m_serv_util = serv_util;
    m_serv_addr = serv_addr;
    m_serv_util->WaitForRequst(ProcessRequest, serv_addr);
}

我收到以下错误：

 error: invalid use of non-static member function
 m_serv_util->WaitForRequst(ProcessRequest, m_serv_addr);

我还尝试注释掉基础 class 中的构造函数，并在派生的 class 中执行此操作（覆盖纯虚函数）。有什么想法吗？

Answer 1

在

void ServerUtil::WaitForRequst(void (*ProcessRequest)(shared_ptr<TCP> tcp), 
                               shared_ptr<struct sockaddr_in> serv_addr)

void (*ProcessRequest)(shared_ptr<TCP> tcp) 指定将使用指向与给定 void (shared_ptr<TCP> tcp) 原型匹配的函数的指针调用该函数。

void ProcessRequest(shared_ptr<TCP> tcp)

是Server的成员所以看起来更像

void ProcessRequest(Server * this, shared_ptr<TCP> tcp)

你可以 sort-of 用

清理它

void ServerUtil::WaitForRequst(void (Server::*ProcessRequest)(shared_ptr<TCP> tcp), 
                               shared_ptr<struct sockaddr_in> serv_addr)

让WaitForRequst（旁白：你打错了，以后可能会咬你）知道它将获得Server的方法。但...！您还必须为 this 传递一个对象实例，因此

void ServerUtil::WaitForRequst(void (Server::*ProcessRequest)(shared_ptr<TCP> tcp), 
                               Server * instance,
                               shared_ptr<struct sockaddr_in> serv_addr)

并且这个实例需要通过

之类的东西传递给线程

std::shared_ptr<std::thread> t = std::make_shared<std::thread>(std::bind(ProcessRequest, 
                                                                    instance, 
                                                                    tcp));

std::thread会帮你解决调用方法指针的繁琐，但如果你有兴趣，这里有一个关于方法指针的考验和磨难的大长篇讨论：Pointers to Member Functions.

不幸的是，你在那里做的事情我认为值得另一个问题。你不想要那些 shared_ptrs。没有人共享指针，因此 std::unique_ptr 或根本没有指针应该是 go-to。这里没有任何指针看起来是好的，除了 instance 可能的例外（如果实例的范围不可靠或比线程短，请考虑 re-design）。

这意味着

void ProcessRequest(TCP tcp)

必须的

void ServerUtil::WaitForRequst(void (Server::*ProcessRequest)(TCP tcp), 
                               Server * instance,
                               shared_ptr<struct sockaddr_in> serv_addr)

和

 m_vector_threads.emplace_back(ProcessRequest, 
                               instance, 
                               TCP(serv_addr, 
                                   &client_addr, 
                                   tcp_port, 
                                   true));

可能就足够了，这取决于 well-written TCP 的情况。传递所有参数并让 ProcessRequest 将 TCP 实例构造为局部变量可能会更好。如果那里有一个小的语法错误，请原谅我。好像我没有足够的能力来测试所有这些。不过，请随意踢我的屁股来解决主要的语法错误。

在将成员函数作为函数变量传递时无效使用非静态成员函数 C++

invalid use of non-static member function C++ while passing member-function as a function variable

c++

inheritance

multithreading

member-functions

pure-virtual