Come determinare la dimensione di un array di stringhe in C ++?

Question

che sto cercando di stampare semplicemente fuori i valori contenuti in un array.

Ho un array di stringhe chiamato 'risultato'. Non so esattamente quanto è grande perché è stato generato automaticamente.

Da quello che ho letto, è possibile determinare la dimensione di un array in questo modo:

sizeof(result)/sizeof(result[0])

È corretto? Perché per il mio programma, sizeof (risultato) = 16 e sizeof (risultato [0]) = 16 in modo che il codice mi avrebbe detto che la mia matrice è di taglia 1.

Tuttavia, che non sembra corretto, perché se stampo manualmente i valori di matrice in questo modo:

std::cout << result[0] << "\n";
std::cout << result[1] << "\n";
std::cout << result[2] << "\n";
std::cout << result[3] << "\n";
etc...

... poi vedo i valori risultanti che sto cercando. La matrice è verso l'alto di 100+ valori di lunghezza / dimensione.

Sembra che dovrebbe essere molto semplice per determinare la dimensione / lunghezza di un array ... quindi spero sto solo perdendo qualcosa qui.

Sono un po 'di C ++ newb modo che qualsiasi aiuto sarebbe apprezzato.

Answer 1

Non è possibile determinare la dimensione di un array dinamico in C ++. È necessario passare la dimensione intorno come parametro.

Come nota a margine, utilizzando un contenitore libreria standard (ad esempio, il vettore) allieviates questo.

Nel tuo esempio sizeof, sizeof(result) sta chiedendo per la dimensione di un puntatore (ad presumibilmente uno std :: string). Questo perché il tipo effettivo matrice "decade" ad un tipo di puntatore da elemento quando passato a una funzione (anche se la funzione è dichiarata a prendere un tipo array). Il sizeof(result[0]) restituisce le dimensioni del primo elemento nella matrice, che per coincidenza è 16 byte. Sembra che i puntatori sono 16 byte (128 bit) sulla propria piattaforma.

Ricordate che sizeof è sempre valutate al momento della compilazione in C ++, non in fase di esecuzione.

Answer 2

Come commento lato, ci sono modi migliori di controllo della dimensione di una matrice (per i casi in cui la matrice è portata e non è decaduta in un puntatore) che sono typesafe:

// simple: runtime result
template <typename T, std::size_t N>
inline std::size_t sizeof_array( T (&)[N] ) {
   return N;
}

// complex: compile time constant
template <typename T, std::size_t N>
char (&static_sizeof_array( T(&)[N] ))[N];   // declared, not defined
#defined SIZEOF_ARRAY( x ) sizeof(static_sizeof_array(x))

In entrambi i casi il compilatore in grado di rilevare se si tenta di passare in un puntatore (array dinamico o array decaduto):

