Discussion :

[camboui]

J'hésite entre deux écritures pour un même résultat:

Code :

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

1
2
template<typename C, typename Tr, typename Al>
void all_trim(std::basic_string<C, Tr, Al> & s, C const *cs)

Code :

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

1
2
template<typename S>
void all_trim(S & s, S::value_type const *cs)

Jusqu'à présent j'avais tendance à utiliser la première écriture pour mes petites fonctions de manipulations de (w)string, mais je suis en train de revoir ma copie pour utiliser la deuxième. C'est plus court et plus simple finalement.
Et ça me permet d'écrire ceci par exemple:

Code :

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

1
2
3
4
5
6
7
template<typename S>
S trim(S && s, S::value_type const *cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

Des avis ?
Merci.

[Bousk]

Si tu ne comptes utiliser que des std::(w)string, autant aller au plus simple à écrire et comprendre imo.

[camboui]

Je croyais tout bon, et puis patatras, ceci ne compile pas:

Code :

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

1
2
3
4
5
6
7
template<typename S>
S trim(S && s, S::value_type const *cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

Visual Studio 2015 me donne ces erreurs:
error C2672: 'trim': no matching overloaded function found_
error C2893: Failed to specialize function template 'S trim(S &&,const S::value_type *)'_

Je dois faire comme ceci

Code :

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

1
2
3
4
5
6
7
template<typename S, typename C>
S trim(S && s, C const *cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

Mais je ne comprends pas trop pourquoi... (bien que ça ne me dérange pas, mais comprendre c'est toujours bon )

[koala01]

Salut,

Comme tu utilises std::wstring et std::string, tu fournis en réalité une spécialisation de std::basic_string. Si bien que S::value_type n'est en réalité que le typedef que l'on trouve dans std::basic_string qui correspond au type de caractères à utiliser.

Or, ce typedef est dépendant de la spécialisation de std::basic_string que tu utilise (et qui te sert de paramètre template), tu devrais donc -- si je ne m'abuse -- clairement spécifier qu'il est dépéndant du paramètre template, sous une forme (non testée) qui serait proche de

Code :

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

1
2
3
4
5
6
7
template<typename S>
S trim(S && s, typename S::value_type const *cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

(d'ailleurs il y a peut-etre bien un typedef plus intéressant à utiliser comme const_pointer)

Une autre solution pourrait être (histoire de t'assurer que C fait bien partie de la spécialisation de std::basic_string représentée par S) de fournir une valeur par défaut pour C, sous la forme de (toujours non testé)

Code :

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

1
2
3
4
5
6
7
template<typename S, typename C= typename S::value_type> //  je préférerais vraiment const_pointer à value_type
S trim(S && s, C const *cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

[JolyLoic]

Je préfère ta seconde écriture, en plus d'être plus simple, elle fonctionnera avec plus de types semblables à des strings que std::basic_string. La première n'a d'intérêt à mon sens que si tu veux jouer avec les paramètres, par exemple convertir ta std::basic_string<C, Tr, Al> en std::basic_string<C, AnotherCharTrait, Al>.

[camboui]

Merci pour vos réponses !
J'y vois un peu plus clair

Après d'autres petits tests, la présence ou non du mot clé typename ne change rien, la même erreur de compilation survient.
C'est la présence de l'opérateur && qui semble perturber le compilateur.

Je reprends ici le code (adapté à juste titre comme proposé par koala01)

Code :

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

1
2
3
4
5
6
7
template<typename S>
inline S trim(S && s, typename S::const_pointer cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

Ce code n'est accepté que si le paramètre "s" est une rvalue.

Code :

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

1
2
3
4
5
6
7
template<typename S, typename Cptr = typename S::const_pointer>
inline S trim(S && s, Cptr cs)
{
	S ms(std::forward<S>(s));
	all_trim(ms, cs);
	return ms;
}

Celui-ci semble toujours être accepté, lvalue ou rvalue pour le paramètre "s".

Moi qui croyais avoir tout compris, voici une petite zone d'ombre (pas bien grave ).