Compter les occurences d'un caractère dans un string

Bonjour à tous,
j'ai besoin de compter le nombre de fois qu'un caractère apparait dans un string .
Pour cela , j'ai ecris ce code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

string chaine = "ABCDABCD"; int longueurchaine = chaine.size(); int compteurcaractere = 0; for (int i=0;i<longueurchaine;++i) { cout << (expression.c_str())[i] << endl; //<= cela affiche bien le caractère de la chaine a la position i.   if (strcmp (expression.c_str()[i],"A") { compteurcaractere++; } }

---

Mais cela ne fonctionne pas ,au niveau de la ligne strcomp().
Quelqu'un pourrait m'aider a comprendre ? ou me proposer une autre solution ?
Merci d'avance de votre aide .

Bonjour,
Je ne connais pas strcomp (je ne connais que strcmp), mais je présume qu'il doit renvoyer 0 lorsque les 2 caractères sont égaux. D'où ton test donne le résultat inverse.
Cependant, pourquoi chercher à faire ce genre de chose. La STL te fourni tout ce qu'il te faut :
std::count_if
std::equal_to
et binder1st
D'où :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <iostream> #include <string> #include <algorithm> #include <functional> int main() { std::string chaine = "ABCDABCD"; int nbr_item = std::count_if( chaine.begin(), chaine.end(), std::bind1st(std::equal_to<char>(),'A') ); std::cout<<nbr_item<<std::endl;   return 0; }

---

c'est une erreure de ma part , c'est bien strcmp et non strcomp .
Etant débutant , j'ai du mal a suivre ton code , surtout a quoi servent :
std::equal_to
et binder1st
Même en suivant les liens , c'est pas évident ....
car en fait le code que tu me donnes fonctionne , mais moi j'ai besoin de rechercher le nombre de fois qu'il y a "A" par exemple sauf si il y a un "\" devant et la du coup c'est pas bon .
Il faut que je modifie un rtuc dans la ligne bind1st mais je ne sais pas quoi ....

Le plus simple c'est quand même std::count, il me semble. :aie:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <string> #include <algorithm> #include <iostream>   int main() {   std::string chaine = "ABCDABCD"; int nbr_item = std::count( chaine.begin(), chaine.end(), 'A'); std::cout<<nbr_item<<std::endl;   return 0; }

---

c'est effectivement plus simple .
Mais je m'etais orienté vers ce code car je dois compter le nombre de A qui ne sont pas precedé par un \ :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

string chaine = "ABCDABCD\A\B\C\D"; int compteurchamps=0; int longueurchaine = chaine.size(); for (int i=0;i<longueurchaine;++i) { cout << (chaine.c_str())[i] << endl; //<= cela affiche bien le caractère de la chaine a la position i.   if (strcmp (chaine.c_str()[i],"\A") != 0 && strcmp (chaine.c_str()[i-1],"\A") != 0) { compteurchamps++; } }   cout << "nbchamps = " << compteurchamps << endl;

---

et sur la ligne du strcmp() , j'obtiens l'erreur suivante :

|erreur: invalid conversion from «const char» to «const char*»|
|erreur: initializing argument 1 of «int strcmp(const char*, const char*)»|
||=== Build finished: 2 errors, 0 warnings ===|

quelqu'un peut m'aider sur le pourquoi de cette erreur ?

Bonjour,
Il me semble que l'erreur est assez explicite mais bon,

Citation:

---

invalid conversion from «const char» to «const char*»

---

Code:

---

strcmp (chaine.c_str()[i],"\(")

---

chaine.c_str()[i] renvoie un char et la fonction attend un char * le compilateur n'arrive pas à convertir le char en char *.
A bientôt

Citation:

---

Envoyé par Arzar

Le plus simple c'est quand même std::count, il me semble. :aie:

---

Effectivement. Des fois, on s'emballe :roll:

Citation:

---

Envoyé par techz

c'est effectivement plus simple .
Mais je m'etais orienté vers ce code car je dois compter le nombre de A qui ne sont pas precedé par un \ :

---

Quand tu commences à faire des recherche non trivial, alors souvent il est judicieux de s'intéresser aux expressions régulières.

Salut,

Citation:

---

Envoyé par techz

std::equal_to
et binder1st

---

std::equal_to est ce que l'on appelle un foncteur, c'est à dire une classe ou une structure qui a pour va agir comme une fonction (cette définition est un peu simpliste, voire l'entrée de la FAQ sur le sujet pour avoir plus d'information ;))

Son rôle est de comparer deux instances pour déterminer si elles sont égales ;)

Le fait est que ce foncteur n'appartient à aucun type particulier, et que, pour qu'il soit en mesure de fonctionner, il doit... disposer des deux objets à comparer :aie:

