Initialiser la matrice ou du vecteur sur du constructeur de l'initialisation de la liste

Comment puis-je initialiser un (string) matrice ou d'un vecteur d'un constructeur de l'initialisation de la liste en C++?

Veuillez considérer cet exemple là où je veux initialiser un tableau de chaînes avec des arguments donnés par le constructeur:

#include <string>
#include <vector>

class Myclass{
           private:
           std::string commands[2];
           //std::vector<std::string> commands(2); respectively 

           public:
           MyClass( std::string command1, std::string command2) : commands( ??? )
           {/* */}
}

int main(){
          MyClass myclass("foo", "bar");
          return 0;
}

En outre, laquelle de ces deux types (tableau vs vecteur) est recommandé pour l'enregistrement de deux chaînes lors de la création d'un objet, et pourquoi?

Utiliser des accolades, tout comme vous le feriez normalement.
Comme dans Myclass m = {"hello", "world"}; ou comme dans Myclass(const std::string& c1, const std::string& c2) : commands{c1, c2}{}?
L'un de ceux à ne pas initialiser les membres, tandis que l'autre s'affiche bien dans Vaughn réponse.
Oui, c'était en quelque sorte de ce que je recevais. 😉

OriginalL'auteur fotinsky | 2013-10-24

arrays c++constructor initialization vector

Avec C++11, tu fais comme ça:

class MyClass{
           private:
           std::string commands[2];
           //std::vector<std::string> commands;

           public:
           MyClass( std::string command1, std::string command2)
             : commands{command1,command2}
           {/* */}
};

Pour le pré-C++11 compilateurs, vous devez initialiser la matrice ou du vecteur dans le corps du constructeur:

class MyClass{
           private:
           std::string commands[2];

           public:
           MyClass( std::string command1, std::string command2)
           {
               commands[0] = command1;
               commands[1] = command2;
           }
};

class MyClass{
           private:
           std::vector<std::string> commands;

           public:
           MyClass( std::string command1, std::string command2)
           {
               commands.reserve(2);
               commands.push_back(command1);
               commands.push_back(command2);
           }
};

Merci. Et pour les anciens compilateurs?
Je l'ai étendu ma réponse à couvrir avant C++11 compilateurs.
que faire si j'utilise C++11 compilateurs et de définir un membre privé std::vector<std::string> commands; comme vous l'avez fait dans la pré-exemple C++? Est-il un moyen plus rapide pour initialiser commands?
oui. C'est exactement la même chose de toute façon.

OriginalL'auteur Vaughn Cato

1

Dans la liste d'initialiseur vous pouvez appeler n'importe quel constructeur de la classe du membre à qui vous souhaitez initialiser. Jetez un oeil à std::string et std::vector de la documentation et de choisir le constructeur qui fonctionne pour vous.

Pour le stockage de deux objets, je vous conseille d'utiliser std::pair. Toutefois, si vous vous attendez à ce que le nombre peut croître std::vector est la meilleure option.

OriginalL'auteur Ivaylo Strandjev

Vous pouvez utiliser

#include <utility>

...
std::pair<string, string> commands;
commands=std::make_pair("string1","string2");

...
//to access them use
std::cout<<commands.first<<" "<<commands.second;

OriginalL'auteur titus

class Myclass{
private:
    Vector<string> *commands;
    //std::vector<std::string> commands(2); respectively 

    public:
    MyClass( std::string command1, std::string command2)
    {
        commands.append(command1);  //Add your values here
    }
}

OriginalL'auteur anbu selvan

Vous devez vous connecter pour publier un commentaire.