Discussion :

[damiengif]

Bonjour, je ne suis encore très à l'aise avec les templates, donc j'aurais besoin de vos lumières pour résoudre mon problème de compile.

Le but du jeu est de créer une fonction xorand qui prend deux tableaux (v1,v2) de type T et de taille N, et calcule le xor de tous les éléments de v1&v2. Sans "templatiser" le type des tableaux ça marchait bien, mais depuis que j'ai rajouté le typename T, rrien ne va plus.

Voici le code fautif :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template<typename T,int N> T inline xorand(T* v1, T* v2)
{
	return xorand<T,N/2>(v1, v2) ^ xorand<T,N-N/2>(v1+N/2, v2+N/2);
}
// Spécialisation pour N=1
template<typename T> T inline xorand<T,1>(T* v1, T* v2)
{
	return v1[0] & v2[0];
}

Merci.

[3DArchi]

Salut,
On ne peut pas faire de spécialisation partielle de fonction (de toute façon préférer la surcharge). Il vaut donc mieux passer par des structures :

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
template<int N>
struct xorand
{
template<typename T> T operator()(T* v1, T* v2)
{
	return xorand<N/2>()(v1, v2) ^ xorand<N-N/2>()(v1+N/2, v2+N/2);
}
};
// Spécialisation pour N=1
template<>
struct xorand<1>
{
template<typename T> T operator()(T* v1, T* v2)
{
	return v1[0] & v2[0];
}
};
 
 
int main()
{
    xorand<10>()((int*)0,(int*)0);
}

Edit : un petit tuto : La meta-programmation en C++

[germinolegrand]

Bonjour !
Je vais me permettre de corriger le code de 3DArchi qui m'a piqué les yeux à première vue :

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
 
template <class T, int N>
struct Xoa
{
	inline static T xorand(T* v1, T* v2)
	{
	    return Xoa<T,N/2>::xorand(v1, v2) ^ Xoa<T,N-N/2>::xorand(v1+N/2, v2+N/2);
	}
};
 
template <class T>
struct Xoa<T, 1>
{
	inline static T xorand(T* v1, T* v2)
	{
	    return v1[0] & v2[0];
	}
};
 
//fonction libre facultative, pour la simplicité d'utilisation
template <int N, class T>
inline T xorand(T* v1, T* v2)
{
    return Xoa<T,N>::xorand(v1,v2);
}
 
int main()
{
    std::cout << "Hello world!" <<std::endl;
 
    std::vector<unsigned int> v1, v2;
 
    Xoa<unsigned int,10>::xorand(v1.data(),v2.data());
    xorand<10>(v1.data(), v2.data());//version facultative mais qui ne demande pas de préciser le type
 
    //vector::data() est C++11, on peut remplacer par &v[0] en C++03
 
    return 0;
}

Lorsqu'on ajoute des classes juste pour utiliser leurs fonctions, il faut déclarer ces dernières statiques. Cela évite de construire un objet à chaque itération et permet au compilateur d'inliner tout le calcul.

Comme précisé dans le code, j'ai ajouté une fonction libre pour faciliter l'utilisation et surtout éviter de préciser T à l'appel. Celle-ci est facultative mais recommandée car elle ne coûte pas plus cher.

J'aurais tendance à éviter les operator() en programmation générique car cela obscurcit le code au possible.

[Kalith]

On peut aussi émuler la spécialisation d'une fonction grâce à la surcharge en introduisant un type intermédiaire. Un exemple :

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
#include <iostream>
 
// Structure intermediaire, n'est pas exposée à l'utilisateur
template<typename, int> struct xorand_dummy {};
// Version générale
template<int N, typename T> T inline xorand_(T* v1, T* v2, xorand_dummy<T,N>*)
{
	return xorand_(v1, v2, (xorand_dummy<T,N/2>*)0) ^ xorand_(v1+N/2, v2+N/2, (xorand_dummy<T,N-N/2>*)0);
}
// Spécialisation pour N=1
template<typename T> T inline xorand_(T* v1, T* v2, xorand_dummy<T,1>*)
{
	return v1[0] & v2[0];
}
// Fonction appelée par l'utilisateur
template<int N, typename T> T inline xorand(T* v1, T* v2)
{
	return xorand_(v1, v2, (xorand_dummy<T,N>*)0);
}
 
int main()
{
	int t1[6], t2[6];
	for (size_t i = 0; i < 6; ++i)
	{
		t1[i] = i; t2[i] = 3*i;
	}
 
	std::cout << xorand<6>(t1, t2) << std::endl;
	std::cout << xorand<1>(t1, t2) << std::endl;
 
	return 0;
}

C'est parfois plus clair que la méthode du foncteur. Au niveau performance, je ne sais pas ce qui sera le mieux. J'imagine que le compilateur ne doit pas avoir trop de mal à éliminer le superflu dans les deux cas, mais pour être sûr il faudrait faire un comparatif sur tes données.

[germinolegrand]

Par contre ça ne m'a vraiment pas l'air plus clair que la méthode statique... C'est plus long, plus complexe, moins optimisé...

[Kalith]

Tu es bien dur... Pour ce qui est de la taille du code, ça ne saute pas aux yeux, et pour les performances, je ne jugerai pas avant d'avoir vu une mesure sur des données réelles. Mais c'est plus complexe, oui.

Quoi qu'il en soit, je voulais surtout signaler qu'on peut faire autrement, et que "spécialisation partielle de fonction template" ne rime pas toujours avec "structure et méthodes statiques" (ou "foncteur"). Ici il faut rajouter un paramètre à la fonction pour pouvoir utiliser la surcharge, ça limite l'intérêt de la méthode je suis d'accord, mais il y a des cas où les paramètres essentiels à la fonction suffisent.

[germinolegrand]

Je suis d'accord qu'il y a plusieurs façons de faire
Pour les perfs, la seule différence une fois compilé entre ta version et la mienne c'est ce pointeur (qui restera en debug).

[Flob90]

La méthode de 3DArchi a quand même un avantage : c'est un foncteur polymorphique (à N fixé) qui fonctionnera avec n'importe quel bibliothèque utilisant cette notion.