+ =在没有提升的载体

问题描述

有没有办法使用了矢量+ =运算符不使用升压或使用衍生化类？

例如：

  somevector + = 1，2，3，4，5，6，7;
 

实际上是

  somevector.push_back（1）;
somevector.push_back（2）;
somevector.push_back（3）;
等等
 

解决方案

随着一点点丑操作符重载，这是不是太难以实现。该溶液可以很容易地制成更通用，但它应当作为一个适当的实施例。

 的#include＆LT;矢量＆GT;
 

您需要的语法使用两家运营商：在 + = 运营商和，运营商。首先，我们需要创建一个包装类，使我们能够运用，运营商一个元素推到一个向量的后面：

 模板＆LT; typename的T＆GT;
结构push_back_wrapper
{
    明确push_back_wrapper（性病::矢量＆lt; T＆GT;＆放大器; 5）：v _（＆放大器; 5）{}    push_back_wrapper＆安培;运营商（常量T＆安培; X）
    {
        v _-＆GT;的push_back（X）;
        返回*这一点;
    }    的std ::矢量＆lt; T＆GT; * V_;
};
 

于是，为了结合 + = 上的向量利用这一点，我们重载 + = 运营商的载体。我们返回 push_back_wrapper 实例，这样我们就可以推链背上用逗号操作：

 模板＆LT; typename的T，typename的U＆GT;
push_back_wrapper＆LT; T＆GT;运算符+ =（的std ::矢量＆lt; T＆GT;＆安培; V，const的U＆安培; X）
{
    v.push_back（X）;
    返回push_back_wrapper＆LT; T＆GT;（五）;
}
 

现在我们可以写出code，你在你的例子有：

  INT的main（）
{
    的std ::矢量＆lt;＆INT GT;伏;
    V + = 1，2，3，4，5，6，7;
}
 

的 V + = 1 将调用我们的运算符+ = 超载，将返回的实例 push_back_wrapper 。然后，逗号运算符应用于每个在随后的元素之列。

Is there any way to use the += operator with a vector without using boost or using a derivated class?

Eg.

somevector += 1, 2, 3, 4, 5, 6, 7;

would actually be

somevector.push_back(1);
somevector.push_back(2);
somevector.push_back(3);
etc.

解决方案

With a little ugly operator overloading, this isn't too difficult to accomplish. This solution could easily be made more generic, but it should serve as an adequate example.

#include <vector>

Your desired syntax uses two operators: the += operator and the , operator. First, we need to create a wrapper class that allows us to apply the , operator to push an element onto the back of a vector:

template <typename T>
struct push_back_wrapper
{
    explicit push_back_wrapper(std::vector<T>& v) : v_(&v) { }

    push_back_wrapper& operator,(const T& x)
    {
        v_->push_back(x);
        return *this;
    }

    std::vector<T>* v_;
};

Then, in order to use this in conjunction with += on a vector, we overload the += operator for a vector. We return a push_back_wrapper instance so that we can chain push backs with the comma operator:

template <typename T, typename U>
push_back_wrapper<T> operator+=(std::vector<T>& v, const U& x)
{
    v.push_back(x);
    return push_back_wrapper<T>(v);
}

Now we can write the code you have in your example:

int main()
{
    std::vector<int> v;
    v += 1, 2, 3, 4, 5, 6, 7;
}

The v += 1 will call our operator+= overload, which will return an instance of the push_back_wrapper. The comma operator is then applied for each of the subsequent elements in the "list."

这篇关于+ =在没有提升的载体的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！