Discussion :

[darkwall_37]

Hello,

J'avais un peu de temps à tuer et je me suis dit que je reprendrais bien mes librairies "maison" qui n'ont d'autres intérêts que les miens ( pour ne pas dire autrement qu'il ne faut pas y chercher d'utilité particulière pour vous ) et à commencer par la gestion des opérations standards sur les pointeurs.

Comme je souhaite ensuite dupliquer ce bout de code pour les autres types et qu'actuellement je dois être à 3000+ lignes, avant de le faire je voulais votre avis s'il y a des âmes courageuses pour y jeter un œil. Parce qu'après, pour reprendre les conneries, c'est moins drôle ^^

Je ne cherche pas tant à ce qu'on me dise, ceci n'est pas optimisé car ce n'est pas le propos de cette librairie mais je ne suis pas avare de bons conseils bien entendu. C'est surtout constater s'il y a de grosses coquilles qui font saigner les yeux même si une coquille est perçue différemment par chacun.

J'ai fait 2 fonctions que j'assimile à de l'assertion même si ce n'en n'est pas vraiment et ce, afin de tester l'ensemble des possibilités ou une une grande partie tout du moins. J'ai lancé 1000 fois sous Dr Memory pour vérifier les erreurs, j'en sors indemne.

Chacune des 'assertions' vise à vérifier les fonctions pour la manipulations des pointeurs 1D puis 2D.
J'ai linké le projet CBP en PJ.

Merci d'avance.

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
 
#include "ptr.h"
#include "log.h"
 
int main()
{
    if ( ( f_log = log_create() ) )
    {
        srand(time(NULL));
 
        size_t a = i_1D_assert( 1, false, 10, INT_MAX ); /* To display results,  set var to true else to false */
        size_t b = i_2D_assert( 1, false , 10, 10, INT_MAX, 2 );
        printf( "\n Unexpected behavior : %zu, check log for more details", a+b );
 
        log_display(  f_log );
        log_destroy( &f_log );
    }
    return 0;
}

[Sve@r]

Bonjour

Je lis ton truc mais ça pique un peu les yeux.
Bon, déjà un truc que j'aime énormément, c'est ce extern log_t *f_log dans les fonctions qui utilisent la variable globale "f_log". Certes c'est de la globale mais au-moins tu identifies les endroits où elle est utilisée. Toutefois, par voie de conséquences, je ne suis pas certain que mettre cette instruction dans le "log.h" soit une super idée.

Maintenant question lisibilité, je pense que tu aurais avantage à remplacer cet insipide (et old-school)

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
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
bool log_add( const char* hea, const char* fun, const char* msg )
{
	extern log_t* f_log;
	bool c = false;
	if ( hea && fun && msg )
	{
		log_t* a = NULL; //Testing pointer for the reallocation of f_log
		if ( f_log )
		{
			a = f_log; size_t sz_new = a->sz+1;
			char** b = NULL; //Testing pointer for reallocation of the string
			if ( ( b = realloc( (a->hea), sz_new*sizeof( *a ) ) ) )
			{
				a->hea = b;
				if ( ( a->hea[sz_new-1] = str_copy(hea) ) )
				{
					if ( ( b = realloc( (a->fun), sz_new*sizeof( *a ) ) ) )
					{
						a->fun = b;
						if ( ( a->fun[sz_new-1] = str_copy(fun) ) )
						{
							if ( ( b = realloc( (a->msg), sz_new*sizeof( *a ) ) ) )
							{
								a->msg = b;
								if ( ( a->msg[sz_new-1] = str_copy(msg) ) )
								{
									a->sz = sz_new;
									f_log = a;
									c = true;
								}
							}
							else log_destroy(&a);
						}
						else log_destroy(&a);
					}
					else log_destroy(&a);
				}
				else log_destroy(&a);
			}
			else log_destroy(&a);
		}
		else log_destroy(&a);
	}
	return c;
}
 
par un plus élégant
bool log_add( const char* hea, const char* fun, const char* msg )
{
	extern log_t* f_log;
	bool c = false;
	if ( hea && fun && msg )
	{
		log_t* a = NULL; //Testing pointer for the reallocation of f_log
		if ( f_log )
		{
			a = f_log; size_t sz_new = a->sz+1;
			char** b = NULL; //Testing pointer for reallocation of the string
			if ( ( b = realloc( (a->hea), sz_new*sizeof( *a ) ) ) )
			{
				a->hea = b;
				if ( ( a->hea[sz_new-1] = str_copy(hea) ) )
				{
					if ( ( b = realloc( (a->fun), sz_new*sizeof( *a ) ) ) )
					{
						a->fun = b;
						if ( ( a->fun[sz_new-1] = str_copy(fun) ) )
						{
							if ( ( b = realloc( (a->msg), sz_new*sizeof( *a ) ) ) )
							{
								a->msg = b;
								if ( ( a->msg[sz_new-1] = str_copy(msg) ) )
								{
									a->sz = sz_new;
									f_log = a;
									c = true;
								}
							}
							else log_destroy(&a);
						}
						else log_destroy(&a);
					}
					else log_destroy(&a);
				}
				else log_destroy(&a);
			}
			else log_destroy(&a);
		}
		else log_destroy(&a);
	}
	return c;
}

par

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
bool log_add( const char* hea, const char* fun, const char* msg )
{
	extern log_t* f_log;
	if ( !hea || !fun || !msg ) return false;
 
	if ( !f_log ) return false;
 
	log_t* a; //Testing pointer for the reallocation of f_log
	a = f_log;
	size_t sz_new = a->sz+1;
	char** b; //Testing pointer for reallocation of the string
 
	if ( ( b = realloc( (a->hea), sz_new*sizeof( *a ) ) ) == NULL )
	{
		log_destroy(&a);
		return false;
	}
 
	a->hea = b;
	if ( !( a->hea[sz_new-1] = str_copy(hea) ) )
	{
		log_destroy(&a);
		return false;
	}
 
	if ( ( b = realloc( (a->fun), sz_new*sizeof( *a ) ) ) == NULL )
	{
		log_destroy(&a);
		return false;
	}
 
	a->fun = b;
	if ( !( a->fun[sz_new-1] = str_copy(fun) ) )
	{
		log_destroy(&a);
		return false;
	}
 
	if ( ( b = realloc( (a->msg), sz_new*sizeof( *a ) ) ) == NULL )
	{
		log_destroy(&a);
		return false;
	}
 
	a->msg = b;
	if ( !( a->msg[sz_new-1] = str_copy(msg) ) )
	{
		log_destroy(&a);
		return false;
	}
 
	a->sz = sz_new;
	f_log = a;
	return true;
}

Et idem partout où tu fais ces tests imbriqués. C'est peut-être moins académique, mais perso je trouve ça plus lisible et plus dans l'esprit "check list". Et puis ça évite une variable.

Pour str_copy, tu peux éviter p_out[i]='\0' si tu remplaces i < p_sz par i <= p_sz. Et si tu fais l'effort d'utiliser des pointeurs, tu peux même shunter ces indirections.

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
static char* str_copy( const char* p )
{
	if ( ! p ) return NULL;
	char* p_out;
	if ( ( p_out = malloc( (str_length(p)+1)*sizeof(*p_out) ) ) == NULL ) return NULL;
	char *p_tmp=p_out;
	do {
		(*p_tmp)=(*p);
		p_tmp++;
	} while (*p++);
	return p_out;
}