Topic des couche-tard (31)

Pylades · Le 13/04/2010, à 22:33

Je suis partisan de l’orthographe « plopper ». Et puis faut pas croire, il y en a (beaucoup) qui bossent, ici…

Pylades · Le 13/04/2010, à 22:38

tshirtman a écrit :

bah non, que tu prenne dans le stack ou le heap elle s'en fout un peu, c'est pareil…

/me n’a rien compris…

tshirtman a écrit :

tu peut lui demander de te passer la structure, ne faire aucune allocation et la remplir sinon…

Ouais, ça fais un truc de plus à passer en argument, sachant qu’il faut toujours garder à l’esprit que parmi les utilisateurs, il y aura toujours un con pour ne pas en rater une… Enfin, bon, là c’est pas encore trop complexe, je crois que c’est ce que je vais faire.

tshirtman a écrit :

codeur!

/me est ému et prend la remarque avec fierté (et songe à l’inclure dans sa signature).

PPdM · Le 13/04/2010, à 22:39

Et puis "ils glandent le jour" ! parles pour toi y'en a qui bossent nan mais ho !:mad:

Dernière modification par pierguiard (Le 13/04/2010, à 22:39)

Dr Le Rouge · Le 13/04/2010, à 22:40

Au fait, this is gonna SPARTAAAAAAAAAAAAAAAAAAAA bientôt.

helly · Le 13/04/2010, à 22:50

Une seule ! plopper est irrégulier, tu l'as dit toi-même !

oui le verbe "ploper" prend 2p UNIQUEMENT à la 2e personne du pluriel !!

parles pour toi y'en a qui bossent nan mais ho

C'est pas parce que vous êtes au bureau que vous glandez moins que moi nanmého !

tshirtman · Le 13/04/2010, à 22:51

/me n’a rien compris… hmm

ben demande à wikipedia heap stack… ah ces jeunes…

Ouais, ça fais un truc de plus à passer en argument, sachant qu’il faut toujours garder à l’esprit que parmi les utilisateurs, il y aura toujours un con pour ne pas en rater une… Enfin, bon, là c’est pas encore trop complexe, je crois que c’est ce que je vais faire.

heu, c'est au programmeur appelant ton api de fournir la structure, toi tu peut la retourner remplie et c'est à peu prèt tout… si le codeur appelant n'est pas foutu de faire ça comme il faut, c'est son pb… sinon tu lui renvoir un pointeur vers une structure que tu as initialisé et remplie c'est au choix… dans ce cas c'est à lui de la free()… c'est un choix…

/me est ému et prend la remarque avec fierté (et songe à l’inclure dans sa signature).

tu devrais pas prendre ça pour un compliment…
développeur c'est un compliment, la différence entre les deux est assez importante… (hacker aussi est un compliment, c'est une autre destination que peut prendre le codeur, et la différence est importante aussi)

Pylades · Le 13/04/2010, à 23:00

Pylade a écrit :

En commentant ce code, je me suis rendu compte que je ne faisais pas attention à la combinaison des options courtes… ><'

Fixed.

Pour fêter ça, un nouveau code. \o/

