C++；从函数调用的多次返回构建字符串向量的最佳方法 我正在练习C++，所以这不是要进入生产的代码，但我很好奇知道：

我有一个指向

Player

类型对象的指针向量：

std::vector<Player*> _players;

我想将所有播放器名称传递给一个函数，该函数期望它们作为字符串向量的引用：

void all_player_names( std::vector< std::string >& );

---

STL中有这样的算法吗？

如果参数为const ref，则除了构造变量外别无选择。const ref应该指向某个现有对象。您可以将函数更改为使用指向函数的指针和指向

std:：vector

的常量ref。使函数获取指向玩家的指针并返回其姓名。

最简单的方法是使用累积并使用一个临时变量，该变量将通过二进制op传递并返回：

std::accumulate(_players.begin(), _players.end(), 
 std::vector<std::string>(),
 [](std::vector<std::string>& vector, const Player* elem) 
   {
    vector.push_back(elem->get_name());
    return vector;
   });

std:：累计（_players.begin（），_players.end（），
std:：vector（），
[]（标准：：向量和向量，常量播放器*elem）
{
vector.push_back（elem->get_name（））；
返回向量；
});

---

多亏了移动语义，它在C++11中几乎没有性能开销。

您想要的是使用lambda表达式（或匿名函数）

现在可以使用C++11，但以前的版本不能。问题也得到了解决

在您的情况下，我将在新类中使用一种方法：

class Players {
public:
    void addPlayer(Player*);
    void removePlayer(Player*);
    vector<string> getNames() {
      std::vector<string> names;
      for(unsigned int i = 0; i != players_.size(); ++i) {
        names.push_back(players_[i]->getName());
      }
    return names;
    }
private:
vector<Player*> players_;

职业玩家{
公众：
无效玩家（玩家*）；
无效移除玩家（玩家*）；
向量getNames（）{
std：：矢量名称；
for（unsigned int i=0；i！=players_u.size（）；++i）{
name.push_back（players_[i]->getName（））；
}
返回姓名；
}
私人：
向量机；

---

})

在我看来，最好使用标准算法std:：transform而不是std:：acculate。在这种情况下，std:：transform的语义比std:：acculate的语义更清晰。比如说

    struct Player
    {
    public:
        Player( const std::string &s ) : s( s ) {}
        const std::string & get_name() const
        {
            return s;
        }
    private:
        std::string s;
    };

    std::vector<Player *> v1;

    v1.push_back( new Player( "Hello" ) );
    v1.push_back( new Player( "Player" ) );

    std::vector<std::string> v2;
    v2.reserve( v1.size() );


    std::transform( v1.begin(), v1.end(), std::back_inserter( v2 ), 
                    std::mem_fun( &Player::get_name ) );

    for ( const std::string &s : v2 ) std::cout << s << ' ';
    std::cout << std::endl;

struct播放器
{
公众：
播放器（const std:：string&s）：s（s）{}
常量std:：string&get_name（）常量
{
返回s；
}
私人：
std：：字符串s；
};
std：：向量v1；
v1.推回（新玩家（“你好”）；
v1.推回（新玩家（“玩家”））；
std：：向量v2；
v2.保留（v1.size（））；
std:：transform（v1.begin（）、v1.end（）、std:：back_插入器（v2），
std:：mem_-fun（&Player:：get_-name））；
对于（const std:：string&s:v2）std:：cout，可以用返回的字符串构建一个向量。。。这是一个暂时的变量，而不是理解。列表理解更像是迭代器对，其中对迭代器的解引用会在fly上生成值。老实说，看看下面的答案，我更喜欢for循环。我的意思是，它仍然没有接近
var Name=players。选择（p=>p.Name）
：-）如果你计划像你那样调用
push_back
，你应该用空构造函数创建向量。+1你的解决方案很好。仍然请在回答中指出您仍然创建一个临时变量并将其作为参数传递。这个函数声明无法避免这种情况，我不知何故未能看到在c++11之前版本中不起作用的代码部分。我也不太明白这是如何解决OP的问题的。
class Players {
public:
    void addPlayer(Player*);
    void removePlayer(Player*);
    vector<string> getNames() {
      std::vector<string> names;
      for(unsigned int i = 0; i != players_.size(); ++i) {
        names.push_back(players_[i]->getName());
      }
    return names;
    }
private:
vector<Player*> players_;

    struct Player
    {
    public:
        Player( const std::string &s ) : s( s ) {}
        const std::string & get_name() const
        {
            return s;
        }
    private:
        std::string s;
    };

    std::vector<Player *> v1;

    v1.push_back( new Player( "Hello" ) );
    v1.push_back( new Player( "Player" ) );

    std::vector<std::string> v2;
    v2.reserve( v1.size() );


    std::transform( v1.begin(), v1.end(), std::back_inserter( v2 ), 
                    std::mem_fun( &Player::get_name ) );

    for ( const std::string &s : v2 ) std::cout << s << ' ';
    std::cout << std::endl;