Memorizzare l'array di caratteri in una classe e quindi restituirlo

Question

Devo archiviare un array di caratteri all'interno di una classe e quindi restituirlo. Devo ammettere che sono un po 'confuso riguardo ai puntatori e ho provato tutto quello che mi viene in mente ma non riesco a farlo funzionare. Ecco cosa ho:

#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();
}

Ovviamente, mi aspetto che setName () memorizzi la stringa " Test " all'interno della classe e getName () dovrebbe restituire " Test " ;. Ma invece ricevo solo la prima lettera T. Cosa sto facendo di sbagliato?

Immagino che dovrei usare le stringhe standard, ma prima vorrei capire perché questo non funziona. Per quanto ne so, questo dovrebbe funzionare anche con gli array di caratteri?

Answer 1

Restituisce solo un puntatore:

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

e aggiungi un costruttore per la classe Test che annullerebbe la matrice incapsulata:

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

in modo da non chiedere problemi se qualcuno crea un'istanza Test di classe e non chiama setName () sull'istanza.

Answer 2

In Test :: getName () stai solo restituendo un carattere (primo carattere). Dovresti invece restituire l'indirizzo del primo carattere da cui inizia la stringa, ovvero cambiare il tipo di ritorno in char * e l'istruzione return in return m_name;

Answer 3

Quando hai un puntatore, p , l'operatore di dereferenziazione del puntatore * " segue " il puntatore in modo che l'espressione * p restituisca l'oggetto a cui punta il puntatore.

In molte situazioni, il nome di un array come m_name , può comportarsi come un puntatore. Pertanto, * m_name restituisce il primo char nell'array, poiché quello è il tipo il nome dell'array, quando interpretato come puntatore, punta a.

Dal momento che le stringhe in C sono rappresentate come puntatori ai caratteri, non dovresti dereferenziare il puntatore, ma renderlo intatto.

Molti hanno suggerito di usare strncpy () per scrivere la stringa di input nell'array, poiché esegue (una sorta di) controllo dei limiti. Tuttavia, non è ottimale, la semantica è dispari e copiare una stringa in un buffer limitato non è proprio quello per cui è stata progettata. È meglio investigare se hai una varietà di snprintf () nel tuo ambiente, e usala così:

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

Answer 4

Ed è più sicuro usare strncpy () di strcpy () in void Test :: setName ()

Answer 5

Se vuoi che questo sia C ++, semplicemente non usare i puntatori char se non hai un motivo molto, molto specifico per farlo!

Passa dal puntatore char a std :: string e vedi se questo risolve il tuo problema:

#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();
}

Per i punti bonus, imposta il tipo di parametro in setName in const std :: string & amp ;.