操作与链接

Question

重载我想超载< <运营商链接像下面

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

功能1将返回一个对象。

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

我的问题将是

1. 我怎么知道是串，在表达式中的最后一个参数，因此我需要使用参数1和参数来调用另一个函数2或者它是不可能这样做呢？

2. 如何将param1和param2传递给要调用的函数？我无法将param1和param2存储在对象中，因为它是多线程的。

谢谢。

Answer 1

您可以通过在其析构函数中调用function2的值从function1返回一个帮助对象。

考虑这个例子：

#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

我怎么知道是串，在表达式中最后 参数，因此 我需要调用使用 参数1和参数的功能，或者是不可能 这样做呢？

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

没有做什么，你认为它。这里function1首先计算，生成的对象用来调用operator<<与obj2作为参数等等...

如果你想在最后调用function1，你叫operator<<与string4作为后应该发生一个论点。

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

你op<<应该回到它具有op()定义类型T的对象，这样你都可以将其与param1和param2在最后。

Answer 3

如果function1返回一些东西（比如int），那么您应该能够延迟al计算直到它被使用。 。您应该返回一个可以转换为int的对象（通过将int operator int()作为成员函数实现）。

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

Answer 4

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

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

标准库中的IO流库通过使用一个全局对象为规避这一问题的“标记“：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 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; 
}