Discussion :

[techz]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 .

[3DArchi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[techz]

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 ....

[Arzar]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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 \ :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[wakan]

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[3DArchi]

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

Effectivement. Des fois, on s'emballe

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.

[koala01]

Salut,

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ... (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

[ptyxs]

On peut avoir quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#include <string>
 
int main()
{
    std::string chaine = "ABCD\AABAA";
 
}

[koala01]

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 '\\'

[ptyxs]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[koala01]

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

[3DArchi]

Un petit rappel de norme :

Code text :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[ptyxs]

Merci 3dArchi, voilà qui clarifie.

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

[Médinoc]

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

[3DArchi]

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

octal-escape-sequence:
\ octal-digit

Ca suffit, non ?

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

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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'

[Médinoc]

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...

[3DArchi]

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

[ptyxs]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.