Si tu voulais l'utiliser toi même, tu serait en effet obligé de l'utiliser sous la forme de

Code:

---

1 2 3 4 5 6 7

Type t1; Type t2; bool res = std::equal_to(t1, t2); if(res) { cout<<"t1 et t2 sont égaux"<<endl; }

---

Marqué pas de bol, count_if n'est capable que de passer un seul argument aux fonctions :aie:... (il travaille avec des ne prenant qu'un seul argument ;))

C'est là que bind_1st intervient:

La programmation générique (basée sur les template) permet en effet de considérer la liste des arguments à passer comme un argument unique, grâce à ce que l'on appelle les "traits de politique" et le "data binding" (explication rapide et simple, donc, forcément incomplète et pas tout à fait juste ;))

bind_1st permet d'enclencher le processus de data bindind et donc, de permettre la transmission de deux argument à equal_to alors que count_if n'était capable que de passer un seul argument au foncteur

Il y aurait moyen de s'étendre énormément sur les différents points de cette réponse, mais cela me ferait écrire, encore un fois, un véritable roman ;)

On peut avoir quelque chose comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <iostream> #include <string>   int main() { std::string chaine = "ABCD\\AABAA"; int count = 0; for (int i = 0; i<chaine.size();++i) if (chaine[i] == 'A' && (i == 0 || chaine[i-1] != '\\')) ++count;   std::cout << "Nombre de A non précédés de '\\' : " << count << std::endl;     }

---

mais cela suppose que les caractères '\' soient protégés ("échappés") par un premier '\'.

Cela dit il me semble que c'est inévitable dans une string, par exemple si je compile ceci (où la chaîne contient un '\' non échappé) :

Code:

---

1 2 3 4 5 6 7 8 9

#include <iostream> #include <string>   int main() { std::string chaine = "ABCD\AABAA";   std::cout << chaine << std::endl; }

---

j'obtiens un message d'erreur :

Code:

---

1 2	essai2.cpp: In function ‘int main()’: essai2.cpp:6: erreur: unknown escape sequence '\A'

---

et je l'obtiendrai même sans le cout en tentant simplement de compiler :

Code:

---

1 2 3 4 5 6 7 8

#include <string>   int main() { std::string chaine = "ABCD\AABAA";   }

---

C'est normal,

Il n'y a pas de caractère échappé (précédé d'un \ ) '\A'...

Le back slash "\" sert, avant tout, à échapper le caractère qui suit ( '\0', '\b', '\r', '\t', '\n'...) pour indiquer qu'il faut prendre un caractère particulier ('\0', indique le caractère de valeur nulle, '\b' indique le caractère de retour de curseur,'\t' le caractère tabulation, '\n' le passage à la ligne suivante, etc...)

Si tu veux rechercher un back slach en tant que caractère \, tu dois l'échaper, et l'écrire '\\' ;)

Dans ce cas-ci, quand on a ...\\A... dans une chaîne, la première des deux barres obliques inverses qui précèdent le 'A', indique que la seconde barre n'est PAS à prendre comme un caractère spécial (cette seconde barre n'est pas à interpréter justement comme... le caractère d'échappement mais comme un simple caractère 'littéral").

La barre oblique inverse (\) a en effet deux usages :
- construire la représentation de certains caractères particuliers comme le retour à la ligne '\n', la tabulation '\t' etc.
- indiquer que le caractère, habituellement 'spécial' , qui suit n'est pas à considérer comme spécial mais comme un caractère ordinaire sans signification particulière (l'emploi qui nous concerne ici).

Un autre emploi de ce genre serait par exemple ceci :

Code:

---

1 2 3 4 5 6 7 8 9

#include <iostream> #include <string>     int main() { std::string s = "il a dit \"oh !\" et il s'est enfui"; std::cout << s << std::endl; }

---

Le guillemet double est 'spécial' : il indique le début ou la fin d'une chaine. Si tu veux lui faire perdre ce rôle et le traiter comme un caractère ordinaire, tu l'échappes avec la barre oblique inverse.

EDIT La norme donnée plus bas par 3DArchi, rajoute quelques autres cas de figure d'emploi de la barre oblique inverse.

En fait, le back slash "échappe" le caractère qui suit:

Le guillemet sert à représenter la fin d'une chaine.

Quand tu le fait précéder du back slash, tu "échappe" le guillemet pour indiquer au compilateur qu'il ne faut pas le prendre dans son utilité première.

De même, lorsque tu échappe le back slash, tu échappe le caractère d'échappement, pour dire au compilateur qu'il ne faut pas le considérer dans son utilité première qui est... d'échapper le caractère qui suit :D

