C++ C++；-将具有公共属性的两个不同、唯一类型的排序向量合并为一个新的排序向量

有两种类型，A和B。这两种类型都有一个共同的属性，一个键

有两个类型为A和B的向量。这些向量按键升序排序。向量就其密钥而言是唯一的，即如果密钥存在于a_向量中，则保证不存在于B_向量中，反之亦然

目标是在向量A_vect中获取关键点，构造新的B类型并将它们放入B_vect中，这样B包含它的原始关键点和它的新关键点。新的B_向量也应该进行排序

到目前为止，我有以下代码片段：

#include <iostream>
#include <vector>
#include <algorithm>


struct A
{
    A(int i)
    {
        key = i;
    }
    
    int key;
};

struct B
{
    B(int i)
    {
        key = i;
    }
    
    B()
    {
    }
    
    int key;
};

int main()
{
    std::vector<A> a_diff_sorted_vect = {1, 3};
    std::vector<B> b_sorted_vect = {2, 4};

    std::transform
    (
        a_diff_sorted_vect.begin(), a_diff_sorted_vect.end(), 
        std::back_inserter(b_sorted_vect), 
        [](const A &a) -> B
        {
            B b;
            b.key   = a.key;
            
            return b;
        }
     );
     
    std::cout << "Printing b_sorted_vect" << "\n";
    for(auto element : b_sorted_vect)
    {
        std::cout << std::to_string(element.key) << "\n";
    }
    std::cout << "Finished printing b_sorted_vect" << "\n";
    
    /*
        std::sort
        (
            b_sorted_vect.begin(), 
            b_sorted_vect.end(), 
            [](B lhs, B rhs) 
            {
                return lhs.key < rhs.key;
            }
        );
        
        std::cout << "Printing b_sorted_vect" << "\n";
        for(auto element : b_sorted_vect)
        {
            std::cout << std::to_string(element.key) << "\n";
        }
        std::cout << "Finished printing b_sorted_vect" << "\n";
    */

    return 0;
}

#包括
#包括
#包括
结构A
{
A（国际一）
{
key=i；
}
int键；
};
结构B
{
B（国际一）
{
key=i；
}
B（）
{
}
int键；
};
int main（）
{
向量a_diff_sorted_vect={1,3}；
std：：向量b_排序_向量={2,4}；
std:：transform
(
a_diff_sorted_vect.begin（）、a_diff_sorted_vect.end（），
标准：：反向插入器（b_排序向量），
[]（常数A和A）->B
{
B B；
b、 key=a.key；
返回b；
}
);
std:：cout
std:：set_union
既然您知道要插入的元素的数量，您应该从在
vect_b
中保留空间开始。然后对不同的方法进行基准测试。最好的方法可能在很大程度上取决于向量的大小。@macroland向量的类型不同。是否可以使用set_unionh两种任意类型，如果是，如何？