Question

我想重载＆lt;＆lt;链接的运算符如下所示

function1(param1, param2)<< obj2 << obj3 << string4

function1将返回一个对象。

我想要做的是在string4之后，我需要使用param1，param2调用一个函数。

我的问题将是

我怎么知道string4是表达式中的最后一个参数，因此我需要使用param1和param2调用另一个function2，否则就不可能这样做了？
如何将param1和param2传递给要调用的函数？我无法将param1和param2存储在对象中，因为它是多线程的。

感谢。

Answer 1

您可以从function1返回一个辅助对象，该值在其析构函数中调用function2。

考虑这个例子：

#include <iostream>

using namespace std;

void function2( int i, int j ) {
    cout << "function2 called with " << i << " and " << j << endl;
}

struct Function2Caller {
  Function2Caller( int param1, int param2 ) : m_param1( param1 ), m_param2( param2 ) {}
  ~Function2Caller() { function2( m_param1, m_param2 ); }

  int m_param1, m_param2;
};

Function2Caller &operator<<( Function2Caller &obj, int x ) {
    cout << "Streaming " << x << endl;
    return obj;
}

Function2Caller function1( int i, int j ) {
    cout << "function1 called with " << i << " and " << j << endl;
    return Function2Caller( i, j );
}

int main() {
    function1( 2, 3 ) << 4 << 6;
}

此程序打印

function1 called with 2 and 3
Streaming 4
Streaming 6
function2 called with 2 and 3

这个想法是，在你的行的末尾，Function2Caller对象超出范围，然后析构函数就会完成它的工作。

请注意，在实现此功能时，您应该禁止复制Function2Caller对象，并使function1成为唯一可以调用Function2Caller构造函数的人。

Answer 2

正如Frerich Raabe所指出的，一种可能的解决方案是使用临时对象的析构函数。但是，它确实会强制您以某种方式需要内联调用所有参数，从而禁止使用以下语法：

auto stream = function1(param1, param2) << param3;
stream << param4;
stream << stringG; // call here

标准库中的IO Stream库通过将全局对象用作“标记”来解决问题：std::endl。这可能是另一种选择。

请注意，如果您采用标记方式，则可以解除不复制的要求。

最后，设计问题更多的是实施问题，所以这是你的呼唤。

class Stream
{
public:
  struct Marker {};
  static Marker End;

  Stream(type1, type2);

  void operator<<(Marker) const { function2(m1,m2); }
  Stream& operator<<(...);

private:
  type1 m1;
  type2 m2;
};

玩得开心：）

Answer 3

我怎么知道string4是最后一个表达式中的参数因此我需要使用调用函数 param1和param2或者它是不可能的这样做？

function1(param1, param2)<< obj2 << obj3 << string4

不符合您的想法。首先评估function1，结果对象用于以operator<<作为参数调用obj2，依此类推......

如果您想在结束时致电function1，则应在以operator<<作为参数调用string4之后发生。

如何将param1和param2传递给函数被调用？我不能将param1和param2存储在对象，因为它是多线程的。

您的op<<应该返回定义了op()的T类型的对象，以便您可以在最后使用param1和param2。

Answer 4

如果function1返回某些内容（例如int），您应该能够延迟计算，直到使用它的值。。您应该返回一个可以转换为int的对象（通过实现int operator int()作为成员函数）。

在function1的实现中，您构建它。该对象还将实现<<。在执行转换的成员函数中，您将收集的所有值用作参数，并使用<<运算符传入。

Answer 5

你最后以这种方式传递一个仿函数

 class myfun {
 public:
         void operator()(const string& param1, const string& param2, const string& values) const {
                 std::cout << "param1: " << param1 << "param2: " << param2 << " value: " << values << std::endl;
         }
 };

 class A {
         string m_param1, m_param2;
         string values;
 public:
         A(string param1, string param2):m_param1(param1), m_param2(param2) { }

         A& operator << (const string& str) {
                 values += str;
                 return *this;
         }

         A& operator << (const myfun& myfun) {
                 myfun(m_param1, m_param2, values);
                 return *this;
         }
         };

 A fun(string param1, string param2) {
       return A(param1, param2);
 };

 int main() {
         fun("a", "b") << "xyz" << myfun();
         return 0;
 }

运算符重载链接

5 个答案: