Ubuntu-fr

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Petite question comme ça : si j’ai un bloc d’instructions, toujours les mêmes, qui se retrouvent en plusieurs endroits dans mon code, y a-t-il un autre moyen de procéder que de faire un copié-collé ? Non, je ne peux pas créer une fonction, il y a dedans un return et un continue.

Oui, et alors ? C’est pratique return et continue.
Bien sûr on peut penser au goto, mais dans mon cas cela serait sémentiquement assez incorrect, et puis je ne sais pas si c’est très sage de foutre un goto quand on est en train de boucler dans tous les sens…

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Raaah, bonjour l'exemple donné par les modos .

Yep. Tous des branleurs, d'façon !

Bel exemple de message inutile qui n’a pour seul but que de flooder et marquer deux points.

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Petite question comme ça : si j’ai un bloc d’instructions, toujours les mêmes, qui se retrouvent en plusieurs endroits dans mon code, y a-t-il un autre moyen de procéder que de faire un copié-collé ? Non, je ne peux pas créer une fonction, il y a dedans un return et un continue.

Oui, et alors ? C’est pratique return et continue.
Bien sûr on peut penser au goto, mais dans mon cas cela serait sémentiquement assez incorrect, et puis je ne sais pas si c’est très sage de foutre un goto quand on est en train de boucler dans tous les sens…

Faudrait voir le code et son contexte pour se prononcer.

Dernière modification par grim7reaper (Le 19/04/2010, à 21:56)

---

Blog

Dr Le Rouge

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

S'pas à ça que servent les macros ?

---

C'est deux suites de Cauchy qui veulent aller à la soirée 'no limit'. Hélas, à l'entrée le videur leur dit : "désolé, c'est complet !".
mon site perso (π²/6.fr) et mon blog

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Hop, v’là l’code :

if(!eq)
{
    ret->errsv=realloc(ret->errsv,(sizeof *ret->errsv)*(j+1));
    ret->errsarg=realloc(ret->errsarg,(sizeof *ret->errsarg)*(j+1));
    if(!ret->errsv||!ret->errsarg)
    {
        delete_return(ret);
        return NULL;
    }
    argv[argn][2]='=';
    ret->errsarg[j]=argn;
    ret->errsv[j++]="illegal '='";
    continue;
}

Si je détecte une erreur, je la renseigne, en n’oubliant pas de tester mes realloc().

Et le contexte, c’est plein de boucles.

@u Rouge : une macro de cette taille c’est raisonnable ?

Dernière modification par Pylade (Le 19/04/2010, à 21:57)

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

Dr Le Rouge

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

J'en sais rien ! Je les utilise pas

---

C'est deux suites de Cauchy qui veulent aller à la soirée 'no limit'. Hélas, à l'entrée le videur leur dit : "désolé, c'est complet !".
mon site perso (π²/6.fr) et mon blog

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Tu pourrais poster (envoyer par mail si c'est c'est trop long) le code entier.
Une macro ça peut être une solution, mais il y a peut-être mieux.

Je suis comme un compilo, il me faut une vue d'ensemble pour optimiser .

En passant, je crois que tu risques une fuite de mémoire vue comme tu traites le realloc, mais c'est pas sûr du tout (je ferais des tests pour voir).

Dernière modification par grim7reaper (Le 19/04/2010, à 22:06)

---

Blog

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

En passant, je crois que tu risque une fuite de mémoire vue comme tu traites le realloc, mais c'est pas sûr du tout (je ferais de test pour voir).

Oui, en effet !
Corrigé.

Le code arrive.

Édit : heu, non. Tu m’as fait dire des conneries. Non, en fait il n’y a aucune fuite, delete_return() s’occupe de tout.

Dernière modification par Pylade (Le 19/04/2010, à 22:08)

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

On verra, je n'en suis pas sûr du tout (lundi soir inside) c'est pour ça que j'insiste pas mais si c'est avéré j'en reparlerais.

---

Blog

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Attention, ça risque d’être violent :

libopt.c

#include "libopt.h"

