Discussion :

[backlash]

Bonjour,

J'ai écris une fonction

Code :

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

1
2
template< typename Functor >
    void preprocess ( string& str , Functor cond )

qui a pour role d'enlever un caractère prédéfini encapsulé dans l'objet cond de la chaine de caractère str.

Exemple de fonctionnement attendu si le caractère à enlever est 'c' :

str = "cccccciiiiiiiiiccccccccccccccooooooccccccccccpppppp"

après appel à la fonction preprocess str devient :

str = "iiiiiiiiioooooopppppp"

Cependant le programme fonctionne mal c'est à dire qu'il n'enlève pas tous les caractères correspondant dans la chaine str, par moment il plante. Le débugger m'indique que la pile d'appel est dans l'état suivante après la réception de SIGSEV :

#0 77179F40 msvcrt!memmove() (C:\windows\system32\msvcrt.dll??)
#1 00000000 0x0044a8b5 in std::string::_M_mutate() (????)
#2 00000000 0x004495b8 in std::string::erase() (????)
#3 0041CD3F Parser::preprocess<Parser::IsCaracter<(char)99> >(str=@0x22ff0c, cond={<No data fields>})
#4 00401672 main(argc=1, argv=0x7a1008)

Mon code est le suivant :

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
#include <string>
 
using namespace std;
 
namespace Parser
{
    template< char caracter >
    struct IsCaracter
    {
        bool operator() ( char c ){ return c == caracter; }
    };
 
    template< typename Functor >
    void preprocess ( string& str , Functor cond )
    {
        for ( string :: iterator it = str.begin () ; it != str.end () ; it++ )
            if ( cond ( *it ) )
                str.erase ( it );
    }
}
 
int main(int argc, char *argv[])
{
    string s;
 
    while ( true )
    {
        getline ( cin , s );
        Parser :: preprocess ( s , Parser :: IsCaracter< 'c' > () );
        cout << s << endl;
    }
 
    return 0;
}

Merci d'avance de votre aide.

[3DArchi]

Salut,

erase peut invalider les itérateurs. Il ne faut donc pas les garder sur la boucle après l'effacement :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
        while (it != str.end ())
        {
            if ( cond ( *it ) )
            {
               it = str.erase ( it );
            }
            else
            {
               ++it;
            }
        }

P.S. : même s'il n'y a qu'une ligne, je te conseille de prendre le réflexe de toujours mettre des accolades après un if/for/while. Cela améliore la lecture du code et évite de nombreux bugs. C'est souvent une règle de codage imposée.

[backlash]

Merci, le code fonctionne.

[Emmanuel Deloget]

Bonjour,

J'ai écris une fonction

Code :

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

1
2
template< typename Functor >
    void preprocess ( string& str , Functor cond )

qui a pour role d'enlever un caractère prédéfini encapsulé dans l'objet cond de la chaine de caractère str.

Exemple de fonctionnement attendu si le caractère à enlever est 'c' :

str = "cccccciiiiiiiiiccccccccccccccooooooccccccccccpppppp"

après appel à la fonction preprocess str devient :

str = "iiiiiiiiioooooopppppp"

Cependant le programme fonctionne mal c'est à dire qu'il n'enlève pas tous les caractères correspondant dans la chaine str, par moment il plante. Le débugger m'indique que la pile d'appel est dans l'état suivante après la réception de SIGSEV :

#0 77179F40 msvcrt!memmove() (C:\windows\system32\msvcrt.dll??)
#1 00000000 0x0044a8b5 in std::string::_M_mutate() (????)
#2 00000000 0x004495b8 in std::string::erase() (????)
#3 0041CD3F Parser::preprocess<Parser::IsCaracter<(char)99> >(str=@0x22ff0c, cond={<No data fields>})
#4 00401672 main(argc=1, argv=0x7a1008)

Mon code est le suivant :

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
#include <string>
 
using namespace std;
 
namespace Parser
{
    template< char caracter >
    struct IsCaracter
    {
        bool operator() ( char c ){ return c == caracter; }
    };
 
    template< typename Functor >
    void preprocess ( string& str , Functor cond )
    {
        for ( string :: iterator it = str.begin () ; it != str.end () ; it++ )
            if ( cond ( *it ) )
                str.erase ( it );
    }
}
 
int main(int argc, char *argv[])
{
    string s;
 
    while ( true )
    {
        getline ( cin , s );
        Parser :: preprocess ( s , Parser :: IsCaracter< 'c' > () );
        cout << s << endl;
    }
 
    return 0;
}

Merci d'avance de votre aide.

Et...

Code :

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

1
2
3
4
5
6
 
#include <string>
#include <algorithm>
...
s.erase(std::remove(s.begin(), s.end(), 'c'), s.end()). 
...

Qui a l'avantage d'avoir été debuggé pour toi par des tas de gens très efficaces

A propos, on ne fait jamais i++ sur un itérateur : on fait ++i ; la sémantique n'est pas la même, et on s'évite une copie de contenu inutile.