#include <stdlib.h>
struct opt
{
	char active;
	char* short_act;
	char** long_act;
	char* short_unact;
	char** long_unact;
	char takes_value;
	char* value;
};   // ma jolie structure que je t’avais déjà commentée
char*** atropt(int,char**,struct opt**);
char*** atropt(int argc,char** argv,struct opt** optv)
{
    char** ret[2];   // j’ai beaucoup de choses à renvoyer
    short i=0;   // compteur
    struct opt* next=NULL;   // si le prochain argument est une valeur d’option, pointeur vers la structure correspondante
    short argn;   // compteur
    for(argn=1;argn<argc;argn++)
    {
        short s_flag=0;   // compteur
        if(argv[argn][0]=='-')   // un argument qui commence par '-' signifie option longue, option courte, ou un "-" tout seul (e.g. dans cat ou su)
        {
            if(argv[argn][1]=='\0')
            {
                ret[0][i++]="-";   // si c’est juste un "-" tout seul, on renvoie ça comme un argument qui n’est pas une option
                continue;
            }
            if(argv[argn][1]!='-')   // on est en présence d’une option courte
            {
                while(argv[argn][++s_flag]!='\0')   // on boucle pour chaque option courte de l’argument
                {
                    short optn;   // compteur
                    for(optn=0;optv[optn]!=NULL;optn++)   // on teste les différentes structures les unes après les autres
                    {
                        short shn;   // compteur
                        for(shn=0;optv[optn]->short_unact[shn]!='\0';shn++)   // on lit les options courtes possibles parmi celles qui désactivent l’option
                        {
                            if(optv[optn]->short_unact[shn]==argv[argn][s_flag])
                                optv[optn]->active=0;   // on désactive notre structure
                        }
                        for(shn=0;optv[optn]->short_act[shn]!='\0';shn++)   // pareil pour les options qui activent
                        {
                            if(optv[optn]->short_act[shn]==argv[argn][s_flag])
                            {
                                optv[optn]->active=1;
                                if(optv[optn]->takes_value==1)
                                    next=optv[optn];   // si cette option prend une valeur, éditer notre pointeur pour le prochain argument
                            }
                        }
                    }
		}
            }
            else
            {
                // options longues on continue !
            }
        }
        else
        {
            if(next!=NULL)   // si notre pointeur est activé, on édite la valeur de l’option
            {
                next->value=argv[argn];
                next=NULL;   // et on n’oublie pas de le désactiver
            }
            else
                ret[0][i++]=argv[argn];   // sinon, on ajoute l’argument à la liste des arguments qui ne sont pas des options
        }
    }
    return ret;
}

Pis j’ai un peu amélioré la propreté du code, aussi.

Pylades · Le 13/04/2010, à 23:04

tshirtman a écrit :

heu, c'est au programmeur appelant ton api de fournir la structure, toi tu peut la retourner remplie et c'est à peu prèt tout… si le codeur appelant n'est pas foutu de faire ça comme il faut, c'est son pb… sinon tu lui renvoir un pointeur vers une structure que tu as initialisé et remplie c'est au choix… dans ce cas c'est à lui de la free()… c'est un choix…

Je sais. En y réfléchissant, je pense que c’est une meilleure solution (demander une structure de plus en argument).

tshirtman a écrit :

tu devrais pas prendre ça pour un compliment…
développeur c'est un compliment, la différence entre les deux est assez importante… (hacker aussi est un compliment, c'est une autre destination que peut prendre le codeur, et la différence est importante aussi)

OK, noté.

kouskous · Le 13/04/2010, à 23:13

pierguiard a écrit :

c'est un forum francophone le mecs

Et ? Ça doit empêcher la culture ? Restreindre la liberté ?

helly · Le 13/04/2010, à 23:13

Mais plop !

tshirtman · Le 13/04/2010, à 23:14

Après y'a codeur et codeur, c'est assez neutre, mais bon, ça veux dire que tu as encore à apprendre c'est tout, sauf si tu te complait dans cet état, tu méritera alors le qualificatif de pisseur de code, c'est moin sympa ^^. Mais je pense que tu n'es pas limité à ça .

helly · Le 13/04/2010, à 23:17

Recherche image pour codeur :

c'est vous ça ?
/me a encore des progrès à faire sur l'anatomie masculine

compte supprimé · Le 13/04/2010, à 23:20

plop

Pylades · Le 13/04/2010, à 23:21

tshirtman a écrit :

tu peut lui demander de te passer la structure, ne faire aucune allocation et la remplir sinon…

Done.

analogfaz · Le 13/04/2010, à 23:21

burp,
oh pardon !

El Pensador · Le 13/04/2010, à 23:22

Plop de bonsoir

wiscot · Le 13/04/2010, à 23:26

