Stocker un tableau de caractères dans une classe puis le renvoyer

Question

Je dois stocker un tableau de caractères dans une classe, puis le renvoyer. Je dois admettre que je suis un peu confus au sujet des pointeurs et que j'ai essayé tout ce à quoi je peux penser mais que je ne peux pas le faire fonctionner. Voici ce que j'ai:

#include <iostream>
using namespace std;

class Test {
public:
    void setName(char *name);
    char getName();
private:
    char m_name[30];
};

void Test::setName(char *name) {
    strcpy(m_name, name);
}

char Test::getName() {
    return *m_name;
}

void main() {

    Test foobar;
    char name[] = "Testing";
    foobar.setName(name);
    cout << foobar.getName();
}

Bien sûr, je m'attends à ce que setName () stocke la chaîne " Testing " Dans la classe, getName () devrait renvoyer "Testing". Mais au lieu de cela, je ne reçois que la première lettre T. Qu'est-ce que je fais mal?

Je suppose que je devrais utiliser des chaînes std, mais j'aimerais tout d'abord comprendre pourquoi cela ne fonctionne pas. Autant que je sache, cela devrait également fonctionner avec les tableaux de caractères?

Answer 1

Il suffit de renvoyer un pointeur:

const char* Test::getName() const
{
    return m_name;
}

et ajoutez un constructeur pour la classe Test qui terminerait nullement le tableau encapsulé:

Test::Test()
{
    m_name[0] = 0;
}

afin de ne pas poser de problèmes si quelqu'un instancie la classe Test et n'appelle pas nomNom () sur l'instance.

Answer 2

Dans Test :: getName () , vous ne renvoyez qu'un seul caractère (premier caractère). Vous devez plutôt renvoyer l'adresse du premier caractère à partir duquel la chaîne commence, c'est-à-dire changer le type de retour en char * et l'instruction de retour en return m_name;

Answer 3

Lorsque vous avez un pointeur, p , l'opérateur de déréférencement du pointeur * "suit". le pointeur de sorte que l'expression * p soit évaluée en fonction de l'objet sur lequel pointe le pointeur.

Dans de nombreuses situations, le nom d'un tableau, tel que nom_m , peut se comporter comme un pointeur. Ainsi, * m_name correspond au premier char du tableau, car il s'agit du type. Le nom du tableau, lorsqu'il est interprété comme un pointeur, pointe sur.

Etant donné que les chaînes en C sont représentées comme des pointeurs sur des caractères, vous ne devez pas déréférencer le pointeur, mais le renvoyer intact.

Beaucoup ont suggéré d'utiliser strncpy () pour écrire la chaîne d'entrée dans votre tableau, car il vérifie (en quelque sorte) les limites. Cependant, ce n'est pas optimal, sa sémantique est étrange et copier une chaîne dans un tampon limité n'est vraiment pas ce pour quoi il a été conçu. Il est préférable de rechercher si vous avez une variété de fonctions snprintf () dans votre environnement et de les utiliser comme suit:

snprintf(m_name, sizeof m_name, "%s", name);

Answer 4

Et il est préférable d'utiliser strncpy () que strcpy () dans void Test :: setName ()

Answer 5

Si vous voulez que ce soit du C ++, n'utilisez simplement pas les pointeurs de caractères, sauf si vous avez une raison très spécifique de le faire!

Passez du pointeur de caractère à std :: string et voyez si cela résout votre problème:

#include <iostream>
#include <string>
using namespace std;

class Test {
public:
    void setName(std::string name);
    std::string getName();
private:
    std::string m_name;
};

void Test::setName(std::string name) {
    m_name = name;
}

std::string Test::getName() {
    return m_name;
}

void main() { 
    Test foobar;
    foobar.setName("Testing");
    cout << foobar.getName();
}

Pour les points bonus, définissez le type de paramètre dans setName comme une constante std :: string & amp;.