Jak zadeklarować tablicę ciągów w C ++?

Staram się iterować wszystkie elementy statycznej tablicy ciągów w najlepszy możliwy sposób. Chcę móc zadeklarować go w jednej linii i łatwo dodawać / usuwać z niego elementy bez konieczności śledzenia liczby. Brzmi naprawdę prosto, prawda?

Możliwe nierozwiązania:

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

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

Problemy - brak możliwości stworzenia wektora w jednej linii z listą łańcuchów

Możliwy brak rozwiązania 2:

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

Problemy - nie ma możliwości automatycznego uzyskania liczby ciągów znaków (o której wiem).

Musi być na to łatwy sposób.

C ++ 11 dodał listy inicjalizacyjne, aby umożliwić następującą składnię:

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

Obsługa tej funkcji języka C ++ 11 została dodana w co najmniej GCC 4,4 i tylko w programie Visual Studio 2013 .

Możesz zwięźle zainicjować a vector<string>z char*tablicy utworzonej statycznie :

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

Nawiasem mówiąc, to kopiuje wszystkie ciągi, więc zużywasz dwukrotnie więcej pamięci. Możesz skorzystać z sugestii Willa Deana, aby zastąpić magiczną liczbę 3 tutaj arraysize (str_array) - chociaż pamiętam, że był jakiś specjalny przypadek, w którym ta konkretna wersja Arraysize może zrobić coś złego (przepraszam, nie pamiętam szczegółów od razu) . Ale bardzo często działa poprawnie.

Ponadto, jeśli naprawdę zależy Ci na jednej linii, możesz zdefiniować makro wariadyczne, tak aby pojedyncza linia DEFINE_STR_VEC(strvector, "hi", "there", "everyone");działała.

Problemy - nie ma możliwości automatycznego uzyskania liczby ciągów znaków (o której wiem).

Istnieje na to standardowy sposób, w którym wiele osób (w tym MS) definiuje makra, takie jak arraysize:

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

Zadeklaruj tablicę ciągów w C ++ w następujący sposób: char array_of_strings[][]

Na przykład : char array_of_strings[200][8192];

pomieści 200 ciągów, z których każdy ma rozmiar 8kb lub 8192 bajtów.

służy strcpy(line[i],tempBuffer); do umieszczania danych w tablicy ciągów.

Jedną z możliwości jest użycie wskaźnika NULL jako wartości flagi:

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

Możesz użyć funkcji begini endz biblioteki zakresów Boost, aby łatwo znaleźć końce pierwotnej tablicy, iw przeciwieństwie do rozwiązania makr, spowoduje to błąd kompilacji zamiast zepsutego zachowania, jeśli przypadkowo zastosujesz go do wskaźnika.

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

Możesz użyć sugestii Willa Deana [ #define arraysize(ar) (sizeof(ar) / sizeof(ar[0]))], aby zastąpić magiczną liczbę 3 tutaj arraysize (str_array) - chociaż pamiętam, że był jakiś specjalny przypadek, w którym ta konkretna wersja arraysize może zrobić coś złego (przepraszam, nie pamiętam szczegółów natychmiast). Ale bardzo często działa poprawnie.

Sytuacja, w której to nie działa, ma miejsce, gdy „tablica” jest tak naprawdę tylko wskaźnikiem, a nie rzeczywistą tablicą. Ponadto, ze względu na sposób, w jaki tablice są przekazywane do funkcji (konwertowane na wskaźnik do pierwszego elementu), nie działa między wywołaniami funkcji, nawet jeśli podpis wygląda jak tablica - some_function(string parameter[])tak naprawdę some_function(string *parameter).

Oto przykład:

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

Zamiast tego makra mógłbym zasugerować to:

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) Chcemy użyć makra, aby uczynić z niego stałą czasu kompilacji; wynik wywołania funkcji nie jest stałą czasu kompilacji.

2) Jednak nie chcemy używać makra, ponieważ mogłoby to zostać przypadkowo użyte na wskaźniku. Ta funkcja może być używana tylko w tablicach kompilowanych w czasie.

Dlatego używamy zdefiniowanej funkcji, aby uczynić makro „bezpiecznym”; jeśli funkcja istnieje (tj. ma niezerowy rozmiar), używamy makra jak powyżej. Jeśli funkcja nie istnieje, zwracamy złą wartość.

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

Możesz bezpośrednio zadeklarować tablicę ciągów, taką jak string s[100];. Następnie, jeśli chcesz uzyskać dostęp do określonych elementów, możesz to uzyskać bezpośrednio jak s[2][90]. Na potrzeby iteracji weź rozmiar łańcucha za pomocą s[i].size()funkcji.