void f( int array[] ) { // really: void f( int *array )
{
//   sizeof_array(array);              // compile time error
//   int another[SIZEOF_ARRAY(array)]; // compile time error
}
int main() {
   int array[] = { 1, 2, 3 };
   std::cout << sizeof_array(array) << std::endl; // prints 3
   int another_array[ SIZEOF_ARRAY(array) ];
   std::cout << sizeof_array(another_array) << std::endl; // 3 again
}

Answer 3

Se quello che hai è un array di "reale", quindi il sizeof (x) / sizeof (x [0]) trucco funziona. Se, tuttavia, quello che hai è davvero un puntatore (ad esempio qualcosa tornato da una funzione), allora quel trucco non funziona - si finirà per dividere la dimensione di un puntatore da parte del sizeof un puntatore. Essi sono puntatori a diverse tipologie, ma su un tipico sistema tutti i puntatori sono le stesse dimensioni, in modo otterrete uno. Anche quando i puntatori sono diverse dimensioni, il risultato ancora non ha nulla a che fare con il numero di stringhe che hai.

Answer 4

Migliore utilizzo std::vector<std::string> invece di un array grezzo. Quindi non c'è bisogno di gestire manualmente la memoria array ed è possibile utilizzare la size() metodo se si desidera conoscere il numero di elementi.

Se si utilizza una matrice di prime allocata dinamicamente si sono tenuti a tenere traccia delle sue dimensioni te stesso, la dimensione non è possibile ottenere dalla matrice. Miglior salvarlo in una variabile in più.

Answer 5

Il sizeof (array) / sizeof (elemento) funziona per lunghezza-array fisso-lunghezza-array fissi (non di puntatori). Come un array di stringhe che più spesso utilizza una (lunghezze standard fisso) array di puntatori-a-various- (fisso) di lunghezza-strings quindi questo trucco non avrebbe funzionato. sizeof () è usato per scopi che dimensioni è noto al momento della compilazione. Non è applicabile alle assegnati dinamicamente i dati in sé.

Quando un oggetto contiene puntatori come nel caso di una matrice di stringhe, sizeof () restituisce la dimensione della struttura di livello più alto (di dimensione fissa). Spesso è solo la dimensione di un singolo puntatore. Non include la dimensione dei dati allocati cui punta il puntatori. Quando i dati in realtà non fa parte dell'oggetto principale, è effettivamente uno o più oggetti separati (abbiamo aggregazione qui invece di composizione, vedere http://en.wikipedia.org/wiki/Object_composition ).

In C ++ utilizzando vettori è molto conveniente per le vostre esigenze. Altri contenitori standard adatti possono essere usati anche. metodi di lunghezza () e le dimensioni () sono sinonimi, vedi http: //www.cplusplus. com / riferimento / string / string / formato / )

P.S. Si prega di notare che per std :: string s sizeof oggetto (s) è una costante indipendente della lunghezza effettiva (variabile) stringa restituita da s.length (). La dimensione effettiva memoria allocata viene restituito da s.capacity () e potrebbe essere maggiore della lunghezza ().

Esempio con matrice vettore:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main()
{
    string s = "01234";
    cout << "s[" << s.length() << "]=\"" << s << "\"" << endl; 
    cout << "sizeof(s)=" << sizeof(s) << " (implementation dependent)" << endl;
    cout << endl;

    s += "56789012345";
    cout << "s[" << s.length() << "]=\"" << s << "\"" << endl; 
    cout << "sizeof(s)=" << sizeof(s) << " (implementation dependent)" << endl;
    cout << endl;

    vector<string>vs={"12","23","345","456","567","67888","7899999999","8","9876543210"};

    cout << "vs[" << vs.size() << "]={";
    size_t sz=0;
    for (size_t index=0; index<vs.size(); index++)
    {
        sz+=vs[index].size();
        if (index>0)
            cout << ",";
        cout << "\"" << vs[index] << "\":" << vs[index].size();
    }
    cout << "}:" << sz << endl;
    cout << "sizeof(vs)=" << sizeof(vs) << " (implementation dependent)" << endl;

    return 0;
}

Risultato:

s[5]="01234"
sizeof(s)=8 (implementation dependent)

s[16]="0123456789012345"
sizeof(s)=8 (implementation dependent)

vs[9]={"12":2,"23":2,"345":3,"456":3,"567":3,"67888":5,"7899999999":10,"8":1,"9876543210":10}:39
sizeof(vs)=24 (implementation dependent)

Answer 6

template< class T, size_t N >
std::size_t Length(const T(&)[N])
{
    return N;
};

std::cout << Length(another_array) << std::endl;

Answer 7

Nel metodo String dimensioni uso vettore ()

Answer 8

Qualcosa di essere a conoscenza di: testo può essere rappresentato in diversi metodi. Un array di testo può anche essere rappresentato in diversi metodi.

array di puntatori a stringhe in stile C

Un metodo comune è quello di avere un array di puntatori a char. Il problema è che la dimensione della matrice non rappresenta la dimensione di tutto il testo. Inoltre, la proprietà dei dati o del puntatore deve essere stabilita, in quanto il testo potrebbe essere necessario eliminare (e può il chiamato eliminare il testo o fa il chiamante?). Perché è un array, la dimensione della matrice deve sempre accompagnare la matrice in tutti i parametri (a meno che la matrice è sempre una dimensione fissa).

Array of char - testo confezionato

Un altro metodo è quello di passare una matrice di char e hanno le stringhe contigue nella matrice. Una stringa segue il char cessazione del precedente. Con questa matrice, la dimensione totale di tutte le stringhe è rappresentato, nessuno spazio sprecato. Ancora una volta, con array, la dimensione della matrice deve accompagnare la matrice quando passato intorno.

Array of std::string

In C ++, il testo può essere rappresentato utilizzando std::string. In questo caso, la matrice rappresenta la quantità di stringhe (simile alla matrice di C-Corde sopra). Per ottenere la dimensione totale di tutte le stringhe, si deve riassumere le dimensioni di ogni singola stringa. Poiché questo è un array, la dimensione della matrice deve essere passata anche.

Sommario

Durante la fase di esecuzione formati matrice devono accompagnare la matrice quando la matrice viene passata in giro. sizeof viene elaborato solo in fase di compilazione. Una struttura più semplice è std::vector, che gestisce l'allocazione dimensioni e della memoria in modo dinamico.