Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre confirmé
    Homme Profil pro
    Etudiant administrateur systèmes et réseaux
    Inscrit en
    octobre 2007
    Messages
    715
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Etudiant administrateur systèmes et réseaux

    Informations forums :
    Inscription : octobre 2007
    Messages : 715
    Points : 459
    Points
    459
    Par défaut Demande de relecture pour vérifications avant généralisation.
    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;
    }
    Fichiers attachés Fichiers attachés
    UNE REPONSE UTILE : &|| UN PROBLEME RESOLU :

  2. #2
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 591
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 591
    Points : 21 629
    Points
    21 629
    Billets dans le blog
    1
    Par défaut
    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;
    }
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo