从另一个字符串向量创建一个对象向量

Question

假设我有一个包含名称的字符串向量，现在我想从这个向量名称创建一个Athlete类向量。那么如何创建一个而不使用使用循环？

这是我的Athlete课程：

class Athlete{
public:
     Athlete(string name, int number);

private:
     string name;
     int number, time;
};

这是我的尝试使用循环，假设矢量名称已包含一些元素：

vector<string> names;
vector<Athlete> athletes;

for(auto i = names.begin(); i != names.end(); i++)
    athletes.push_back(Athlete(*i, i - names.begin() + 1));

但是现在我想创建矢量运动员而不使用使用循环。起初，我以为我会使用generate但是函数对象不能引用向量名。那么我应该使用哪种功能？

Answer 1

Lambda函数

技术上仍然是一个循环，但多次丑陋：

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

using std::cout;
using std::endl;

class Athlete {
public:
    Athlete(std::string name, int number) {};

private:
    std::string name;
    int number, time;
};

int main()
{
    std::vector<std::string> names;
    std::vector<Athlete> athletes;

    std::transform(names.begin(), names.end(), std::back_inserter(athletes),
        [&names](std::string const& name)
        {
            return Athlete(name, &name - &names.front() + 1);
        });
}

基于范围的循环

很有趣，因为循环可能是：

for(auto const& name : names)
    athletes.emplace_back(name, &name - &names.front() + 1);

功能对象＃1

但是既然你想要一个仿函数类，那就是定义：

class StringToAthleteFunct
{
    std::vector<std::string> const& names;

public:

    StringToAthleteFunct(std::vector<std::string> const& names) :
    names(names)
    {
    }

    Athlete operator()(std::string const& name) const
    {
        return Athlete(name, &name - &names.front() + 1);
    }
};

这是用法：

std::transform(names.begin(), names.end(), std::back_inserter(athletes),
    StringToAthleteFunct(names));

功能对象＃2

实际上，这个更好：

class StringToAthleteFunct
{
    int index;

public:
    StringToAthleteFunct() : index(0) { }

    Athlete operator()(std::string const& name)
    {
        return Athlete(name, ++index);
    }
};

- 不需要引用源向量