C le plus clean ?

[tatouille]

#define kbarDefaultString "bar"
char *bar;

/* need, free the allocated storage */
/* strdup() */

/* need, free the allocated storage */
char *foo_encoding(char * c)
{
    /*
    ....
    */
    
    return foo_encoding_char;
}

char *get_val(char * c)
{
    /*
    ....
    */
    
    /* could be NULL */
    
    return get_val;
}

int foo()
{
    char *bar_copy;
    bar = strdup(kbarDefaultString);
    
    if( bar_copy = get_val(bar) )
    {
         val = foo_encoding(bar_copy);
        
        /* do that */
        realloc(bar,strlen(val)+1);
        /*  or do that ? */
        free(bar);
        /*  or simply crush  ? */
        
        bar = strdup(val);
        
        free(val);
    }
    
    return 0;
}


int main(void)
{
    int res;
    res = foo();
    
    if(res)
    {
        /* new val */
        printf("%s",bar);
        free(bar);
        exit(0);
        
    }else {
        /* kbarDefaultString */
        printf("%s",bar);
        free(bar);
        exit(1);
    }
    return 0;
}

:zen: ps c'est la meme chose , mais qu'elle est le plus élégant et le plus compréhensible

 

[claw59]

alors, voyons voir ... donc si j'ai bien compris le but de ce code: réallouer à la volée une variable, est-ce mieux de passer par la méthode 'realloc' ou bien de le faire soi-même à la main ??

En ce qui me concerne, l'efficacité à emboîter le pas sur des méthodes préexistantes (surtout si elles sont fournies en standard) consiste à pouvoir être capable d'améliorer leur fonctionnement soit par l'ajout de paramètres de précision ou bien dans la vocation de complexifier ultérieurement facilement le code existant.

exemple bidon:
float lenteur;

suivant le 1er cycle de réalisation de cette variable on n'utilise que des entiers
on revoit le code pour rajouter la prise en compte d'un caractère mineur qui influence la variable lenteur pour donner des nombres 'flottants'.

je dirai si tu veux par la suite non pas réallouer une seule variable mais plusieurs ou des tableaux, etc...il serai plus judicieux d'être capable d'anticiper sur des complexités faciles à deviner, en particulier "si c'est vrai pour un, est-ce vrai pour plusieurs ?". donc il faudrai fragmenter l'utilisation de la méthode 'realloc' en différentes étapes élémentaires!

En tout cas c'est un aspect des choses que j'ai compris perso dans le but d'éviter de passer mon temps à faire des 'for...for' imbriquée. Ainsi au lieu d'imbriquer index sur index sur index, pourquoi ne pas utiliser une seule structure contenant l'ensemble de ces 'index' ? et ensuite en dernier on utilise un for..l'utilisation des différents index se qualifie bien souvent par rapport à des écarts.

 

[tatouille]

oui je suis d'accord programmer objet

mon problème est de rendre un code le plus explicit as possible
car ce code sera repris et utilisé et implémenté par des jeuns

donc c'était :

savoir comment être le plus clair et le "plus didactique"
et donc le moins compacte possible


:zen:

 

[Didier Guillion]

Claw59 a l'air d'avoir compris ta demande, gloire a lui !

Personnellement, je n'arrive meme pas a comprendre si c'est une question ou non.

Tu pourrais expliciter ?


Cordialement

 

[claw59]

A mon avis, il a voulu mettre en évidence le fait d'éviter de se servir de certaines facilités de service.

L'utilisation de realloc, si je ne me trompe pas, sert à anticiper des débordements ou dépassements le plus facilement possible (par contre pour concevoir du code sécurisé ça j'ignore). donc, il est préférable de ne pas s'en servir trop souvent, sinon cela fait chuter les performances.

 

[tatouille]

/* do that */
realloc(bar,strlen(val)+1);
bar = val; 
/*  or do that ? */
free(bar);
bar = strdup(val); 
/*  or simply crush  ? */
        
bar = val;

oui si tu testes mal la len passé à malloc cela crée des situation d'overflow
par exemple si la len renvoyée et -1 on obtient malloc(0) / realloc ou négatif