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

[Invit�]

Bonjour,

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

Il est toujours accept� car le param�tre template Cptr est d�duit � partir du type du param�tre que tu rentres et non du type par d�faut que tu lui donnes, retirer = typename S::const_pointer n'y changerait rien.

Tu as trouv� le pourquoi dans le lien que tu donnes : lorsque tu passes une lvalue, S comporte �galement la r�f�rence. Et pour aller plus loin, rends-toi compte que S ms ainsi que le retour de ta fonction trim() sont de fait �galement des r�f�rences de ton entr�e, qui se voit ainsi modifi�e. Je ne suis pas certain que ce soit r�ellement ce que tu souhaites.

Dans tous les cas std::remove_reference � la rescousse

[camboui]

Oufti
Mon dieu, la grosse bourde
Heureusement que tu passais par ici, toi

Voici donc le "bon" code

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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

Test� et... je vous laisse le soin d'approuver.

[Invit�]

Aurais-je oubli� de mentionner que les cv-qualifiers �taient �galement conserv�s ?
Ex. : que se passe-t-il si tu passes std::string const str en param�tre ?

Petit tableau r�capitulatif :

Code : S�lectionner tout - Visualiser dans une fen�tre � part 1 2 3 4 int x = 22; int & rx = x; int const cx = x; int const & rcx = x;	Code : S�lectionner tout - Visualiser dans une fen�tre � part 1 2 template <typename T> void f(T && param);
f(x);	T ≡ int &. param est de type int &
f(rx);	T ≡ int &. param est de type int &
f(cx);	T ≡ int const &. param est de type int const &
f(rcx);	T ≡ int const &. param est de type int const &
f(22);	T ≡ int. param est de type int &&

[Bousk]

Pourquoi utiliser && ici ?
je ne comprends pas l'utilit�, si on doit utiliser remove reference et travailler sur une copie, pourquoi ne pas simplement passer un const& ou une copie directement ?

[camboui]

On travaille sur une copie si le param�tre est une lvalue.
Si le param�tre est une rvalue, on travaille sur celle-ci directement. C'est d'ailleurs pour �a que j'ai mis le std::forward (sans lui le passage du param�tre via && ne sert effectivement plus � rien).

[jo_link_noir]

En cr�ant ms, tu travaille toujours sur une copie.

[camboui]

Non.

Voici un code pour le prouver (la fonction template test_moved_param(S && s, char const *val) est semblable � la fonction template trim(S && s, typename std::remove_reference_t<S>::const_pointer cs) pr�c�dante).

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
class full_object
{
	std::string last_call;
	std::string m_value;
public:
	full_object() : last_call("Default constructor"),
		m_value()
		{ display(); }
	full_object(const full_object & fo) : last_call("Copy constructor"),
		m_value(fo.m_value)
		{ display(); }
	full_object(full_object && fo) : last_call("Move constructor"),
		m_value(std::move(fo.m_value))
		{ display(); }
	full_object & operator=(const full_object & fo)
	{
		last_call = "Copy assignment operator";
		m_value = fo.m_value;
		display();
		return *this;
	}
	full_object & operator=(full_object && fo)
	{
		last_call = "Move assignment operator";
		m_value = std::move(fo.m_value);
		display();
		return *this;
	}
	virtual ~full_object()
	{
		last_call = "Destructor";
		display();
	}
 
	full_object & assign(char const *val)
		{ m_value = val; return *this; }
	full_object & append(char const *val)
		{ m_value += val; return *this; }
	full_object & assign(const full_object & fo)
		{ m_value = fo.m_value; return *this; }
	full_object & append(const full_object & fo)
		{ m_value += fo.m_value; return *this; }
	void display()
		{ std::cout << get() << std::endl; }
	std::string get()
		{ return last_call + " - value=" + m_value; }
};
 
full_object operator+(const full_object & lfo, const full_object & rfo)
{
	full_object tfo;
	tfo.assign(lfo);
	tfo.append(rfo);
	return tfo;
}
 
template<typename S>
inline std::remove_reference_t<S>
	test_moved_param(S && s, char const *val)
{
	std::remove_reference_t<S> ms(std::forward<S>(s));
	ms.assign(val);
	return ms;
}
 
