Comment initialiser un constructeur qui prend les Chaînes de caractères comme paramètres?

Je ne suis pas sûr que je suis en utilisant la terminologie appropriée, mais la question est comment puis-je bien faire d'un constructeur qui prend une chaîne de caractères comme paramètre?

Je suis habitué à avoir un const char * dans le constructeur au lieu de chaînes de caractères.

Normalement, je devrais faire quelque chose comme ceci:

Name(const char* fName, const char* lName)
    : firstName(0), lastName(0)
{
    char * temp = new char [strlen(fName) + 1];
    strcpy_s(temp, strlen(fName) + 1, fName);
    firstName = temp;

    char * temp2 = new char [strlen(lName) + 1];
    strcpy_s(temp2, strlen(lName) + 1, lName);
    lastName = temp2;
}

Que si le constructeur est: est-ce

 Name(const string fName, const string lName) { }

Dois-je encore faire la base de l'initialisation de membre? dois-je encore besoin d'utiliser la chaîne de copie dans la base du constructeur?

OriginalL'auteur Sarah | 2013-11-05

c++constructor string

10

Utilisation std::string et d'initialiseur de listes:
```
std::string fName, lName;

Name(string fName, string lName):fName(std::move(fName)), lName(std::move(lName))
{
}
```
Dans ce cas, vous n'avez pas besoin d'utiliser terriblement nue pointeurs, vous n'avez pas besoin d'allouer de la mémoire, copier des caractères et, enfin, de lui allouer. En outre, ce nouveau code a toutes les chances de profiter des avantages de se déplacer plutôt que de copier depuis std::string est mobile. Aussi, il est utile de lire cette.

Et ainsi de suite....

Pourquoi n'aurais-je pas initialiser à 0 comme je le ferais avec des char *?
Parce que std::string objets ne sont pas censés être 0, car il y a des objets (pas de pointeurs). Ils sont vides, comme dans le sens de "".
En plus de Martijn de commentaire, le code ci-dessus est en cours d'initialisation et de copier simultanément. Vous n'avez besoin de rien d'autre.
Merci c'est exactement ce que je voulait savoir
Le code ci-dessus pourrait en fait encourir au moins 2 copies, sauf si vous spécifiez explicitement std::move dans la liste d'initialiseur. Aussi, ce n'est pas un bon exemple de la sémantique de déplacement, car vous n'aurez qu'1 exemplaire; exactement le même que si vous aviez utilisé une référence.

OriginalL'auteur deepmax
8

Je vois que vous avez déjà accepté une réponse, mais je souhaite compléter les réponses.

Comme deepmax dit, si vous passez par la valeur que vous pouvez écrire votre constructeur de profiter de "la sémantique de déplacement". Cela signifie plutôt que de copier les données, il peut être déplacé d'une variable à l'autre.

Écrit comme suit:
```
class Name{
    public:
        Name(std::string var): mem_var(std::move(var)){}

        std::string mem_var;
};
```
Qui semble être une bonne idée, mais, en réalité, n'est pas plus efficace que le constructeur de copie
```
class Name{
    public:
        Name(const std::string &var): mem_var(var){}

        std::string mem_var;
};
```
La raison que c'est, c'est parce que les cas qui ressemble à ceci:
```
auto main() -> int{
    Name name("Sample Text");
}
```
une seule copie aurai jamais fait (voir copie élision), et dans l'autre cas de
```
auto main() -> int{
    std::string myname = "Hugh Jaynus";
    Name name(myname);
}
```
2 copies seront faites dans le "efficace" par la valeur sémantique de déplacement!

C'est un bon exemple de cas où le constructeur de copie (ou par référence) devrait être utilisé, pas un exemple contre elle.

Au contraire...

Si vous écrivez explicitement un constructeur qui rend l'utilisation de la sémantique de déplacement, vous pourriez obtenir une solution efficace peu importe les circonstances.

Ici est de savoir comment je serait d'écrire la définition de la classe:
```
class Name{
    public:
        Name(const std::string &first_, const std::string &last_)
            : first(first_), last(last_){}

        Name(std::string &&first_, std::string &&last_) //rvalue reference
            : first(std::move(first_)), last(std::move(last_)){}

        std::string first, last;
};
```
Puis lorsque vous utilisez cette classe vous puissiez décider quand l'un des deux est plus efficace.

Si nous revenons à nos exemples, nous pouvons réécrire à faire usage de la meilleure ou la plus efficace constructeur:
```
auto main() -> int{
    //pass by reference best here
    Name myname("Yolo", "Swaggins");

    //move most efficient here
    //but never use 'first' and 'last' again or UB!
    std::string first = "Hugh", last = "Jaynus";
    Name yourname(std::move(first), std::move(last));
}
```
Jamais prendre pour acquis qu'une solution est meilleure que toutes les autres!

OriginalL'auteur CoffeeandCode
3

J'ai l'habitude de le faire:
```
std::string fName;
std::string lName;

Name(const std::string &fName, const std::string &lName) :
     fName(fName), lName(lName)
{
}
```
À l'aide des références sauve le travail de copier les chaînes de caractères à un nouvel objet sur la pile, il suffit de passer la référence de la chaîne existante. Une fois que vous êtes en les assignant à des membres de la classe, ils seront copiés.

Pourquoi vous ne passez pas par valeur si vous le souci de l'efficacité?
mais si je ne suis pas en utilisant des références à des chaînes dans mes paramètres?
J'ai écrit dans ma réponse: parce qu'ils ne soient pas copiés en les passant au constructeur. Le constructeur aura à les copier en tant que bien, dans tous les cas (avec ou sans les références).
Eh bien, alors vous restez avec votre situation actuelle ou la modifier à const références.
La sémantique de déplacement (C++11) dire quelque chose d'autre, de lire cet article.

OriginalL'auteur Martijn Courteaux
0

si vous voulez garder const char * comme votre constructeur de types d'entrée ce faire.
```
std::string fName;
std::string lName;

Name(const char *_fName, const char *_lName) :
     fName(_fName), lName(_lName)
{
}
```
Vous pouvez construire une std::string à partir d'un const char.

Les identificateurs commençant par un trait de soulignement sont réservés par le compilateur, vous devriez les avoir de fuite.

OriginalL'auteur Mark Hendrickson

Vous devez vous connecter pour publier un commentaire.