Discussion :

[oodini]

Hello,

J'ai un souci avec le code suivant, où le compilateur n'arrive pas à déduire le type T :

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
#include <iostream>
#include <vector>
#include <type_traits>
 
namespace data
{
	struct Foo {};
 
	template <typename T>
	void func(const std::vector<typename std::enable_if<std::is_pod<T>::value, T>::type>& contents)
	{
		std::cout << "Blah" << std::endl;
	}
}
 
int main()
{
	std::vector<data::Foo> vec;
	func(vec);
	return 0;
}

Vous pouvez le retrouver sur ideone.com.

Merci pour votre aide, et pour la discussion probablement intéressante que nous allons initier.

[ternel]

le compilateur ne peut déduire que les types "finaux".
dans typename enable_if<Bidule, T>::type, le type final est ::type, qui n'est pas forcément T, il peut y avoir une spécialisation.

A la louche, le compilateur ne peut pas déduire un type qui a besoin de typename.
C'est d'ailleurs parce que le compilateur aura du mal à travailler avec cette chose qu'on doit lui préciser que c'est un type.

Mais ton enable_if en type retour de la fonction, et ca ira mieux. (note, le ::type par défaut de enable_if est void, ca tombe bien)

Code :

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

1
2
3
template <typename T>
typename std::enable_if<std::is_pod<T>::value>::type
func(const std::vector<T>& contents)

[oodini]

Je ne peux pas.

J'ai fait un exemple simplifié pour le forum, mais en fait, la fonction est l'opérateur de flux operator<< :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template<typename T>
inline std::ostream& operator<<(std::ostream& out, const std::vector<typename std::enable_if<!std::is_pod<T>::value, T>::type>& contents)
{
	out.put(sizeof(T));
	size_t size = contents.size();
	out.write(reinterpret_cast<const char*>(&size), sizeof(size_t));
 
	for (const auto& spi : contents)
	    out << spi;
 
	return out;
}

Tu noteras que cette fonction doit être appelée quand le type n'est pas un POD (contrairement au premier exemple fourni).
Quand j'ai un POD, je serialise ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template<typename T>
inline std::ostream& operator<<(std::ostream& out, const std::vector<T>& contents)
{
    out.put(sizeof(T));
    size_t size = contents.size();
    out.write(reinterpret_cast<const char*>(&size), sizeof(size_t));
    out.write(reinterpret_cast<const char*>(contents.data()), contents.size()*sizeof(T));
    return out;
}

Dans le cas contraire, il faut être plus fin...

[ternel]

Et ceci ne fonctionnerait pas?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template<typename T>
inline
typename std::enable_if<!std::is_pod<T>::value, std::ostream&>::type
operator<<(std::ostream& out, const std::vector<T>& contents) { //code si non pod }
 
template<typename T>
inline
typename std::enable_if<std::is_pod<T>::value, std::ostream&>::type
operator<<(std::ostream& out, const std::vector<T>& contents) { //code si pod }

[oodini]

operator<< est supposé renvoyer std::ostream&, afin de pouvoir chaîner les appels.

[ternel]

Oui, c'est le principe de même enable_if: bloquer les instanciations qui ne respècte pas une condition. Son usage est de remplacer un type dans la définition d'une fonction (ou d'une classe)

enable_if<cond, T>::type est T si cond est vrai, non défini sinon.

Donc typename enable_if< std::is_pod<T>::value, std::ostream&>::type est std::ostream& si T est is_pod, et ne compile pas sinon
Grace à SFINAE, cette impossibilité de définir la template pour ce T précis n'est pas une erreur, si une autre template compile correctement.

Les deux templates de fonctions de mon message précédents définissent deux templates de surcharges de <<. Elles retournent toutes deux des std::ostream& car c'est le type "résultat" du enable_if.


enable_if se comporte comme suis:

Code :

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

1
2
3
4
5
template<bool B, class T = void>
struct enable_if {};
 
template<class T>
struct enable_if<true, T> { using type = T; };

[oodini]

Ah oui, excuse-moi ! Je n'avais pas vu l'usage du second paramètre template de enable_if, que je ne connaissais pas.

Je n'aurai pas le temps d'essayer ça aujourd'hui, mais je je vais essayer. Je te tiens au courant.

[oodini]

J'ai essayé ta solution, et j'ai le même souci... :-/

[oodini]

Voici la solution :

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
#include <iostream>
#include <vector>
#include <type_traits>
 
namespace data
{
	struct Foo {};
 
	template <typename T, typename U = typename std::enable_if<std::is_pod<T>::value>::type>
	void func(const std::vector<T>& contents)
	{
		std::cout << "Blah" << std::endl;
	}
}
 
int main()
{
	std::vector<data::Foo> vec;
	func(vec);
	return 0;
}

Selon si on met ou non un ! avant std::is_pod, cela compile ou pas.

Cela dit, je pense que ta solution est tout de même supposée fonctionner.
Je vais fouiller un peu plus...

[Invité]

Bonsoir,

Hormis dans certains cas, il y a trois solutions. Cf. Est-il possible de faire une spécialisation partielle d'une fonction ?