C++ 如何通过STL算法得到两个数组（向量）的组合？

我有

v1

和

v2

，我应该如何获得一个新的

v

，如下所示

v1 = {1,2}
v2 = {3,4,5}

v = {f(1,3) , f(1,4) , f(1,5) f(2,3) ,f(2,4) ,f(2,5)}

我知道我可以用两个循环来实现，但如果有更惯用的方法，比如使用STL算法呢

//using two loops
for iter1 of v1 
     for iter2 of v2
           v.push_back(f(v1,v2))

编辑：

---

v1

和

v2

不必具有相同的大小。

没有合适的STL算法，但这种组合可以通过自定义函数和std:：generate实现：

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

typedef int T;

struct Fctor
{
    typedef std::vector<T>::iterator Iterator;
    Iterator it1, it2, begin, end;

    Fctor(Iterator begin1, Iterator end1, Iterator begin2)
    {
        begin = begin1;
        end = end1;
        it1 = begin1;
        it2 = begin2;
    }

    T operator()()
    {
        // T result = f(*it1, *it2);
        T result = (*it1) * (*it2);

        if(++it1 != end) return result;
        it1 = begin;
        ++ it2;
        return result;
    }
};


int main()
{
    std::vector<T> v1; v1.push_back(1); v1.push_back(2);
    std::vector<T> v2; v2.push_back(3); v2.push_back(4); v2.push_back(5);
    std::vector<T> result(v1.size() * v2.size());

    Fctor fctor(v2.begin(), v2.end(), v1.begin());
    generate(result.begin(), result.end(), fctor);

    std::copy(result.begin(), result.end(), 
              std::ostream_iterator<T>(std::cout, " "));
    std::cout << std::endl;
    // => 3 4 5 6 8 10
}

#包括
#包括
#包括
#包括
typedef int T；
结构过滤器
{
typedef std:：vector:：迭代器迭代器；
迭代器it1，it2，开始，结束；
Fctor（迭代器begin1、迭代器end1、迭代器begin2）
{
begin=begin1；
结束=结束1；
it1=begin1；
it2=begin2；
}
T运算符（）（）
{
//T结果=f（*it1，*it2）；
T结果=（*it1）*（*it2）；
如果（++it1！=end）返回结果；
it1=开始；
++it2；
返回结果；
}
};
int main（）
{
标准：：向量v1；v1.向后推（1）；v1.向后推（2）；
向量v2；v2.推回（3）；v2.推回（4）；v2.推回（5）；
向量结果（v1.size（）*v2.size（））；
Fctor Fctor（v2.begin（），v2.end（），v1.begin（））；
生成（result.begin（）、result.end（）、fctor）；
复制（result.begin（），result.end（），
std：：ostream_迭代器（std：：cout，“”）；
标准：：cout 3 4 5 6 8 10
}

没有合适的STL算法，但这种组合可以通过自定义函数和std:：generate实现：

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

typedef int T;

struct Fctor
{
    typedef std::vector<T>::iterator Iterator;
    Iterator it1, it2, begin, end;

    Fctor(Iterator begin1, Iterator end1, Iterator begin2)
    {
        begin = begin1;
        end = end1;
        it1 = begin1;
        it2 = begin2;
    }

    T operator()()
    {
        // T result = f(*it1, *it2);
        T result = (*it1) * (*it2);

        if(++it1 != end) return result;
        it1 = begin;
        ++ it2;
        return result;
    }
};


int main()
{
    std::vector<T> v1; v1.push_back(1); v1.push_back(2);
    std::vector<T> v2; v2.push_back(3); v2.push_back(4); v2.push_back(5);
    std::vector<T> result(v1.size() * v2.size());

    Fctor fctor(v2.begin(), v2.end(), v1.begin());
    generate(result.begin(), result.end(), fctor);

    std::copy(result.begin(), result.end(), 
              std::ostream_iterator<T>(std::cout, " "));
    std::cout << std::endl;
    // => 3 4 5 6 8 10
}

#包括
#包括
#包括
#包括
typedef int T；
结构过滤器
{
typedef std:：vector:：迭代器迭代器；
迭代器it1，it2，开始，结束；
Fctor（迭代器begin1、迭代器end1、迭代器begin2）
{
begin=begin1；
结束=结束1；
it1=begin1；
it2=begin2；
}
T运算符（）（）
{
//T结果=f（*it1，*it2）；
T结果=（*it1）*（*it2）；
如果（++it1！=end）返回结果；
it1=开始；
++it2；
返回结果；
}
};
int main（）
{
标准：：向量v1；v1.向后推（1）；v1.向后推（2）；
向量v2；v2.推回（3）；v2.推回（4）；v2.推回（5）；
向量结果（v1.size（）*v2.size（））；
Fctor Fctor（v2.begin（），v2.end（），v1.begin（））；
生成（result.begin（）、result.end（）、fctor）；
复制（result.begin（），result.end（），
std：：ostream_迭代器（std：：cout，“”）；
标准：：cout 3 4 5 6 8 10
}

计算笛卡尔积的好的非递归算法是什么这看起来几乎与您的要求完全相同：计算笛卡尔积的好的非递归算法是什么这与您的要求几乎完全相同：