Discussion :

[ToTo13]

Bonjour,

je souhaite limiter le type de mes template à des int ou des unsigned int. En gros je souhaiterai que tout ce qui est float/double ne soit pas implémenté.
J'ai trouve cette TRES vieille discussion et bien d'autre du même type sur le net, mais toute très vieilles.
Mais C++ évolue constamment.
Est ce que ce que je souhaite faire n'est toujours pas possible ?

Merci par avance.

[Ehonn]

Bonjour

C'est possible et très simple à partir de C++11 en utilisant static_assert.

Tu peux limiter à int et unsigned int avec std::is_same<T1, T2>::value mais il est probable que si ton code fonctionne pour int et unsigned int, il fonctionnera pour tout ce qui se comporte comme un entier signé ou pas. Dans ce cas, tu peux utiliser std::numeric_limits<T>::is_integer

Voici un petit exemple qui illustre tout ça :

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
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
#include <type_traits>
#include <limits>
 
template <class T>
class int_or_uint
{
	static_assert(std::is_same<T, int>::value || std::is_same<T, unsigned int>::value, "int_or_uint<T>: error: T is not int or unsigned int");
};
 
template <class T>
class any_integer
{
	static_assert(std::numeric_limits<T>::is_integer, "any_integer<T>: error: T is not an integer");
};
 
int main ()
{
	int_or_uint<int> a;
	int_or_uint<unsigned int> b;
	//int_or_uint<float> c; // error: static assertion failed: int_or_uint<T>: error: T is not int or unsigned int
 
	any_integer<long int> d;
	any_integer<char> e;
	//any_integer<double> f; // error: static assertion failed: any_integer<T>: error: T is not an integer
 
	return 0;
}

Note : Dans le futur de C++ (C++17 par exemple), on aura la notion de concept qui permettra de limiter non pas à une caractéristique particulière (l'opérateur + existe, le constructeur par défaut existe ? ...) mais à un ensemble des caractéristiques qui ont un sens (est-ce un container ? ...).

[ToTo13]

Super !!!
Merci infiniment.

[ToTo13]

En faisant des recherches sur static_assert, j'ai lu que souvent le flag utilisé est -std=c++0x
Quel est l'avantage de l'un par rapport à l'autre?

[Bousk]

c'est l'ancien nom et flag du C++11

[Ehonn]

Avant la sortie définitive de la norme en C++11, on parlait de C++0x, le x devait être remplacé par l'année de sortie de la norme. Comme celle ci n'est pas sortie avant 2010 (et que la notation n'est pas en l’hexadécimal), c'est devenu C++11 (en hexadécimal, on aurait eu C++0B)).
Donc, sur les "vieux" compilateurs (avant 2011), on passait l'option -std=c++0x pour profiter de la future norme (de 2011). Maintenant on utilise -std=c++11 ou -std=c++14 (-std=c++1y sur certains compilateurs avant 2014) ou même -std=c++1z pour profiter des fonctionnalités prévues pour 2017.

[koala01]

Salut,

Il faut aussi noter que l'on trouve quelques traits géniaux, depuis C++11, dans le fichier d'en-tête <type_traits>... Quelques élément choisis (à vous de deviner le sens ) "pas vraiment par hasard"

• std::is_floating_point
• std::is_integer
• std::is_signed
• std::is_unsigned
• std::is_float
• std::is_double
• std::enable_if // plus difficile à manipuler, celui là ;)

Avec ces quelques traits (et surtout le dernier) il est tout à fait possible de faire en sorte qu'une fonction ne soit disponible que pour un type parfaitement défini, par exemple... Mais il y en a d'autres