Un petit rappel de norme :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

escape-sequence: simple-escape-sequence octal-escape-sequence hexadecimal-escape-sequence universal-character-name simple-escape-sequence: one of \' \" \? \\ \a \b \f \n \r \t \v octal-escape-sequence: \ octal-digit \ octal-digit octal-digit \ octal-digit octal-digit octal-digit hexadecimal-escape-sequence: \x hexadecimal-digit hexadecimal-escape-sequence hexadecimal-digit universal-character-name: \u hex-quad \U hex-quad hex-quad hex-quad: hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit

---

Merci 3dArchi, voilà qui clarifie.

EDIT Humpf mais est-ce qu'on peut considérer que cela permet '\0', mentionné plus haut par koala01 ?

\u, c'est du C++0x?

Citation:

---

Envoyé par ptyxs

Humpf mais est-ce qu'on peut considérer que cela permet '\0', mentionné plus haut par koala01 ?

---

Citation:

---

octal-escape-sequence:
\ octal-digit

---

Ca suffit, non ?

Citation:

---

Envoyé par Médinoc

\u, c'est du C++0x?

---

C'est tiré de la norme C...

le '\0' (zero, et non O ;)) est utilisé pour représenter la fin d'une chaine de caractères C style...

Si tu demande l'affichage d'une telle chaine déclarée sous la forme de

Code:

---

1 2	char str[]="une chaine\0 coupee apres le deuxieme mot"; ptrintf("%s",str);

---

tu n'aura que l'affichage de "une chaine" ;)
(et si tu utilises les fonctions C propres aux chaines de caractères (strlen, strcmp, strcat, ...), "coupee apres le deuxieme mot" ne sera jamais pris en compte ;)
[EDIT]c'est d'ailleurs le moyen le plus simple de vider une chaine de caractères C style: placer un '\0' au premier caractère ( str[0] ) ;)

[EDIT 2] Le plus marrant de l'histoire, c'est que, le C++ se basant sur le standard C, on remarque assez facilement que la création d'une std::string utilisera également le '\0' comme délimiteur:

Code:

---

1 2 3 4 5 6 7 8 9 10

#include <iostream> #include <string> using namespace std; int main() { std::string str("une chaine\0 coupee apres le deuxieme mot"); cout<<str.size()<<" "<<str<<endl <<str[13];//devrait afficher 'o' return 0; }

---

affiche n'importe quoi, mais pas 'o' ;)

Citation:

---

Envoyé par 3DArchi

C'est tiré de la norme C...

---

Pas C90, en tout cas.

Le gros problème des séquences d'échappement octales et compagnie, c'est que le code des séquences d'échappement n'est pas un "code déchiffrable" : Certains symboles sont préfixes d'autres, ce qui fait qu'on ne peut pas, sans concaténation (ou séquence d'échappement supplémentaire), faire une chaîne où un zéro suit immédiatement un \0...

Effectivement (ISO/IEC 9899:1999)...

Citation:

---

Envoyé par koala01

le '\0' (zero, et non O ;)) est utilisé pour représenter la fin d'une chaine de caractères C style...

Si tu demande l'affichage d'une telle chaine déclarée sous la forme de

Code:

---

1 2	char str[]="une chaine\0 coupee apres le deuxieme mot"; ptrintf("%s",str);

---

tu n'aura que l'affichage de "une chaine" ;)
(et si tu utilises les fonctions C propres aux chaines de caractères (strlen, strcmp, strcat, ...), "coupee apres le deuxieme mot" ne sera jamais pris en compte ;)
[EDIT]c'est d'ailleurs le moyen le plus simple de vider une chaine de caractères C style: placer un '\0' au premier caractère ( str[0] ) ;)

[EDIT 2] Le plus marrant de l'histoire, c'est que, le C++ se basant sur le standard C, on remarque assez facilement que la création d'une std::string utilisera également le '\0' comme délimiteur:

Code:

---

1 2 3 4 5 6 7 8 9 10

#include <iostream> #include <string> using namespace std; int main() { std::string str("une chaine\0 coupee apres le deuxieme mot"); cout<<str.size()<<" "<<str<<endl <<str[13];//devrait afficher 'o' return 0; }

---

affiche n'importe quoi, mais pas 'o' ;)

---

Oui bien sûr mais c'est pour tout cela qu'il ne me paraissait pas très évident qu'on puisse assimiler ce \0 à un \octal-digit et donc pas évident non plus que la norme prévoie l'existence de ce \0 qui n'est pas interprété comme un zéro... mais sans doute la norme est-elle à considérer ici comme purement syntaxique.