Discussion :

[yoloosis]

Hello tout le monde,

Comment definir une expression reguliere qui pourra etre appliquee a tous types de string ? L'exemple suivant affiche "Matched" si la chaine passee est "abc" :

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
 
#include <string>
#include <iostream>
using namespace std;
 
#include <boost/regex.hpp>
using namespace boost;
 
 
template <typename StrT>
struct my_parser
{
        bool match( const StrT& ) const;
};
 
 
template <typename StrT>
bool my_parser<StrT>::match( const StrT& a_str ) const
{
        match_results<typename StrT::const_iterator> m;
        basic_regex<typename StrT::value_type> r( "abc" );
        regex_match( a_str, m, r );
}
 
 
int main()
{
        my_parser<string> p;
        string s = "abc";
 
        //my_parser<wstring> p;
        //wstring s = L"abc";
 
        if ( p.match( s ) )
        {
                cout << "Matched" << endl;
        }
        return 0;
};

Cet exemple fonctionne dans le cas ou le basic_regex est instancie avec une std::string. Cependant, il y a erreur a la compilation lorsqu'on veut utiliser une std::wstring : dans ce cas, la ligne qui definit le basic_regex devrait etre

Code :

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

1
2
 
basic_regex<typename StrT::value_type> r( L"abc" );

Notez bien le L devant la chaine "abc" : c'est une wstring.

J'aimerai rendre ce code generique compatible avec d'autres chaines, comme les QString de Qt par exemple : quelle methode vous semble la plus appropriee ?

Merci beaucoup !

[IrmatDen]

Salut,

J'aimerai rendre ce code generique compatible avec d'autres chaines, comme les QString de Qt par exemple : quelle methode vous semble la plus appropriee ?

Il faudra y aller au cas par cas je suppose. Pour les QString par exemple, tu peux fournir une spécialisation de ton template, qui appelle ta fonction match générique après avoir appelé la fonction QString::toStdWString() par exemple.

Code :

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

1
2
3
4
5
6
7
8
template <>
struct my_parser<QString>
{
        bool match(const QString &str) const
        {
                return my_parser<std::wstring>().match(str.toStdWString());
        }
};

Je dis peut-être une bêtise, je suis pas un gourou du générique hein

[JolyLoic]

Pour ce genre de choses, je n'ai pas trouvé mieux que d'avoir une fonction de conversion de string en string template (nommée string_cast, par exemple), définie une bonne fois pour toute (et qui sert à d'autres choses aussi) avec toutes les surcharges qui vont bien, puis d'appeler :

Code :

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

1
2
3
4
5
 
template <class Dest, class Src>
Dest string_cast(Src const &src);
 
basic_regex<typename StrT::value_type> r( string_cast<StrT>(L"abc") );

Le problème étant qu'on se retrouve à faire au run-time une conversion de chaîne qu'on aurait pu éviter.

[yoloosis]

La fonction de conversion... C'est probablement la solution là plus simple à implémenter. D'autres idées ?