struct option* new_option(void)
{
    struct option* opt=malloc(sizeof *opt);
    if(opt)
    {
        opt->active=0;
        opt->short_act="";
        opt->long_act=malloc(sizeof *opt->long_act);
        if(!opt->long_act)
        {
            free(opt);
            return NULL;
        }
        opt->short_unact="";
        opt->long_unact=malloc(sizeof *opt->long_unact);
        if(!opt->long_unact)
        {
            free(opt->long_act);
            free(opt);
            return NULL;
        }
        opt->takes_value=0;
        opt->value="";
    }
    return opt;
}

int new_long_option(struct option* ptr,char act,const char* str)
{
    int i=-1;
    while(str[++i]!='\0')
        if(str[i]=='=')
            return -1;
    if(!i)
        return -1;
    i=0;
    if(act)
    {
        while(ptr->long_act[i++]!=NULL);
        ptr->long_act=realloc(ptr->long_act,(sizeof *ptr->long_act)*(i+1));
        if(!ptr->long_act)
            return -1;
        ptr->long_act[i-1]=str;
        ptr->long_act[i]=NULL;
    }
    else
    {
        while(ptr->long_unact[i++]!=NULL);
        ptr->long_unact=realloc(ptr->long_unact,(sizeof *ptr->long_unact)*(i+1));
        if(!ptr->long_unact)
            return -1;
        ptr->long_unact[i-1]=str;
        ptr->long_unact[i]=NULL;
    }
    return 0;
}

void delete_option(struct option** ptr)
{
    free((*ptr)->long_act);
    free((*ptr)->long_unact);
    free(*ptr);
    *ptr=NULL;
}

struct option** new_option_table(int n)
{
    int i;
    struct option** opt_tab=malloc((sizeof *opt_tab)*(n+1));
    if(!opt_tab)
        return NULL;
    for(i=0;i<n;i++)
    {
        opt_tab[i]=new_option();
        if(!opt_tab[i])
        {
            delete_option_table(&opt_tab);
            return NULL;
        }
    }
    opt_tab[n]=NULL;
    return opt_tab;
}

void delete_option_table(struct option*** ptr)
{
    int i;
    for(i=0;(*ptr)[i]!=NULL;i++)
        delete_option(*ptr+i);
    free(*ptr);
    *ptr=NULL;
}

int str2cnt(const char* s1,const char* s2)
{
    int i=0;
    while(s1[i]==s2[i])
    {
        if(s1[i]=='\0')
            return i;
        i++;
    }
    return 0;
}

int deleq(char* str)
{
    int i=-1;
    while(str[++i]!='\0')
        if(str[i]=='=')
        {
            str[i]='\0';
            return i;
        }
    return -1;
}

void delete_return(struct retr** ptr)
{
    free((*ptr)->argsv);
    (*ptr)->argsv=NULL;
    free((*ptr)->errsv);
    (*ptr)->errsv=NULL;
    free((*ptr)->errsarg);
    (*ptr)->errsarg=NULL;
    free(*ptr);
    *ptr=NULL;
}

