C++中类成员函数相互调用有啥好处？

Posted 2023-02-16

技术标签:

【中文标题】C++中类成员函数相互调用有啥好处？【英文标题】：What is the advantage of class member functions to call each other in C++?C++中类成员函数相互调用有什么好处？ 【发布时间】：2017-05-10 06:23:06 【问题描述】：

我是 C++ 新手。我发现下面的编程风格对我来说很有趣。我在这里写了一个简化版。

#include <iostream>
using namespace std;
class MyClass 
    public :
        MyClass(int id_) : id(id_) 
            cout<<"I am a constructor"<<endl;
        
        bool error = false;
        void run() 
            //do something ...
            if (!error) 
                read();
            
        
        void read() 
            //do something ...
            if (!error) 
                write();
            
        
        void write() 
            //do something ...
            if (!error) 
                read();
            
        
    private :
        int id;
;
int main() 
    MyClass mc(1);  
    mc.run();
    return 0;

这里的例子是可编译的，但我没有运行它，因为我必须进入一个无限循环。但是，我希望以此作为参考。 read() 和 write() 互相调用。我第一次遇到这种编程风格是在boost.asio。当服务器在 do_read() 中收到一条消息时，它调用 do_write() 来回显客户端，然后在 do_write() 结束时再次调用 do_read()。

关于这种类型的编码，我有两个问题。

这会导致堆栈溢出吗？因为函数一直在调用自己并且函数结束只会发生错误。

它有什么好处？为什么我不能用一个函数让它们有序循环，遇到错误就中断循环。

bool replied = true;

while (!error) 

    if (replied) read();

    else 

        write();

        replied = !replied;

【问题讨论】：

如果你在做正确的尾调用，编译器应该优化它们以防止调用堆栈溢出。如何定义“正确”？表示控制权不必返回给调用者，即return f(x);是尾调用，int y = f(x); return y;不是。 【参考方案1】：

您的简化版本忽略了最重要的方面：write() 和 read() 调用是异步的。

因此，函数实际上不会导致递归，请参阅最近的答案：Do "C++ boost::asio Recursive timer callback" accumulate callstack?

async_read(...) 和async_write(...) 的“不寻常”之处在于函数在实际执行 IO 操作之前返回，更不用说完成了。实际执行是按不同的时间表完成的¹。

为了向“调用者”返回完成信号，异步调用通常采用一个完成处理程序，该处理程序被调用，并带有 IO 操作的结果。

在该完成处理程序中，通常会看到通信通道的结束或正在安排的下一个 IO 操作。这被称为异步调用链，并且在许多支持异步操作的语言中非常突出²

这需要一些时间来适应，但最终你会习惯这种模式。

考虑到这一点，重新审视其中一个提升样本，看看硬币是否下降：

Documentation sample Chat Client

  void handle_connect(const boost::system::error_code& error)
  
    if (!error)
    
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
          boost::bind(&chat_client::handle_read_header, this,
            boost::asio::placeholders::error));
    
  

  void handle_read_header(const boost::system::error_code& error)
  
    if (!error && read_msg_.decode_header())
    
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
          boost::bind(&chat_client::handle_read_body, this,
            boost::asio::placeholders::error));
    
    else
    
      do_close();
    
  

  void handle_read_body(const boost::system::error_code& error)
  
    if (!error)
    
      std::cout.write(read_msg_.body(), read_msg_.body_length());
      std::cout << "\n";
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
          boost::bind(&chat_client::handle_read_header, this,
            boost::asio::placeholders::error));
    
    else
    
      do_close();
    
  

  void do_write(chat_message msg)
  
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    if (!write_in_progress)
    
      boost::asio::async_write(socket_,
          boost::asio::buffer(write_msgs_.front().data(),
            write_msgs_.front().length()),
          boost::bind(&chat_client::handle_write, this,
            boost::asio::placeholders::error));
    
  

  void handle_write(const boost::system::error_code& error)
  
    if (!error)
    
      write_msgs_.pop_front();
      if (!write_msgs_.empty())
      
        boost::asio::async_write(socket_,
            boost::asio::buffer(write_msgs_.front().data(),
              write_msgs_.front().length()),
            boost::bind(&chat_client::handle_write, this,
              boost::asio::placeholders::error));
      
    
    else
    
      do_close();
    
  

  void do_close()
  
    socket_.close();