Comment déclarer un tableau de chaînes en C ++?

J’essaie de parcourir tous les éléments d’un tableau statique de chaînes de manière optimale. Je veux pouvoir le déclarer sur une seule ligne et en append / supprimer facilement des éléments sans avoir à suivre le numéro. Cela semble vraiment simple, n’est-ce pas?

Non-solutions possibles:

vector v; v.push_back("abc"); b.push_back("xyz"); for(int i = 0; i < v.size(); i++) cout << v[i] << endl; 

Problèmes – aucun moyen de créer le vecteur sur une ligne avec une liste de chaînes

Non-solution possible 2:

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

Problèmes – pas moyen d’obtenir le nombre de chaînes automatiquement (que je connais).

Il doit y avoir un moyen facile de le faire.

La bibliothèque d’affectation de boost semble être exactement ce que vous recherchez. Cela permet d’assigner des constantes aux conteneurs plus facilement que jamais.

C ++ 11 a ajouté des listes d’initialisation pour autoriser la syntaxe suivante:

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

La prise en charge de cette fonctionnalité C ++ 11 a été ajoutée dans au moins GCC 4.4 et uniquement dans Visual Studio 2013 .

Vous pouvez initialiser de manière concise un vector partir d’un tableau de caractères char* créé statiquement:

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

Cela copie toutes les chaînes, au fait, vous utilisez donc deux fois plus de mémoire. Vous pouvez utiliser la suggestion de Will Dean pour remplacer le nombre magique 3 par arraysize (str_array) – bien que je me souvienne qu’il existe un cas particulier dans lequel cette version particulière de l’arraysize pourrait faire quelque chose de mal (désolé je ne me souviens pas des détails immédiatement) . Mais cela fonctionne très souvent correctement.

De plus, si vous êtes vraiment fan de la ligne unie, vous pouvez définir une macro variadic pour qu’une seule ligne telle que DEFINE_STR_VEC(strvector, "hi", "there", "everyone"); travaux.

Problèmes – pas moyen d’obtenir automatiquement le nombre de chaînes (que je connais).

Il existe une méthode standard de bog, à savoir que de nombreuses personnes (y compris MS) définissent des macros telles que des arraysize pour:

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

Déclarez un tableau de chaînes en C ++ comme ceci: char array_of_ssortingngs[][]

Par exemple: char array_of_ssortingngs[200][8192];

contiendra 200 chaînes, chaque chaîne ayant une taille de 8 Ko ou 8 192 octets.

utilisez strcpy(line[i],tempBuffer); mettre des données dans le tableau de chaînes.

Une possibilité consiste à utiliser un pointeur NULL comme valeur de drapeau:

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

Vous pouvez utiliser les fonctions de begin et de end de la bibliothèque de plages Boost pour trouver facilement les extrémités d’un tableau primitif. Contrairement à la solution de macros, vous obtiendrez une erreur de compilation au lieu d’un comportement endommagé si vous l’appliquez accidentellement à un pointeur.

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

Vous pouvez utiliser la suggestion de Will Dean [ #define arraysize(ar) (sizeof(ar) / sizeof(ar[0])) ] pour remplacer le nombre magique 3 ici par arraysize (str_array) – bien que je me souvienne dans lequel cette version particulière de l’arraysize pourrait faire quelque chose de mal (désolé je ne peux pas me souvenir des détails immédiatement). Mais cela fonctionne très souvent correctement.

Le cas où cela ne fonctionne pas, c’est quand le “tableau” est vraiment un pointeur, pas un tableau réel. De plus, en raison de la manière dont les tableaux sont transmis aux fonctions (convertis en pointeur sur le premier élément), ils ne fonctionnent pas entre les appels de fonctions, même si la signature ressemble à un tableau – some_function(ssortingng parameter[]) some_function(ssortingng *parameter) .

J’ai essayé de dire à Craig H que vous devriez utiliser boost :: assign, mais je n’ai pas de rep 🙁

J’ai rencontré une technique similaire dans le premier article que j’ai lu par Andrei Alexandrescu dans C / C ++ Users Journal , Vol 16, No 9, septembre 1998, pp. 73-74 (citation complète car elle figure dans les commentaires de mon implémentation de son code que j’utilise depuis).

Les modèles sont votre ami.

Au lieu de cette macro, pourrais-je suggérer celle-ci:

 template inline size_t array_size(T(&)[N]) { return N; } #define ARRAY_SIZE(X) (sizeof(array_size(X)) ? (sizeof(X) / sizeof((X)[0])) : -1) 

1) Nous voulons utiliser une macro pour en faire une constante à la compilation; le résultat de l’appel de fonction n’est pas une constante à la compilation.

2) Cependant, nous ne voulons pas utiliser une macro car la macro peut être utilisée accidentellement sur un pointeur. La fonction ne peut être utilisée que sur des tableaux de compilation.

Nous utilisons donc la définition de la fonction pour rendre la macro “sûre”; Si la fonction existe (c’est-à-dire qu’elle a une taille non nulle), nous utilisons la macro comme ci-dessus. Si la fonction n’existe pas, nous renvoyons une mauvaise valeur.

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

Voici un exemple:

 #include  #include  #include  #include  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 v(list, list + len); std::copy(v.begin(), v.end(), std::ostream_iterator(std::cout, "\n")); } 
 #include  #include  #include  #include  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" ) ); } 
 #include  #include  int main() { int n; cout<<"enter the maximum number\n"; cin>>n; cout<<"enter the first number\n"; for(int i=0;i>a[i][j]; } } cout<<"enter the second number\n"; for(int i=0;i>b[i][k]; } } cout<<"the product will be\n"; for(int i=0;i 

Vous pouvez directement déclarer un tableau de chaînes comme ssortingng s[100]; . Ensuite, si vous voulez accéder à des éléments spécifiques, vous pouvez l’obtenir directement comme s[2][90] . À des fins d’itération, prenez la taille de la chaîne en utilisant la fonction s[i].size() .