struct retr* atropt(int argc,char** argv,struct option** optv)
{
    short i=0;
    short j=0;
    char skip=0;
    struct option* next=NULL;
    short argn;
    struct retr* ret=malloc(sizeof *ret);
    if(!ret)
        return NULL;
    ret->argsv=NULL;
    for(argn=1;argn<argc;argn++)
    {
        short s_flag=0;
        if(argv[argn][0]=='-'&&!skip)
        {
            if(argv[argn][1]=='\0')
            {
                ret->argsv=realloc(ret->argsv,(sizeof *ret->argsv)*(i+1));
                if(!ret->argsv)
                    return NULL;
                ret->argsv[i++]="-";
                continue;
            }
            if(argv[argn][1]!='-')
            {
                while(argv[argn][++s_flag]!='\0')
                {
                    short optn;
                    for(optn=0;optv[optn]!=NULL;optn++)
                    {
                        short shn;
                        for(shn=0;optv[optn]->short_unact[shn]!='\0';shn++)
                            if(optv[optn]->short_unact[shn]==argv[argn][s_flag])
                                optv[optn]->active=0;
                        for(shn=0;optv[optn]->short_act[shn]!='\0';shn++)
                            if(optv[optn]->short_act[shn]==argv[argn][s_flag])
                            {
                                optv[optn]->active=1;
                                if(optv[optn]->takes_value==1)
                                    next=optv[optn];
                            }
                    }
                }
            }
            else
            {
                if(argv[argn][2]=='\0')
                    skip=1;
                else
                {
                    /* options longues on continue ! */
                    short optn;
                    int eq=deleq(argv[argn]+2);
                    if(!eq)
                    {
                        ret->errsv=realloc(ret->errsv,(sizeof *ret->errsv)*(j+1));
                        ret->errsarg=realloc(ret->errsarg,(sizeof *ret->errsarg)*(j+1));
                        if(!ret->errsv||!ret->errsarg)
                        {
                            delete_return(&ret);
                            return NULL;
                        }
                        argv[argn][2]='=';
                        ret->errsarg[j]=argn;
                        ret->errsv[j++]="illegal '='";
                        continue;
                    }
                    for(optn=0;optv[optn]!=NULL;optn++)
                    {
                        short lgn;
                        for(lgn=0;optv[optn]->long_unact[lgn]!=NULL;lgn++)
                            if(str2cnt(optv[optn]->long_unact[lgn],(const char*) argv[argn]+2))
                                optv[optn]->active=0;
                        /* À revoir (copié-collé des options courtes)
                        for(lgn=0;optv[optn]->long_act[lgn]!=NULL;lgn++)
                        {
                            /!\if(optv[optn]->long_act[lgn],argv[argn]+2)
                            {
                                optv[optn]->active=1;
                                if(optv[optn]->takes_value==1)
                                    next=optv[optn];
                            }/!\
                        }*/
                    }
                    /* / options longues */
                }
            }
        }
        else
        {
            if(next!=NULL)
            {
                next->value=(const char*) argv[argn];
                next=NULL;
            }
            else
            {
                ret->argsv=realloc(ret->argsv,(sizeof *ret->argsv)*(i+1));
                if(!ret->argsv)
                {
                    delete_return(&ret);
                    return NULL;
                }
                ret->argsv[i++]=(const char*) argv[argn];
            }
        }
    }
    ret->argsv=realloc(ret->argsv,(sizeof *ret->argsv)*(i+1));
    ret->errsv=realloc(ret->errsv,(sizeof *ret->errsv)*(j+1));
    ret->errsarg=realloc(ret->errsarg,(sizeof *ret->errsarg)*(j+1));
    if(!ret->argsv||!ret->errsv||!ret->errsarg)
    {
        delete_return(&ret);
        return NULL;
    }
    ret->argsv[i]=NULL;
    ret->argsc=i;
    ret->errsv[j]=NULL;
    ret->errsc=j;
    ret->errsarg[j]=0;
    return ret;
}

header :

#ifndef LIBOPT_H_INCLUDED
#define LIBOPT_H_INCLUDED
#include <stdlib.h>

struct option
{
	char active;
	const char* short_act;
	const char** long_act;
	const char* short_unact;
	const char** long_unact;
	char takes_value;
	const char* value;
};
struct retr
{
    int argsc;
    const char** argsv;
    int errsc;
    const char** errsv;
    int* errsarg;
};
struct retr* atropt(int,char**,struct option**);
struct option* new_option(void);
int new_long_option(struct option*,char,const char*);
void delete_option(struct option**);
struct option** new_option_table(int);
void delete_option_table(struct option***);
int str2cnt(const char*,const char*);
int deleq(char*);
void delete_return(struct retr**);
#endif /* MAIN_H_INCLUDED */

Comme vous pouvez le constater, ce n’est pas encore fini, et c’est assez brouillon.

debug.c :

#include <stdio.h>
#include <stdlib.h>
#include "libopt.h"

int main(int argc,char** argv)
{
    struct option** optv=new_option_table(2);
    struct retr* ret1;
    int i=-1;
    optv[0]->short_act="d";
    if(new_long_option(optv[0],0,"una")==-1) exit(-1);
    optv[1]->short_act="fi";
    optv[1]->short_unact="r";
    ret1=atropt(argc,argv,optv);
        if(ret1==NULL) exit(-1);
    if(optv[0]->active)
        puts("optv[0] active!");
    if(optv[1]->active)
        puts("optv[1] active!");
    delete_option_table(&optv);
    while((ret1->argsv)[++i]!=NULL)
        puts((ret1->argsv)[i]);
    puts("--- errors ---");
    i=-1;
    while((ret1->errsv)[++i]!=NULL)
        printf("%s: %s\n",argv[(ret1->errsarg)[i]],(ret1->errsv)[i]);
    delete_return(&ret1);
    return 0;
}

