Come dichiarare un array di stringhe in C ++?

Sto cercando di iterare su tutti gli elementi di un array statico di stringhe nel miglior modo possibile. Voglio essere in grado di dichiararlo su una riga e aggiungere / rimuovere facilmente elementi da esso senza dover tenere traccia del numero. Sembra davvero semplice, non è vero?

Possibili non soluzioni:

vector<string> v;
v.push_back("abc");
b.push_back("xyz");

for(int i = 0; i < v.size(); i++)
    cout << v[i] << endl;

Problemi: non è possibile creare il vettore su una riga con un elenco di stringhe

Possibile mancata soluzione 2:

string list[] = {"abc", "xyz"};

Problemi: nessun modo per ottenere automaticamente il numero di stringhe (che io sappia).

Ci deve essere un modo semplice per farlo.

C ++ 11 ha aggiunto elenchi di inizializzazione per consentire la seguente sintassi:

std::vector<std::string> v = {"Hello", "World"};

Il supporto per questa funzionalità C ++ 11 è stato aggiunto almeno in GCC 4.4 e solo in Visual Studio 2013 .

Puoi inizializzare in modo conciso un vector<string>da un char*array creato staticamente :

char* strarray[] = {"hey", "sup", "dogg"};
vector<string> strvector(strarray, strarray + 3);

Questo copia tutte le stringhe, a proposito, quindi usi il doppio della memoria. Puoi usare il suggerimento di Will Dean per sostituire il numero magico 3 qui con arraysize (str_array) - anche se ricordo che c'era qualche caso speciale in cui quella particolare versione di arraysize potrebbe fare qualcosa di brutto (scusa non ricordo immediatamente i dettagli) . Ma molto spesso funziona correttamente.

Inoltre, se sei davvero entusiasta della cosa su una riga, puoi definire una macro variadica in modo che una singola riga funzioni DEFINE_STR_VEC(strvector, "hi", "there", "everyone");.

Problemi: nessun modo per ottenere automaticamente il numero di stringhe (che io sappia).

Esiste un modo standard per farlo, che molte persone (incluso MS) definiscono macro come arraysizeper:

#define arraysize(ar)  (sizeof(ar) / sizeof(ar[0]))

Dichiara un array di stringhe in C ++ in questo modo: char array_of_strings[][]

Per esempio : char array_of_strings[200][8192];

conterrà 200 stringhe, ciascuna delle quali ha la dimensione di 8kb o 8192 byte.

utilizzare strcpy(line[i],tempBuffer); per inserire dati nell'array di stringhe.

Una possibilità è usare un puntatore NULL come valore di flag:

const char *list[] = {"dog", "cat", NULL};
for (char **iList = list; *iList != NULL; ++iList)
{
    cout << *iList;
}

È possibile utilizzare le funzioni begine enddalla libreria degli intervalli Boost per trovare facilmente le estremità di un array primitivo e, a differenza della soluzione macro, questo darà un errore di compilazione invece di un comportamento interrotto se lo si applica accidentalmente a un puntatore.

const char* array[] = { "cat", "dog", "horse" };
vector<string> vec(begin(array), end(array));

Puoi usare il suggerimento di Will Dean [ #define arraysize(ar) (sizeof(ar) / sizeof(ar[0]))] per sostituire il numero magico 3 qui con arraysize (str_array) - anche se ricordo che ci sono stati casi speciali in cui quella particolare versione di arraysize potrebbe fare qualcosa di brutto (scusa non ricordo i dettagli subito). Ma molto spesso funziona correttamente.

Il caso in cui non funziona è quando l '"array" è in realtà solo un puntatore, non un array effettivo. Inoltre, a causa del modo in cui gli array vengono passati alle funzioni (convertiti in un puntatore al primo elemento), non funziona tra le chiamate di funzione anche se la firma sembra un array - lo some_function(string parameter[])è davvero some_function(string *parameter).

Ecco un esempio:

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

int main() {
    const char* const list[] = {"zip", "zam", "bam"};
    const size_t len = sizeof(list) / sizeof(list[0]);

    for (size_t i = 0; i < len; ++i)
        std::cout << list[i] << "\n";

    const std::vector<string> v(list, list + len);
    std::copy(v.begin(), v.end(), std::ostream_iterator<string>(std::cout, "\n"));
}

Invece di quella macro, potrei suggerire questa:

template<typename T, int N>
inline size_t array_size(T(&)[N])
{
    return N;
}

#define ARRAY_SIZE(X)   (sizeof(array_size(X)) ? (sizeof(X) / sizeof((X)[0])) : -1)

1) Vogliamo usare una macro per renderla una costante del tempo di compilazione; il risultato della chiamata di funzione non è una costante del tempo di compilazione.

2) Tuttavia, non vogliamo utilizzare una macro perché la macro potrebbe essere utilizzata accidentalmente su un puntatore. La funzione può essere utilizzata solo su array in fase di compilazione.

Quindi, usiamo la definizione della funzione per rendere la macro "sicura"; se la funzione esiste (cioè ha una dimensione diversa da zero) allora usiamo la macro come sopra. Se la funzione non esiste restituiamo un valore errato.

#include <boost/foreach.hpp>

const char* list[] = {"abc", "xyz"};
BOOST_FOREACH(const char* str, list)
{
    cout << str << endl;
}

#include <iostream>
#include <string>
#include <vector>
#include <boost/assign/list_of.hpp>

int main()
{
    const std::vector< std::string > v = boost::assign::list_of( "abc" )( "xyz" );
    std::copy(
        v.begin(),
        v.end(),
        std::ostream_iterator< std::string >( std::cout, "\n" ) );
}

Puoi dichiarare direttamente un array di stringhe come string s[100];. Quindi se vuoi accedere a elementi specifici, puoi ottenerlo direttamente come s[2][90]. Per scopi di iterazione, prendi la dimensione della stringa usando la s[i].size()funzione.