Discussion :

[subzero82]

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 :

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

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 :

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

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 :

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

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 :

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

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.

[Scorpi0]

Un peu plus transparent pour l'utilisateur :

Code :

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

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 :

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

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

[souviron34]

ou même idée mais encore plus simple

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
#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 :
              ....
     }
}
 
....

[Scorpi0]

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

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

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
#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 :

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

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);
}

[Médinoc]

Légère correction :

Code C :

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
#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.

[Scorpi0]

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

On chipote on chipote..

[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.

[Scorpi0]

Techniquement aucune différence non.