Régalez-vous !

Édit : correction d’une fuite de mémoire (véritable celle là).
Édit : une autre.
Édit : et encore une.

Dernière modification par Pylade (Le 19/04/2010, à 22:44)

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Tu as mis à jour le code posté ?

---

Blog

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Je crois qu’il est bon.

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

helly

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

 kill

---

Archlinux-wmii-dwb.
Un problème résolu ? Faites le savoir en mettant [résolu] à côté du titre de votre topic.
Un problème non résolu ? Faites le savoir en insultant ceux qui cherchent à vous aider.
Un site bleu super remasterised©, un wiki cherchant des volontaires pour traduire un site.

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Tu à bien une fuite de mémoire (ce n'est pas celle que j'avais vu)

==25241== HEAP SUMMARY:
==25241==     in use at exit: 20 bytes in 1 blocks
==25241==   total heap usage: 12 allocs, 11 frees, 124 bytes allocated
==25241==                                                                                                                                                                          
==25241== 20 bytes in 1 blocks are definitely lost in loss record 1 of 1                                                                                                           
==25241==    at 0x40238FC: malloc (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)                                                                                           
==25241==    by 0x8048A8E: atropt (libopt.c:137)                                                                                                                                   
==25241==    by 0x804853A: main (debug.c:14)                                                                                                                                       
==25241==                                                                                                                                                                          
==25241== LEAK SUMMARY:                                                                                                                                                            
==25241==    definitely lost: 20 bytes in 1 blocks
==25241==    indirectly lost: 0 bytes in 0 blocks
==25241==      possibly lost: 0 bytes in 0 blocks
==25241==    still reachable: 0 bytes in 0 blocks
==25241==         suppressed: 0 bytes in 0 blocks

Ensuite.
Hum, mouais...
Comment dire...

Bon je vais être franc : ta fonction atropt est bloated, très peu lisible et proche du plat de spaghetti.
Bon ça, c'est fait.

