Vérifier si la chaîne est en chaîne (liste des chaînes)

Je suis nouveau ici et de C++. J'ai eu une certaine expérience en python, et trouvé de "si a dans b" est vraiment facile, et je me demandais si il y a un équivalent en C++.

Fond

J'ai essayé de faire une liste de chaînes et de vérifier si une entrée est dans la liste.
La raison pour laquelle je veux faire, c'est parce que je veux seulement utiliser une fonction si l'entrée sera effectivement faire quelque chose dans cette fonction. (Changement de type int coordonnées x et y dans ce cas)

Question

string myinput;
string mylist[]={"a", "b", "c"};
cin>>myinput;
//if myinput is included in mylist
//do other stuff here

Comment puis-je vérifier à l'aide d'un if si l'entrée myinput est inclus dans la chaîne de mylist?

En supposant que vous maliste aurait uniquement les valeurs uniques?
stackoverflow.com/questions/6194797/...

InformationsquelleAutor Sumyjkl | 2013-01-25

c++cin if-statement input string

13

Vous pouvez utiliser std::find:
```
std::string myinput;
std::vector<std::string> mylist{"a", "b", "c"};

std::cin >> myinput;
if (std::find(std::begin(mylist), std::end(mylist), myinput) != std::end(mylist))
    //myinput is included in mylist.
```
Cela fonctionne bien avec seulement trois cordes, mais si vous allez avoir beaucoup plus, vous seriez probablement mieux avec un std::set ou std::unordered_set à la place.
```
std::set<std::string> myset;
//put "a", "b", and "c" into the set here

std::cin >> myinput;
if (myset.find(myinput) != myset.end())
    //myinput is included in myset.
```
- +1: insertion dans un ensemble ne serait pas un O(1) O(n) si. Donc, cela dépend de ce qui est vraiment nécessaire (rapide insertion / recherche rapide)
- L'Insertion dans un ensemble serait en O(log n) dans le cas d'habitude. Au moins dans un cas typique, vous vous attendez à une recherche plus d'insérer de toute façon. Bien sûr, si vous utilisez unordered_set, vous pouvez vous attendre les insertions à O(1) ainsi.
- Ajouter un en-tête de fichier <algorithm>
InformationsquelleAutor Jerry Coffin
2

Utilisation std::find:
```
std::size_t listsize = sizeof mylist / sizeof mylist[0];
if (std::find(mylist, mylist + listsize, myinput) != mylist + listsize) {
    //found
}
```
Si vous connaissez la taille de la liste à l'avance, je vous suggère de std::array qui expose les itérateurs et un size() fonction, ainsi que quelques autres avantages intégrées dans des tableaux. Notez que c'est le C++11 (le C++03, près équivalent est std::vector), et aussi avec le C++11 est std::begin et std::end, qui la réduisent à ceci:
```
if (std::find(std::begin(mylist), std::end(mylist), myinput) != std::end(mylist))
```
Il est assez facile de faire votre propre intégré dans les tableaux en C++03, mais avec un conteneur standard qui expose begin() et end() membres, cela ne devrait pas être trop nécessaire, même si elle est plus polyvalente.
- Vrai, je vais ajouter que dans le std::array note.
- Merci, même si je m'attendais à quelque chose d'un peu plus simple, je crois que je vais essayer de comprendre comment l'utiliser.
- c'est aussi simple que en Python, la seule différence est la syntaxe, mais ce qui se passe est vraiment la même. À l'aide de C++ sans utiliser la STL, c'est comme l'utilisation de python sans son API fourni
- C'est juste le concept initial pour obtenir plus. find() la recherche par le biais de la fourchette que vous spécifiez (plus facilement a noté avec le début et la fin des fonctions) et retourne la position (un itérateur) à laquelle il se trouve, ou à la fin de la plage si il ne l'est pas. C'est pourquoi vous devez comparer le résultat avec la fin de la position que vous transmettez. L'ensemble de la sizeof affaires divise la taille totale du tableau par la taille d'un élément, donnant le nombre d'éléments, mais comme mentionné, les conteneurs standard exposer facile size() membre, si ce n'est pas trop utile dans ce contexte.
InformationsquelleAutor chris

Utilisation std::find, std::find_if algorithmes

  string myinput;
  string mylist[]={"a", "b", "c"};

  std::string *begin = mylist;
  std::string *end = mylist + 3;

  if (std::find(begin, end, "b") != end)
  {
    std::cout << "find" << std::endl;
  }

Ou de l'utilisation de C++11 std::array avec std::begin(), std::end()

std::array<std::string, 3> mylist = { "a", "b", "c" };

if (std::find(std::begin(mylist), std::end(mylist), "b") != std::end(mylist))
{
  cout << "find" << endl;
}

Ou Lambda:

if (std::find_if(std::begin(mylist), std::end(mylist),
     [](const std::string& s){ return s == "b";}) != std::end(mylist))

InformationsquelleAutor billz

Puisque vous travaillez avec le C++ n'hésitez pas à l'aide de la bibliothèque STL:

  string mylist[]={"a", "b", "c"};
  vector<string> myvector(mylist, mylist + sizeof(mylist)/sizeof(mylist[0])); 

  if (find(myvector.begin(), myvector.end(), mystring) != myvector.end()) {
    ..
  }

InformationsquelleAutor Jack

if (find(mylist, &mylist[3], myinput) != &mylist[3])
    ...

InformationsquelleAutor user1610015

#include <algorithm>
#include <iostream>
#include <string>

using namespace std;

int main()
{
    string myinput;
    string mylist[]={"a", "b", "c"};
    if (cin >> myinput && 
        std::find(std::begin(mylist), std::end(mylist), myinput) == std::end(mylist))
    {
        //do other stuff
    }
}

InformationsquelleAutor Denis

Vous pouvez en utiliser, comme d'autres l'ont suggéré, ou vous pouvez utiliser une boucle for(easierfor débutants):

for (int i = 0; i < mylist.size() ; i ++){
        if (myinput == mylist[i]){
               //Do Stuff
        }

InformationsquelleAutor Sajjad Heydari

Vous pouvez également utiliser std::count

#include <iostream>
#include <algorithm>  //std::count
#include <vector>

//using namespace std;

int main() {
    std::vector<std::string> ans = {"a", "b", "c", "a"};
    std::cout << count(ans.begin(), ans.end(), "a") << std::endl;
    return 0;
}

si le nombre > 0, cela signifie que la chaîne est dans les cordes.

InformationsquelleAutor Hu Xixi

Vous devez vous connecter pour publier un commentaire.