Template Int<bits>, votre avis?

**MatRem** · 16/07/2007, 11h05

Bonjour,

je viens d'écrire une petite classe pour gérer les types d'entiers par taille :

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
#include <iostream>
 
template<bool b, typename T1, typename T2>
class If
{
public:
	typedef T1 Res;
};
 
template<typename T1, typename T2>
class If<false, T1, T2>
{
public:
	typedef T2 Res;
};
 
template<int bits>
class Int
{
public:
	typedef
		typename If<
			(sizeof(short)==bits/8),
			short,
			typename If<
				(sizeof(int)==bits/8),
				int,
				typename If<
					(sizeof(long)==bits/8),
					long,
					void
				>::Res
			>::Res
		>::Res
	T;
};
 
typedef Int<16>::T Int16;
typedef Int<32>::T Int32;
typedef Int<64>::T Int64;
 
int main()
{
	Int32 i = 10;
	std::cout<<i<<std::endl;
}

J'aimerais savoir, si il y a des erreurs de conception (je débute dans les templates), et si c'est une solution viable pour définir ces types d'entier?

**Médinoc** · 16/07/2007, 11h09

Bonjour,
Pour commencer, tu devrais régler le problèmes des arrondis, si tu comptes pouvoir accepter des tailles autres que 8, 16, 32, 64. Pour l'instant, la taille est arrondie à 8 bits près par défaut, je pense qu'elle devrait l'être par excès.
..Et aussi, pour l'instant tu n'acceptes que l'égalité. Il te faudra faire des comparaisons d'infériorité/supériorité si tu veux supporter plus d'un set fixe de tailles.

PS: Tu n'as pas le type long long. Sous un système 64 bits tel que Win64, les long font toujours 32bits...

**Laurent Gomila** · 16/07/2007, 11h14

C'est une solution qui fonctionne, mais en pratique on l'utilise peu car ça risque de rallonger considérablement les temps de compilation (surtout que ce genre de code est typiquement destiné à être inclus dans tous les fichiers sources du projet).

Ton implémentation manque un peu de flexibilité, tu pourrais par exemple utiliser les listes de types (typelists) pour faire quelque chose de plus sympa.
Ca pourrait donner ce genre de code :

Code :

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

1
2
3
4
5
6
7
typedef TYPELIST(char, short, int, long, long long) SignedTypes;
typedef TYPELIST(unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long) UnsignedTypes;
typedef TYPELIST(float, double, long double) FloatTypes;
 
typedef Int<SignedTypes,   8>::T Int8;
typedef Int<UnsignedTypes, 8>::T Uint8;
typedef Int<FloatTypes,   32>::T Float32; // du coup le nom Int serait à changer

**MatRem** · 16/07/2007, 11h24

Envoyé par Médinoc

Pour l'instant, la taille est arrondie à 8 bits près par défaut, je pense qu'elle devrait l'être par excès

En fait j'aurais voulu que Int<18> par exemple soit impossible...
Que seul les types short, int, long, et donc long long soit acceptable.

Par contre gcc me dit que les long long ne font pas partis du c++ standard...

A tient les TypeList je connaissais pas... C'est vrai que pour l'instant ce que j'ai fait, est assez limité.

Donc en pratique on utilise plutôt des #define?

**Laurent Gomila** · 16/07/2007, 11h37

En fait j'aurais voulu que Int<18> par exemple soit impossible...

Il suffit de caser un petit template qui te génère une erreur de compilation si tu lui passes une condition qui n'est pas vérifiée, et lui passer (bits % 8) == 0 par exemple.

A tient les TypeList je connaissais pas...

Tu en as une bonne description dans le livre Modern C++ Design, et donc une implémentation dans la bibliothèque Loki. A mon avis tu peux aussi trouver de bons articles en ligne en recherchant "typelist".

Donc en pratique on utilise plutôt des #define?

Non toujours des typedef, mais avec des tests plus classiques. Par exemple on peut tester si l'en-tête (pas encore standard ?) <cstdint> est présent et aller chercher dedans, ou bien tester les valeurs max des types définies dans <climits>, etc...

**Médinoc** · 16/07/2007, 11h59

Envoyé par MatRem

Par contre gcc me dit que les long long ne font pas partis du c++ standard...

QUEL standard ? C89 ? C90 ?
Ou C99 ?

**MatRem** · 16/07/2007, 12h32

QUEL standard ? C89 ? C90 ?
Ou C99 ?

g++ en fait je voulais dire... donc dans mon cas c++98.

Il suffit de caser un petit template qui te génère une erreur de compilation si tu lui passes une condition qui n'est pas vérifiée, et lui passer (bits % 8) == 0 par exemple.

Il faut que je réfléchisse à ça.

**MatRem** · 16/07/2007, 15h29

C'est gcc qui n'est pas à jour pour les long long?

Je sais maintenant que cette solution n'est pas très intéressantes, mais ça me permet d'apprendre la gestion des templates.

Pour la gestion des erreurs, j'ai fait ça comme ç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
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
#include <iostream>
 
/* Expression template du IF C Then A ELSE B. */
template<bool b, typename T1, typename T2>
class If
{
public:
	typedef T1 Res;
};
template<typename T1, typename T2>
class If<false, T1, T2>
{
public:
	typedef T2 Res;
};
 
 
/* Classe template pour la gestion des erreurs de Int<int>. */
template<bool b>
class ValidInt
{
};
template<>
class ValidInt<true>
{
public:
	typedef int NB_BYTES_NOT_MODULO_8;
	typedef int NB_BYTES_TOO_HIGHT;
};
 
/* Gestion des entiers de taille spécifique. */
template<int bits>
class Int
{
public:
	typedef
		typename If<
			!(bits%8),
			typename If<
				(sizeof(char)==bits/8),
				char,
				typename If<
					(sizeof(short)==bits/8),
					short,
					typename If<
						(sizeof(int)==bits/8),
						int,
						typename If<
							(sizeof(long)==bits/8),
							long,
							typename ValidInt<sizeof(long)>=bits/8>::NB_BYTES_TOO_HIGHT
						>::Res
					>::Res
				>::Res
			>::Res,
			typename ValidInt<!(bits%8)>::NB_BYTES_NOT_MODULO_8
		>::Res
	T;
};
 
typedef Int<8>::T  Int8;
typedef Int<16>::T Int16;
typedef Int<32>::T Int32;

Y'a t il moyen de faire ça plus "proprement"?

**Laurent Gomila** · 16/07/2007, 16h03

Du moment que tu as une erreur de compilation à peu près explicite si la condition n'est pas repsectée, c'est déjà pas mal

Après il y a peut-être moyen de faire un truc plus concis ou avec un message d'erreur plus propre (voir par exemple chez boost.static_assert), mais moi ça me paraît bien ce que tu as fait.

C'est gcc qui n'est pas à jour pour les long long?

Quelle version ? Quelles options de compilation ?

**MatRem** · 16/07/2007, 16h47

les options : g++ main.cpp -std=c++98 -Wall -Werror -pedantic -pedantic-errors

la version :

$> g++ --version
gcc (GCC) 4.1.1 20060724 (prerelease) (4.1.1-3mdk)
...

**loufoque** · 16/07/2007, 19h59

Regarde du côté de boost.integer, y'a déjà ce genre de choses.
http://www.boost.org/libs/integer/integer.htm

**MatRem** · 16/07/2007, 20h46

Ok merci

...
en fait là c'était plus pour me familiariser avec les templates.

Mais, c'est vrai qu'au début je me demandais si c'était intéressant de coder ça comme ça.

Template Int<bits>, votre avis?

Langage C++

Discussions similaires

Partager

Partager