C++ 用于排序可变数组数的可变模板

我正在尝试编写一个程序，使用可变模板将未排序的‘n’向量排序为一个排序向量。这可以通过其他方式来完成，但我想通过这种方式来更好地理解可变模板。我不知道我是否能做到这一点，但下面是我的尝试，这是不起作用的

我的理解是，最终排序的n向量将减少为

MergeVector+MergeVector+MergeVectorMergeVector

与第50行（MergeVector a8（a5+a6+a7））相同，但我认为这是错误的。请帮助，并给我一些代码审查意见以及

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <functional>
#include <string>

template<typename t>
class MergeVector {
        public:
        std::vector<t> arr_;

        MergeVector(std::vector<t> arr) : arr_(arr) {}

        auto operator + (MergeVector<t> &obj) {
                std::vector<t> dst;
                std::sort(arr_.begin(), arr_.end());
                std::sort(obj.arr_.begin(), obj.arr_.end());
                std::merge(arr_.begin(), arr_.end(), obj.arr_.begin(), obj.arr_.end(), std::back_inserter(dst));
                MergeVector res(dst);
                return res;
        }

        friend auto& operator<<(std::ostream &os, MergeVector<t>& mv)
        {
                std::copy(mv.arr_.begin(), mv.arr_.end(), std::ostream_iterator<t>(os, " "));
                return os;
        }
};

template<typename t>
auto sorted_n_vector(t vec)
{
        return vec;
}

template<typename t, typename... vectors>
auto sorted_n_vector(t vec, vectors... args)
{
        return vec + sorted_n_vector(args...);
}

int main() {
        std::vector<int> a1 = {1, 2, 3};
        std::vector<int> a2 = {4, 5, 6};
        std::vector<int> a3 = {7, 8, 9};
        MergeVector<int> a5(a1);
        MergeVector<int> a6(a2);
        MergeVector<int> a7(a3);
        MergeVector<int> a8(a5 + a6 + a7); //---- Line 50
        std::cout << a8 << std::endl;

#if 1
        MergeVector<int> a9(sorted_n_vector(a5, a6, a7));
        std::cout << a9 << std::endl;
#endif

        return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
模板
类合并向量{
公众：
std：：向量arr；
MergeVector（std:：vector arr）：arr(arr）{}
自动运算符+（合并向量和对象）{
std：：向量dst；
排序（arr\u.begin（），arr\u.end（））；
std:：sort（obj.arr_u2;u.begin（），obj.arr_2;u.end（））；
std:：merge（arr.begin（）、arr.end（）、obj.arr.begin（）、obj.arr.end（）、std:：back_插入器（dst））；
合并向量资源（dst）；
返回res；
}
friend auto&operator
排序向量
的返回类型指定为
auto
，因此它将返回一个临时对象，而不是对其他对象的引用

您尝试使用此临时参数调用
运算符+
，但
运算符+
需要一个非常量（左值）引用参数

禁止将临时（或相当的值表达式）绑定到非const（LValk）引用，因此编译器不会考虑调用您的<代码>运算符+ < /代码>，而是将搜索到其他地方。
找不到对
+
的任何替代调用，它会向您显示所看到的错误消息

解决方案是将
运算符+
的参数作为常量参考：

auto operator + (const MergeVector<t> &obj) {

然后，您可以在
operator+
中删除
std:：sort
行，并且可以在两个参数中完全设置
const
：

auto operator + (const MergeVector<t> &obj) const {

自动运算符+（常量合并向量和对象）常量{
将
操作符+（）
声明为成员函数是个坏主意。这对
操作符+=（）
有好处，但
操作符+（）
更适合作为
朋友
函数

以身作则

    friend auto operator+ (MergeVector<t> mv1, MergeVector<t> mv2)
     {
       std::vector<t> dst;
       std::sort(mv1.arr_.begin(), mv1.arr_.end());
       std::sort(mv2.arr_.begin(), mv2.arr_.end());

       std::merge(std::make_move_iterator(mv1.arr_.begin()),
                  std::make_move_iterator(mv1.arr_.end()),
                  std::make_move_iterator(mv2.arr_.begin()),
                  std::make_move_iterator(mv2.arr_.end()),
                  std::back_inserter(dst));

       return MergeVector<t>{dst};
     }

额外的观察：如果你可以使用C++17，你可以使用模板折叠，所以

template<typename... vectors>
auto sorted_n_vector(vectors... args)
{
   return (args + ...);
}

模板
自动排序的向量（向量…参数）
{
返回值（args+…）；
}
你能确切地说明你想要什么，以及你得到了什么吗？如果你的目标只是对一个可变数量的
向量进行排序，那么
for
在
向量上循环
就可以了。一旦你的程序运行起来，代码审查评论最好留给代码审查。@WeaktoEnumaElish:更新帖子以回答这个问题你的问题。我真的不明白为什么没有任何理由-1？谢谢你的澄清，我知道你现在做得更好了。但我不知道哪行代码是50。当你处理一行特定的代码不起作用时，最好写一条评论，这样我们就可以看到。@WeaktoEnumaElish:why-1？
    friend auto operator+ (MergeVector<t> mv1, MergeVector<t> mv2)
     {
       std::vector<t> dst;
       std::sort(mv1.arr_.begin(), mv1.arr_.end());
       std::sort(mv2.arr_.begin(), mv2.arr_.end());

       std::merge(std::make_move_iterator(mv1.arr_.begin()),
                  std::make_move_iterator(mv1.arr_.end()),
                  std::make_move_iterator(mv2.arr_.begin()),
                  std::make_move_iterator(mv2.arr_.end()),
                  std::back_inserter(dst));

       return MergeVector<t>{dst};
     }

    MergeVector (std::vector<t> arr) : arr_{std::move(arr)} {}

template<typename... vectors>
auto sorted_n_vector(vectors... args)
{
   return (args + ...);
}