Prout , oups , pardon..... plop (c'est mieux >< )

grim7reaper · Le 13/04/2010, à 23:26

@Pylade : c'est bien ce qui me semblait, c'est violent (commentaires suivants à prendre avec précautions car potentiellement issue d'une mauvaise interprétation due à mes yeux fatigués )

Tout d'abord

char** ret[2];
...
ret[0][i++]="-";

SIGSEV !!!
Ta déclaration correspond à ça

 ret[0]  ret[1]
---------------
|char**|char**| => valeurs aléatoires car indéfinies.
---------------

Donc ton ret[0][i++] est mauvais car tu n'as pas de 2nde dimension définit. Tu pointe sur une zone de mémoire aléatoire et tu te déplace (i++) allégrement dedans en écrasant tout sur ton passage, ça va violemment te péter à la gueule .
Donc là, déjà il va falloir une allocation ou définir une taille arbitraire genre "char* ret[2][128];".
La taille arbitraire ce n'est pas aberrant (les fonctions genre rm & cie ont une limite au niveau du nombre d'arguments comme je l'ai tristement découvert ), mais gère bien pour éviter les overflow. À toi de voir .

Ensuite

ret[0][i++]="-";

Future SIGSEV probable.
Une constante littérale entre double quote est remplacée implicitement pas un "char const*" contenant ta chaîne. Tu récupères donc l'adresse d'une variable locale, donc risque de gros ennuis lors des futures tentatives d'accès (SIGSEV ou UB=>Undefined Behavior=>comportement indéterminé). Sans compter que si tu en à plusieurs qui pointent sur "-", ça peut-être des adresses différentes ou identiques (comportement dépendant de l'implémentation donc variable d'un OS à l'autres, d'un compilo à l'autre, voire d'une version de compilo à l'autre ). Et puis, accessoirement tu fais pointer un char* sur un char const*, ça passe (parce que le C est permissif) mais c'est pas super clean.
La solution c'est du strcpy (ou strncpy, ou memcpy) pour travailler sur ta propre copie de la chaîne. Là encore, soit tu alloue dynamiquement ton "ret[0][i]" et tu copies, soit tu définit une taille arbitraire lors de la déclaration (genre "ret[2][128][1024];" , mais là on commence à quitter le domaine du facilement lisible, debuggable et maintenable ).

Enfin

return ret;

Là il n'y a pas le choix. Soit ret est globale, soit il est dynamique. Ce sont les seules options viables pour obtenir une portée adéquate.
Comme le global on va oublier (pleins de problèmes, je ne m'étendrai pas sur le sujet ici) on va donc partir sur du dynamique. Et là ça brille ! C'est du code de grand chef !! Du 4 étoiles !!!.
Et bah oui, il faut maintenant déclarer ret ainsi "char**** ret;" (ou on te le passe en paramètre, mais on reste dans 4 étoiles) et là pour tout le reste c'est de l'alloc en cascade (oublie les alternatives précédente (dynamique ou arbitraire), tu n'as plus le choix c'est du full dynamique maintenant).

Je pense que tu commences à entrevoir la lourdeur du traitement (en plus du contrôle des allocations et tout ce qui va avec, imagine aussi la fonction de libération...).

Conclusion
Le 3 étoiles, on y arrive, pas fréquemment certes, mais c'est couramment justifié et ça se manipule relativement bien à condition de prendre les précautions necessaires et de bien auditer le code (tests, gdb, valgrind & cie).
Le 4 étoiles, je n'ai jamais vu ça, et sauf cas rare, cela traduit une erreur de conception. Le code devient complexe, les erreurs sournoises, le debug cauchemardesque, la maintenance psychédélique, j'en passe et des meilleures .
Donc à moins d'avoir une argumentation en béton renforcé d'une armature en titane et une raison valable (i.e aucune alternative possible) il est fortement conseillé de revoir la conception et l'angle d'attaque du problème car il y a toutes les chances que tu te sois engagé sur une mauvaise voie.

À la base ton idée me semblait complexe mais réalisable (il me semble avoir vu un truc du même goût quelque part, moins abouti cependant). Mais la réalisation me semble bien trop lourde (peu souple et complexe).
Mon conseil (à suivre ou pas) : revois toute ton approche du problème (mieux vaut le faire maintenant que 1000 lignes de codes plus tard, avec des user qui t'envoient des rapports de bugs et te foutent la pression ).
Cependant, le bilan n'est pas totalement négatif. L'idée de la structure me semble bonne, c'est la mise en œuvre qu'il faut retravailler. En revanche, abandonne l'idée du double tableau de chaîne de caractère (implémente l'idée différemment si tu tiens à la conserver).

Je peux sembler casseur sur ce coup-là (je manque sûrement de pédagogie ), mais ce n'est pas mon but. Je préfère juste mettre les choses au clair dès le début plutôt que de te voir te lancer dans un truc "bancal" et tenter de coller des rustines après pour essayer de sauver les meubles (ce que font les devs Windows sur certains de leurs produits, on vois les résultats ).

Si tu trouves mon raisonnement peu clair, douteux ou carremment faux (c'est malheureusement possible, Cf. début du post pour les raisons) et bien signale le moi. Je serais prêt à eclaircir les points sombres, voire complétement revoir mon jugement s'il découle de mauvaise(s) interprétation(s).

Édit : j'ai vu que tu a posté une nouvelle version de ton code. Comme j'étais en train de rédiger l'analyse je ne l'ai pas vu, donc le pavé porte sur l'avant-dernière version (la première commenté). Mais je crois que les points soulevés sont toujours présent et identique, et donc que l'analyse reste d'actualité.

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

wiscot · Le 13/04/2010, à 23:28

helly a écrit :

Recherche image pour codeur :
http://www.planete-sciences.org/robot/c … age005.gif
c'est vous ça ?
/me a encore des progrès à faire sur l'anatomie masculine

changes de kernel , ça ira mieux .

wiscot · Le 13/04/2010, à 23:31

tiens helly , KDO:

[youtube]http://www.youtube.com/watch?v=zL6xgki326E[/youtube]

helly · Le 13/04/2010, à 23:33

@wiscrotte : dééééésolée ,j'ai plus flash

Dernière modification par helly (Le 13/04/2010, à 23:34)

grim7reaper · Le 13/04/2010, à 23:34

Il faudrai créer une balise [pavé][/pavé], ça éviterai d'encombrer et les gens qui s'en foutent n'auraient pas à subir mes sombres élucubrations .

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

helly · Le 13/04/2010, à 23:35

grim7reaper a écrit :

Il faudrai créer une balise [pavé][/pavé], ça éviterai d'encombrer aux gens qui s'en foutent de subir mes sombres élucubrations .

+1 !
mais aussi -1 : c'est un peu une des seules discussion qui POURRAIT être interessante actuellement

analogfaz · Le 13/04/2010, à 23:35

plop

wiscot · Le 13/04/2010, à 23:38

helly a écrit :

@wiscrotte : dééééésolée ,j'ai plus flash

J'vais te signaler désolé ><'

bon , j'me tire bonne nuit a tous .

Dernière modification par wiscot (Le 14/04/2010, à 01:28)

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#7426 Le 13/04/2010, à 22:33

Re : Topic des couche-tard (31)

#7427 Le 13/04/2010, à 22:38

Re : Topic des couche-tard (31)

#7428 Le 13/04/2010, à 22:39

Re : Topic des couche-tard (31)

#7429 Le 13/04/2010, à 22:40

Re : Topic des couche-tard (31)

#7430 Le 13/04/2010, à 22:50

Re : Topic des couche-tard (31)

#7431 Le 13/04/2010, à 22:51

Re : Topic des couche-tard (31)

#7432 Le 13/04/2010, à 23:00

Re : Topic des couche-tard (31)

#7433 Le 13/04/2010, à 23:04

Re : Topic des couche-tard (31)

#7434 Le 13/04/2010, à 23:13

Re : Topic des couche-tard (31)

#7435 Le 13/04/2010, à 23:13

Re : Topic des couche-tard (31)

#7436 Le 13/04/2010, à 23:14

Re : Topic des couche-tard (31)

#7437 Le 13/04/2010, à 23:17

Re : Topic des couche-tard (31)

#7438 Le 13/04/2010, à 23:20

Re : Topic des couche-tard (31)

#7439 Le 13/04/2010, à 23:21

Re : Topic des couche-tard (31)

#7440 Le 13/04/2010, à 23:21

Re : Topic des couche-tard (31)

#7441 Le 13/04/2010, à 23:22

Re : Topic des couche-tard (31)

#7442 Le 13/04/2010, à 23:26

Re : Topic des couche-tard (31)

#7443 Le 13/04/2010, à 23:26

Re : Topic des couche-tard (31)

#7444 Le 13/04/2010, à 23:28

Re : Topic des couche-tard (31)

#7445 Le 13/04/2010, à 23:31

Re : Topic des couche-tard (31)

#7446 Le 13/04/2010, à 23:33

Re : Topic des couche-tard (31)

#7447 Le 13/04/2010, à 23:34

Re : Topic des couche-tard (31)

#7448 Le 13/04/2010, à 23:35

Re : Topic des couche-tard (31)

#7449 Le 13/04/2010, à 23:35

Re : Topic des couche-tard (31)

#7450 Le 13/04/2010, à 23:38

Re : Topic des couche-tard (31)

Pied de page des forums