int main()
{
	full_object fo1;
	std::cout << ".\t" << fo1.get() << std::endl;
	fo1.assign("fo1");
	std::cout << ".\t" << fo1.get() << std::endl;
	full_object fo2 = test_moved_param(fo1, "fo1, lvalue");
	std::cout << ".\t" << fo2.get() << std::endl;
	full_object fo3 = test_moved_param(fo1.append("/").append(fo2), "fo1.append(\"/\").append(f02), lvalue");
	std::cout << ".\t" << fo3.get() << std::endl;
	full_object fo4 = test_moved_param(fo2.append("|") + fo3, "fo2+fo3, rvalue");
	std::cout << ".\t" << fo4.get() << std::endl;
}

Et voici l'output:

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
Default constructor - value=
.       Default constructor - value=
.       Default constructor - value=fo1
Copy constructor - value=fo1
Move constructor - value=fo1, lvalue
Destructor - value=
.       Move constructor - value=fo1, lvalue
Copy constructor - value=fo1/fo1, lvalue
Move constructor - value=fo1.append("/").append(f02), lvalue
Destructor - value=
.       Move constructor - value=fo1.append("/").append(f02), lvalue
Default constructor - value=
Move constructor - value=fo1, lvalue|fo1.append("/").append(f02), lvalue
Destructor - value=
Move constructor - value=fo1, lvalue|fo1.append("/").append(f02), lvalue
Move constructor - value=fo2+fo3, rvalue
Destructor - value=
Destructor - value=
.       Move constructor - value=fo2+fo3, rvalue
Destructor - value=fo2+fo3, rvalue
Destructor - value=fo1.append("/").append(f02), lvalue
Destructor - value=fo1, lvalue|
Destructor - value=fo1/fo1, lvalue

En gras et en couleur l'affichage lorsque le code std::remove_reference_t<S> ms(std::forward<S>(s)); est execut�.
En vert on s'attend � une lvalue et c'est bien le Copy Construtor qui est appel�.
En rouge on s'attend � une rvalue et c'est bien le Move Construtor qui est appel�.
On voit donc bien que les rvalue ne sont pas copi�es et restent des rvalue.

[jo_link_noir]

Ici, il faut prendre le "une copie", comme "une autre instance". Ton message pr�c�dent sous-entend que si le param�tre est une rvalue, le param�tre est utilis� directement, or non, il y a cr�ation d'une nouvelle instance, d'o� le "une copie" qui est ici ambigu.

Ce que dit @Bousk et que si tu utilises toujours une nouvelle instance, autant prendre un type plein en param�tre (= un type sans r�f�rence). Ainsi, il n'y a plus besoin de cr�er une nouvelle instance et tu simplifies le code.
Et tu profites �galement de la copie �lision, ce qui veut dire que pour auto s = trim("abc"s); et avec la RVO (une sorte de copie �lision pour le retour de fonction), il y un constructeur avec une cha�ne, 0 constructeur de copie, 0 constructeur de d�placement, contrairement � la version avec std::forward qui utilise un constructeur de d�placement.

[Bousk]

Merci jo, je pensais devenir fou.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
trim(S && s, typename std::remove_reference_t<S>::const_pointer cs)
{
	std::remove_reference_t<S> ms(std::forward<S>(s));

est exactement similaire �

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
trim(S ms, typename S::const_pointer cs)
{

si ma sant� mentale n'est pas encore d�faillante.

edit: bien vu, je l'avais loup�

[jo_link_noir]

On peut m�me �jecter std::remove_reference.

[camboui]

Vous avez raison.
A force de vouloir caser ce foutu && j'en oublie de faire simple pour faire compliqu�.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
template<typename S>
inline S test_moved_param(S ms, char const *val)
{
	ms.assign(val);
	return ms;
}

R�sultat:

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
Default constructor - value=
.       Default constructor - value=
.       Default constructor - value=fo1
Copy constructor - value=fo1
Move constructor - value=fo1, lvalue
Destructor - value=
.       Move constructor - value=fo1, lvalue
Copy constructor - value=fo1/fo1, lvalue
Move constructor - value=fo1.append("/").append(f02), lvalue
Destructor - value=
.       Move constructor - value=fo1.append("/").append(f02), lvalue
Default constructor - value=
Move constructor - value=fo1, lvalue|fo1.append("/").append(f02), lvalue
Destructor - value=
Move constructor - value=fo2+fo3, rvalue
Destructor - value=
.       Move constructor - value=fo2+fo3, rvalue
Destructor - value=fo2+fo3, rvalue
Destructor - value=fo1.append("/").append(f02), lvalue
Destructor - value=fo1, lvalue|
Destructor - value=fo1/fo1, lvalue

Je vais un faire un peu de "C" avec de z'olis pointeurs pour me changer les id�es