[3DArchi]

Et...

Code :

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

1
2
3
4
5
6
 
#include <string>
#include <algorithm>
...
s.erase(std::remove(s.begin(), s.end(), 'c'), s.end()). 
...

Qui a l'avantage d'avoir été debuggé pour toi par des tas de gens très efficaces .

+1. Et avec std::remove_if si le prédicat est un peu plus compliqué que juste une comparaison de caractère.

[backlash]

En effet

[oodini]

Pourrais-tu nous dire pourquoi tu as choisi de faire d'IsCharacter un foncteur templatisé plutôt qu'une bête fonction ?

[Emmanuel Deloget]

Pourrais-tu nous dire pourquoi tu as choisi de faire d'IsCharacter un foncteur templatisé plutôt qu'une bête fonction ?

La je peux répondre à sa place : l'appel à la fonction ne sera pas inlinée, et appeler une fonction pour chaque char dans ce contexte, ce n'est pas très efficace

[oodini]

Et l'utilisation d'une structure se justifie par le fait qu'on ne peut ne peut templatiser une méthode de classe dans ce contexte ?

Je crois me souvenir qu'il y a une une contrainte avec les templates et les méthodes de classe, mais je ne me souviens plus des détails...

[Emmanuel Deloget]

Et l'utilisation d'une structure se justifie par le fait qu'on ne peut ne peut templatiser une méthode de classe dans ce contexte ?

J'ai du mal à saisir. Tu peux préciser stp ?

[3DArchi]

On peut templatiser tout ce que l'on veut (sauf les fonctions virtuelles). La seule incompatibilité est que l'opérateur() ne peut pas être une méthode de classe (static). Du coup, comme Emmanuel, je ne suis pas sur d'avoir compris ta question.

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
 
template< char caracter >
struct IsCaracter
{
    bool operator() ( char c )const{ return c == caracter; }
};
 
struct IsCaracterNonTpl
{
    template< char caracter >
    static bool IsCaracter( char c ){ return c == caracter; }
};
 
struct IsCaracterState
{
    IsCaracterState(char c):caracter(c){}
 
    bool operator() ( char c )const{ return c == caracter; }
 
    const char caracter;
};
 
 
struct IsCaracterTplop
{
 
    template<char caracter>
    bool operator() ( char c )const{ return c == caracter; }
};
 
struct IsCaracterBase
{
 
    virtual bool operator() ( char c )const=0;
};
template<char caracter>
struct IsCaracterDerive : IsCaracterBase
{
 
    virtual bool operator() ( char c )const{ return c == caracter; }
};
 
 
//template< char caracter >
//struct IsCaracterError
//{
//    static bool operator() ( char c ); //interdit : l'opérateur () ne peut être statique - pas de rapport avec générique
//};
//
//struct IsCaracterNonTplError
//{
//    template< char caracter >
//    static bool IsCaracter( char c );//interdit : l'opérateur () ne peut être statique - pas de rapport avec générique
//};
//
//struct IsCaracterStateError
//{
//    static bool operator() ( char c )//interdit : l'opérateur () ne peut être statique - pas de rapport avec générique
//
//    static const char caracter = 'x';
//};
 
template<char caracter>
bool IsCaracterFn(char c)
{
    return c==caracter;
}
 
bool IsCaracterFn(char caracter, char c)
{
    return c==caracter;
}
 
int main()
{
    std::string s("azerty1234567890");
    s.erase(std::remove_if(s.begin(), s.end(), IsCaracter<'a'>()), s.end());
    s.erase(std::remove_if(s.begin(), s.end(), IsCaracterNonTpl::IsCaracter<'z'>), s.end());
    s.erase(std::remove_if(s.begin(), s.end(), IsCaracterFn<'e'>), s.end());
    s.erase(std::remove_if(s.begin(), s.end(), std::bind1st(std::ptr_fun(IsCaracterFn),'r')), s.end());
    s.erase(std::remove_if(s.begin(), s.end(), IsCaracterState('t')), s.end());
    s.erase(std::remove_if(s.begin(), s.end(), std::bind1st(std::mem_fun_ref(&IsCaracterTplop::operator()<'y'>),IsCaracterTplop())), s.end());
    std::cout<<s<<"\n";
 
    return 0;
}

[oodini]

On peut templatiser tout ce que l'on veut (sauf les fonctions virtuelles). La seule incompatibilité est que l'opérateur() ne peut pas être une méthode de classe (static). Du coup, comme Emmanuel, je ne suis pas sur d'avoir compris ta question.

Normal, elle était vague. :-)
J'ai simplement le très vague souvenir qu'il pouvait y avoir des problèmes avec les méthodes templates de classe non template. Mais je peux me tromper, et ça peut être quelque chose qui n'est que vaguement approchant. Si ça vous inspire quelque chose, tant mieux, sinon, tant pis. :-)