Comment puis-je initialiser des tableaux de char dans un constructeur?

Je vais avoir de la difficulté de la déclaration et l'initialisation d'un tableau de char. Toujours, il affiche des caractères aléatoires. J'ai créé un petit morceau de code pour montrer ce que j'essaie à mon plus grand programme:

class test
{
    private:
        char name[40];
        int x;
    public:
        test();
        void display()
        {
            std::cout<<name<<std::endl;
            std::cin>>x;
        }
};
test::test()
{
    char name [] = "Standard";
}

int main()
{   test *test1 = new test;
    test1->display();
}

Et désolé si ma mise en forme est mauvaise, j'ai peine à comprendre ce site et encore moins comment corriger mon code 🙁

Connexes: Comment puis-je utiliser la liste d'initialisation de membre de l'initialiser?
Ok, donc je suis en utilisant std::string maintenant, cependant, dans le plus grand programme c'est pour j'ai été en utilisant une fonction comme ceci: void get(char invite[], int taille,char b[]) où char b[] a été mon char tableau à partir d'avant. Comment pourrais-je le modifier afin de passer d'une chaîne à ma fonction get?
De retour d'un std::string objet au lieu de void.

OriginalL'auteur ShengLong916 | 2012-05-02

arrays c++c++11 char

Si il n'y a pas de raisons particulières de ne pas utiliser std::string, utilisez std::string.

Mais si vous avez vraiment besoin d'initialiser le personnage de membre du groupe, puis:

#include <assert.h>
#include <iostream>
#include <string.h>
using namespace std;

class test
{
    private:
        char name[40];
        int x;
    public:
        test();
        void display() const
        {
            std::cout<<name<<std::endl;
        }
};

test::test()
{
    static char const nameData[] = "Standard";

    assert( strlen( nameData ) < sizeof( name ) );
    strcpy( name, nameData );
}

int main()
{
    test().display();
}

Je pense que le main corps est un peu cryptique, de mesurer l'OP de la phase d'apprentissage 🙂
J'ai donc décidé d'utiliser std::string, mais comme pour mon commentaire ci-dessus, comment pourrais-je passer d'une chaîne dans une autre fonction?

OriginalL'auteur Cheers and hth. - Alf

6

Votre constructeur n'est pas le réglage de la variable de membre name, c'est de déclarer une variable locale. Une fois que la variable locale est hors de portée à la fin du constructeur, il disparaît. Pendant ce temps la variable de membre n'est pas encore initialisé et est rempli avec de l'aléatoire d'ordures.

Si vous allez utiliser l'ancienne tableaux de caractères, vous aurez également besoin d'utiliser une ancienne fonction comme strcpy à copier dans la variable membre. Si tout ce que vous voulez faire est de définir une chaîne vide, vous pouvez l'initialiser avec name[0] = 0.

OriginalL'auteur Mark Ransom
5

En considérant que vous avez marqués à la question C++, vous devez utiliser std::string:
```
#include <string>

class test
{
    private:
        std::string name;
        int x;
    public:
        test();
        void display()
        {
            std::cout<<name<<std::endl;
            std::cin>>x;
        }
};
test::test() : name("Standard")
{

}
```
Merci beaucoup cela m'a bien aidé.
Je n'ai jamais très bien compris comment "identiques" réponses postées tard plus upvotes. Et ma réponse a été sans doute (beaucoup) plus complète de l'obtenir-aller...
Je ne comprends pas trop ce site mais sehe, j'ai essayé de upvote les deux, mais ne le pouvait pas. Désolé.
C'est ok, je n'étais pas vraiment blâmer qui que ce soit 🙂
qui sait :D.

OriginalL'auteur mfontanini

Puisque vous êtes à l'aide de C++, je suggère d'utiliser des chaînes à la place des tableaux de char. Sinon, vous auriez besoin d'utiliser la fonction strcpy (ou des amis).

Aussi, vous avez oublié de supprimer le test1 instance.

#include <iostream>
#include <string>

class test
{
    private:
        std::string name;
        int x;
    public:
        test();
        void display()
        {
            std::cout<<name<<std::endl;
        }
};

test::test()
{
    name = "Standard";
}

int main()
{   
    test test1;
    test1.display();

    std::cin>>x;
}

Merci beaucoup les gars, vous êtes SUPER!
cas d'utilisation pour des tableaux de char: C++ est disponible dans les endroits où les mst lib n'est pas, comme les microcontrôleurs.

OriginalL'auteur sehe

2

c++11 en fait, fournit deux façons de le faire. Vous pouvez par défaut le membre sur sa déclaration en ligne ou vous pouvez utiliser la liste d'initialisation du constructeur.

Exemple de déclaration en ligne de l'initialisation:
```
class test1 {
    char name[40] = "Standard";
public:
    void display() { cout << name << endl; }
};
```
Exemple de constructeur d'initialisation:
```
class test2 {
    char name[40];
public:
    test2() : name("Standard") {};
    void display() { cout << name << endl; }
};
```
Vous pouvez voir un exemple de ces deux là: http://ideone.com/zC8We9

Ma préférence personnelle est d'utiliser la déclaration en ligne de l'initialisation de la raison:
1. Où aucune des autres variables doivent être construits cela permet à l'généré constructeur par défaut pour être utilisé
2. Où plusieurs constructeurs sont nécessaires cela permet que la variable est initialisée dans un seul endroit plutôt que dans l'ensemble le constructeur d'initialisation des listes
Ayant dit tout cela, à l'aide d'un char[] peut être considérée comme nuisible que la valeur générée par défaut de l'opérateur d'assignation, et de copier/déplacer des constructeurs ne fonctionne pas. Ce problème peut être résolu par:
1. Rendre le membre const
2. À l'aide d'un char* (cela ne fonctionnera pas si le membre de la retenir, mais une chaîne littérale)
3. Dans le cas général std::string doit être préférée à l'
OriginalL'auteur Jonathan Mee

Vous devez vous connecter pour publier un commentaire.