C'est pas cool mais ça peut s'arranger .
Déjà, les return c'est cool, mais faut pas en abuser et là 21 en 9 fonctions c'est clairement trop (dont 6 dans atropt). L'idéal c'est un seul return par fonction (mais on peut faire des exceptions, sans aller jusqu'a 6 ).

Ensuite le realloc c'est bien aussi, mais ça à un coup et faire du realloc pour augmenter la taille de 1 à chaque fois ça risque de plomber les perfs (bon c'est de la gestion d'option, c'est pas critique, mais par principe c'est moyen).

Tu peux (non, tu dois) découper ta fonction atropt. Je verrais bien une sous-fonction pour :
- traitement des options coutrtes
- traitement des options longues
- traitement du "-" seul

En fait, une fonction pour chaque grand cas (qui correspondent au if/else de plus haut niveau je crois).
Une fois que ça sera fait, on y verra plus clair et on redécoupera si nécessaire et on pourra s'attaquer à la factorisation du code, à la traque des memory leak et à l'optimisation.

Dernière modification par grim7reaper (Le 19/04/2010, à 23:06)

---

Blog

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Tu à bien une fuite de mémoire (ce n'est pas celle que j'avais vu).

Oui, je sais, je viens d’en niquer trois, mais j’ai pu en laisser passer une.

Bon je vais être franc : ta fonction atropt est bloated, très peu lisible et proche du plat de spaghetti.
Bon ça, c'est fait.

><'

Déjà, les return c'est cool, mais faut pas en abuser et là 21 en 9 fonctions c'est clairement trop (dont 6 dans atropt). L'idéal c'est un seul return par fonction (mais on peut faire des exceptions, sans aller jusqu'a 6 ).

Bah, ouais, mais comment je fais pour pour gérer les erreurs sans complexifier encore plus le code ?
Je ne vois pas où est le mal, ça m’aide à ne pas trop surcharger.

Ensuite le realloc c'est bien aussi, mais ça à un coup et faire du realloc pour augmenter la taille de 1 à chaque fois ça risque de plomber les perfs (bon c'est de la gestion d'option, c'est pas critique, mais par principe c'est moyen).

Oui, je voulais faire un truc souple, ce n’est pas comme si j’étais en permanence en train de faire des realloc(), ça ne dure qu’une fraction de seconde.

Tu peux (non, tu dois) découper ta fonction atropt. Je verrais bien une sous-fonction pour :
- traitement des options coutrtes
- traitement des options longues
- traitement du "-" seul

Le "-" seul ne prend que 6 lignes, je pense qu’une fonction serait contre productive.
Les arguments non-options, ça prend 5 lignes.
Le "--", n’en parlons même pas.

Les options courtes prennent tout de même assez peu de place, mais créer une fonction courte serait imaginable.
Pour ce qui est des options longues, aaargh ! Je sais, c’est ce qui prend le plus de place, mais là ça me ferait vraiment chier de créer une fonction supplémentaire, à cause de la complexité ambiante, et vivent les return, en plus. Aïe.

Une fois que ça sera fait, on y verra plus clair et on redécoupera si nécessaire et on pourra s'attaquer à la factorisation du code, à la traque des memory leak et à l'optimisation.

En parlant d’optimisation, il faudrait faire un padding correct pour les structures. Les memory leak, je peux voir ça j’étais dans la traque quand tu m’a dit que tu me rédigeais mon blâme.
Sinon, la factorisation, c’est quoi ?

Voilà.

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Post Not Found

Tu à bien une fuite de mémoire (ce n'est pas celle que j'avais vu).

Oui, je sais, je viens d’en niquer trois, mais j’ai pu en laisser passer une.

Oki.

Bon je vais être franc : ta fonction atropt est bloated, très peu lisible et proche du plat de spaghetti.
Bon ça, c'est fait.

><'

Oui, c'est un peu violent mais c'est malheureusement à peine exagéré.

Déjà, les return c'est cool, mais faut pas en abuser et là 21 en 9 fonctions c'est clairement trop (dont 6 dans atropt). L'idéal c'est un seul return par fonction (mais on peut faire des exceptions, sans aller jusqu'a 6 ).

Bah, ouais, mais comment je fais pour pour gérer les erreurs sans complexifier encore plus le code ?
Je ne vois pas où est le mal, ça m’aide à ne pas trop surcharger.

Ça casse la lecture, c'est difficile à lire, ça complique le repérage des points de sortie de tes fonctions et ça s'oppose un peu à la programmation structurée.
Celà dit, c'est surtout due à la taille de ta fonction je pense, il sera plus simple de gérer proprement les erreurs quand le code sera clarifié.

Ensuite le realloc c'est bien aussi, mais ça à un coup et faire du realloc pour augmenter la taille de 1 à chaque fois ça risque de plomber les perfs (bon c'est de la gestion d'option, c'est pas critique, mais par principe c'est moyen).

Oui, je voulais faire un truc souple, ce n’est pas comme si j’étais en permanence en train de faire des realloc(), ça ne dure qu’une fraction de seconde.

Un allocation ce n'est pas quelque chose de rapide, surtout realloc qui peut être amener à recopier toute ton tableau dans une autre zone mémoire (bon dans ton cas les tableaux devrai garder une taille raisonnable donc ça peut passer).

Tu peux (non, tu dois) découper ta fonction atropt. Je verrais bien une sous-fonction pour :
- traitement des options coutrtes
- traitement des options longues
- traitement du "-" seul

Le "-" seul ne prend que 6 lignes, je pense qu’une fonction serait contre productive.
Les arguments non-options, ça prend 5 lignes.
Le "--", n’en parlons même pas.

Le nombre de ligne n'est pas un argument. J'ai couramment des fonctions qui font moins de 10 lignes (voire une seule). Ensuite, si le compilo juge bon de remplacer l'appel par du code direct qu'il le fasse c'est très bien (ça ne nuit ni au performance, ni à la lisibilité de mon code).

Les options courtes prennent tout de même assez peu de place, mais créer une fonction courte serait imaginable.
Pour ce qui est des options longues, aaargh ! Je sais, c’est ce qui prend le plus de place, mais là ça me ferait vraiment chier de créer une fonction supplémentaire, à cause de la complexité ambiante, et vivent les return, en plus. Aïe.

Pourquoi ça te dérange de faire des fonctions ?
Cela permet au contraire de diminuer la complexité en repartissant les tâches (quand au return, il suffit d'en utiliser moins.)
Dans certaines de tes fonctions il suffit d'ajouter une variable, modifier quelques conditions et/ou rajouter un else pour supprimer les return multiple.

Une fois que ça sera fait, on y verra plus clair et on redécoupera si nécessaire et on pourra s'attaquer à la factorisation du code, à la traque des memory leak et à l'optimisation.

En parlant d’optimisation, il faudrait faire un padding correct pour les structures. Les memory leak, je peux voir ça j’étais dans la traque quand tu m’a dit que tu me rédigeais mon blâme.
Sinon, la factorisation, c’est quoi ?

Voilà.

Hum, en quoi le padding des structures te semble mauvais ? Tes structures ne sont pas énormes, mais bon on verra ça quand on en fera l'optimisation.
La factorisation de code c'est justement faire des fonctions pour éviter le copier/coller et la duplication du code. Ça améliore grandement la maintenance et l'évolutivité du programme (ça simplifie également les corrections de bug et la lecture).

Edit : Good Night World !

Dernière modification par grim7reaper (Le 19/04/2010, à 23:56)

---

Blog

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Post Not Allowed

---

Blog

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Post Not Acceptable

---

Blog

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Ça casse la lecture, c'est difficile à lire, ça complique le repérage des points de sortie de tes fonctions et ça s'oppose un peu à la programmation structurée.

?
Plutôt que de rajouter des tests partout, ça me permet de quitter proprement dès que je tombe sur une erreur.

Oui, je voulais faire un truc souple, ce n’est pas comme si j’étais en permanence en train de faire des realloc(), ça ne dure qu’une fraction de seconde.

Un allocation ce n'est pas quelque chose de rapide, surtout realloc qui peut être amener à recopier toute ton tableau dans une autre zone mémoire (bon dans ton cas les tableaux devrai garder une taille raisonnable donc ça peut passer).

Je voulais dire que la phase du traitement d’options ne dure qu’une fraction de secondes dans l’exécution du programme. ^^

Pourquoi ça te dérange de faire des fonctions ?
Cela permet au contraire de diminuer la complexité en repartissant les tâches (quand au return, il suffit d'en utiliser moins.)
Dans certaines de tes fonctions il suffit d'ajouter une variable, modifier quelques conditions et/ou rajouter un else pour supprimer les return multiple.

Mouais. Utiliser moins de return, ça va être dur.

Hum, en quoi le padding des structures te semble mauvais ? Tes structures ne sont pas énormes, mais bon on verra ça quand on en fera l'optimisation.
La factorisation de code c'est justement faire des fonctions pour éviter le copier/coller et la duplication du code. Ça améliore grandement la maintenance et l'évolutivité du programme (ça simplifie également les corrections de bug et la lecture).

OK.

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

grim7reaper

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Post Time-out
Dernier de la série floodesque.

@Pylade : je te répond demain.

@World : BN

Dernière modification par grim7reaper (Le 20/04/2010, à 00:03)

---

Blog

cm-t

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Edit : Good Night World !

et que vous faisiez des beaux rêves, World

---

Actu Ubuntu            ☺/
Pauses Ubuntu sur Paris            \_< -t
[(π)] La Quadrature du net

cm-t

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

Post Authentication Required

Gné?

---

Actu Ubuntu            ☺/
Pauses Ubuntu sur Paris            \_< -t
[(π)] La Quadrature du net

nesthib

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

¬¬

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

Pylades

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

C’est dingue, quand-même, il suffit de créer un sujet à points pour voir rappliquer toute une troupe de floodeurs.

---

“Any if-statement is a goto. As are all structured loops.
“And sometimes structure is good. When it’s good, you should use it.
“And sometimes structure is _bad_, and gets into the way, and using a goto is just much clearer.”
                Linus Torvalds – 12 janvier 2003

cm-t

Re : ..:: Topic des Codeurs Couche-Tard [0] ::..

je ne vois pas de quoi vous parlez.

sinon, ton histoire de copier/coller de code, ca fait pas avec les inline?

(/me is noob, je connaissais pas les inline, j'ai pas encore vérifier comment les variables était gérées dans ces cas-ci; mais la c'est dodo)

---

Actu Ubuntu            ☺/
Pauses Ubuntu sur Paris            \_< -t
[(π)] La Quadrature du net