Discussion :

[Aleph69]

Bonjour,

j'aimerais savoir s'il y a une différence de performance entre ces prototypages pour une seule et même tache :

Code :

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

1
2
3
void fun(size_t);
void fun(size_t const);
void fun(size_t const&)

Je crois me souvenir avoir lu dans le livre d'Alexandrescu que la deuxième solution est plus efficace que la troisième mais je ne vois pas vraiment pourquoi.

J'ai une deuxième question connexe concernant les fonctions templates :

Code :

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

template<typename T> void fun(T const&);

Dans le cas où T peut aussi bien être un type simple qu'un objet, quelle solution préconisez-vous pour forcer les types simples à ne pas être passés par référence mais par valeur?

Merci d'avance pour votre aide et vos conseils!

[Nhaps]

Dans le cas où T peut aussi bien être un type simple qu'un objet, quelle solution préconisez-vous pour forcer les types simples à ne pas être passés par référence mais par valeur?

Bonjour,

Pourquoi ne pas passer les types simples par référence ?

EDIT : sinon j'aurai dit pour ta première question que la 3eme solution est la meilleur car on m'a toujours dit par exemple pour un setteur que le prototype soit comme ta 3eme solution évitant ainsi une duplication en mémoire de ce que tu passe en paramètre.

[Aleph69]

A cause de ce qui est dit plus haut : dans le cas particulier des types simples, j'ai cru comprendre qu'il valait mieux passer par valeur que par référence. Mais je me trompe peut-être.

[dragonjoker59]

Pour avoir un passage de paramètre optimal, tu peux utiliser ceci :

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
//! Struct used to select best way to put type in parameter : 'value' or 'const reference'
template <typename T>
struct CallTraits
{
	template <typename U, bool Big> struct CallTraitsImpl;
	//! Struct used to select 'const reference' parameter type
	template <typename U>
	struct CallTraitsImpl<U, true>
	{
		typedef const U & Type;
	};
	//! Struct used to select 'value' parameter type
	template <typename U>
	struct CallTraitsImpl<U, false>
	{
		typedef U Type;
	};
	typedef typename CallTraitsImpl<T, (sizeof( T) > 8)>::Type ParamType;
};

Du coup, dans ta fonction, ça donnerait ceci :

Code :

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

void fun(CallTraits<size_t>::ParamType p_param)

[Aleph69]

Merci pour cette solution élégante. Je pense même qu'il est possible de cacher le booléen aux utilisateurs en passant par une autre classe de trait déterminant si un type donné est simple ou pas.

J'ai quelques questions par rapport à cette solution :

1. le test sizeof( T) > 8 est-il pérenne?
2. je vois que les types simples sont passés par valeur non constante : pourquoi?

[dragonjoker59]

Cette solution tient uniquement compte de la taille.
Je pense que c'est la question la plus importante lors du passage d'un paramètre, la copie est à mes yeux négligeable pour une taille <= 8. Au-dessus aussi, dans une certaine limite, mais 8 est une limite qui permet à tous les types basiques de passer.

EDIT : A la question de la pérennité du sizeof( T) > 8, je dirais oui, jusqu'à ce qu'on passe à des processeurs 128 bits.