Conseil ; créer un type de données

Version imprimable

Bonjour,

Dans le cadre d'un projet j'ai besoin de créer un nouveau type de données : Truth. Ce dernier est en fait un float dans le domaine de définition est [0, 1].
Code:

1 2 typedef float truth;
J’ai créé une batterie de fonction qui aura pour rôle de se charger de vérifier si la valeur qu'on veut affecter à une variable de type truth appartient au domaine [0, 1]. Leurs protos sont les suivants ;
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 truth int_to_truth(int value); truth uint_to_truth(unsigned int value); truth sint_to_truth(signed int value); truth shint_to_truth(short int value); truth lint_to_truth(long int value); truth luint_to_truth(long unsigned int value); truth lsint_to_truth(long signed int value); truth shuint_to_truth(short unsigned int value); truth shsint_to_truth(short signed int value); truth float_to_truth(float value); truth double_to_truth(double value); truth ldouble_to_truth(long double value);
donc si je veut affecter une valeur à une variable de type truth, j'aurais qlq chose comme sa:
Code:

1 2 truth t = XXXX_to_truth(valeur);
C’est un peu artificiel de dire ça, mais je trouve ça une peu moche.

J’aimerai faire en sorte que lorsque l'utilisateur affecte une valeur à une variable de truth un contrôle systématique soit fait afin de s'assurer qu'elle est effectivement entre 0 et 1. dans le monde de l'objet ça serait un événement qui sera déclenché à chaque fois qu'on fait appel à l'opérateur = et ça ne serait pas un problème de surcharger l'opérateur = sous C++.

pour obtenir une écriture plus élégante :
Code:

1 2 truth t = valeur ;
Le problème c'est que le C ne supporte ni la surcharge de fonction, encore moins la surcharge d'opérateur ou les événements.

Auriez-vous une astuce ou un conseil au sujet afin d'implémenter ce mécanisme ?

Merci d'avance.

Un peu plus transparent pour l'utilisateur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#define TYPE_FLOAT 1
typedef float truth;
 
truth* to_truth(void *my, int type)
{
	switch(type)
	{
		case TYPE_FLOAT:
			return (float*)(my);
	}
 
}

main :

Code:

1
2
3
4
float a = 1;
truth*b;
 
b = to_truth(&a, TYPE_FLOAT);

ou même idée mais encore plus simple

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#define FLOAT      0
#define DOUBLE    1
#define INT          2
#define LONG_INT 3
#define CHAR        4
......
 
 
float to_truth ( void *toto, int type )
{
   float ftoto = (float *)toto ;
   double dtoto = (double *)toto ;
   int itoto = (int *)toto ;
   char ctoto = (char *)toto ;
 
   switch ( type )
     {
        case FLOAT :
              ....
     }
}
 
....

Oui, je sais pas pourquoi j'ai voulu retourner un pointeur ^^

J'ai un truc de ce gout là au final :

Code:

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
#define TYPE_DOUBLE 1
typedef float truth;
 
truth to_truth(void *my, int type)
{
	truth borneInf = 0.0;
	truth borneSup = 1.0;
 
	switch(type)
	{
		case TYPE_DOUBLE:
			if(*(double*)(my) < 0)
			{
				return borneInf;
			}
			else if(*(double*)(my) > 1 )
			{
				return borneSup;
			}
			else
			{
				return (truth)(*(double*)my);
			}
	}
 
}

main :

Code:

1
2
3
4
5
6
7
8
9
{
 
	double a = 0.5, b = -0.5, c = 1.5;
	truth my_truth;
 
	my_truth = to_truth(&a, TYPE_DOUBLE);
	my_truth = to_truth(&b, TYPE_DOUBLE);
	my_truth = to_truth(&c, TYPE_DOUBLE);
}

Légère correction :

Code:

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
#define TYPE_DOUBLE 1
typedef float truth;
 
truth to_truth(void const *my, int type)
{
	truth borneInf = 0.0;
	truth borneSup = 1.0;
 
	switch(type)
	{
	case TYPE_DOUBLE:
		{
		double const * pcValue = my;
		double value = *pcValue;
		if(value < borneInf)
		{
			return borneInf;
		}
		else if(value > borneSup)
		{
			return borneSup;
		}
		else
		{
			return (truth)value;
		}
		}
		break;
	case TYPE_INT :
		...
	}
 
}

C'est quand même plus facile à comprendre, et en plus c'est const-correct.

11/07/2008, 16h54
Scorpi0

Les const je veux bien, mais la déclaration de variable dans le bloc switch, ça m'étonnerait que ça compile :P

On chipote on chipote..
11/07/2008, 16h58
souviron34

Citation:

Envoyé par Scorpi0

Les const je veux bien, mais la déclaration de variable dans le bloc switch, ça m'étonnerait que ça compile :P

On chipote on chipote..

conforme à la norme ;)
11/07/2008, 17h03
subzero82
C’est vrai que c'est tellement plus compact et clair.

Merciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii.

J’en profite pour poser une question. vous l'aurez Déja remarqué je ne suis pas un expert en C.

y'a t'il une différence entre ces différentes écritures :
1. void* value
2. void * value
3. void *value
c'est la même chose je pense (j'en suis pas sur à 100%).

merci d'avance.
11/07/2008, 17h11
Scorpi0

Techniquement aucune différence non.
11/07/2008, 17h25
subzero82

oki ,

merci pour votre aide.
12/07/2008, 11h23
Emmanuel Delahaye

Citation:

Envoyé par Scorpi0

Les const je veux bien, mais la déclaration de variable dans le bloc switch, ça m'étonnerait que ça compile

Peu importe que ça t'étonne ou pas, c'est conforme.
18/07/2008, 12h54
tim974

Citation:

J’en profite pour poser une question. vous l'aurez Déja remarqué je ne suis pas un expert en C.

y'a t'il une différence entre ces différentes écritures :

1. void* value
2. void * value
3. void *value

Oui, une très grosse différence, void *value c'est mieux :king:
Enfin, si cela t'arrive de déclarer quelques variables d'un coup, du même type. Tu auras le bon réflexe automatiquement, void *value,*cost,*topay etc ..