Un topic pour un noob en C - Page 1

Bon, j'ouvre mon topic de questions sur le C car Pollux j'imagines que tu dois en avoir marre de répondre a toutes mes questions

Donc deja, ce que j'utilise pour compiler :
Ma calc uniquement (V200) avec GTC (quasi-derniere version)

La syntaxe est donc particuliere il faudra faire attention dans ce topic

-----------------------------------------------------------------------------------

Deja, premiere question :
Lorsque je recupere les arguments donnés a mon prog, il vaut mieux les stocker comment ? Sous forme de tableaux dynamique ? Si oui, comment ?

(Je serais pas dispo d'un petit moment donc prennez votre temps )

Si tu as TGCC d'installer sur ton PC, regardes les exemples qui sont fourni avec.
Ce genre de questions standards y trouve sa reponse

Dude (./1) :
Lorsque je recupere les arguments donnés a mon prog, il vaut mieux les stocker comment ? Sous forme de tableaux dynamique ? Si oui, comment ?

C'est quoi comme programme? Si c'est un programme mathématique, il vaut mieux travailler directement sur la pile d'expressions.

C'est quoi comme arguments aussi? Les chaînes de caractères se traîtent différemment des nombres.

Ben tout le probleme est là en fait.
Là je suis en train de faire une structure "basique" de programme avec compilation conditionnelle. (Ca me servira pour plusieurs projets en meme temps)
Ca implique que je dois etre capable de recuperer n'importe quoi comme arguments et surtout, n'importe quel type d'argument.
Pour le moment je me cantonne a des chaines de caracteres.
Mais ensuite je prevois d'utiliser ca pour des arguments autres que chaines de caracteres et surtout, avec un nombre variable d'arguments.
Le top de serait de faire abstraction du type et de stocker tout ca sous forme de tableau dynamique non ?
On en avait déja un peu parlé Kevin, j'avait cru comprendre, mais finalement...
Bref, je vois pas trop comment faire ca, surtout que je me casse les dents sur les tableaux dynamiques a N dimensions, j'ai vraiment du mal

Eh bien moi je verrai un truc de ce genre, pour ta liste d'arguments universelle :

typdef struct {
                  enum {CHAINE, ENTIER, etc} type;
                  union {
                            char *chaine;
                            long  entier;
                            etc
                        } valeur;
              } t_argument;

t_argument *liste_darguments;

./5 Ne t'inquietes pas pour ca
La compilation conditionnelle ne me pose aucun probleme
Le seul truc qui me fait défaut là, c'est le moyen de stocker ce qu'il y a dans l'estack.
Et a priori le moyen le plus simple serait un tableau dynamique a N dimensions.
Mais, je vois bien autre chose aussi : copier l'estack et manipuler tout ca en interne apres...je sais pas trop...Des idées ?

./6 > Ah oué! C'est pas bete du tout ca!
Je vais y réfléchir et voir ce que ca donne
Merci pour ton idée

const char * serait mieux. Le pointeur mènera directement sur la pile d'expressions et tu n'es pas censé modifier le contenu de la pile d'expressions directement, sans passer par les push_*.

Et sinon, justement, ce n'est pas une bonne idée de faire un code de gestion d'arguments générique, parce que justement la meilleure solution dépend du programme!

Kevin Kofler (./9) :
const char * serait mieux. Le pointeur mènera directement sur la pile d'expressions et tu n'es pas censé modifier le contenu de la pile d'expressions directement, sans passer par les push_*.

Pas faux !

D'ailleurs, si tu veux alléger l'écriture, tu peux retirer l'identifiant valeurs;

 :typedef struct {
                   enum {
                             CHAINE,
                             ENTIER,
                             etc
                        } type;
                   union {
                             const char *chaine;
                             long        entier;
                             etc
                         };
               } t_argument;

t_argument *liste_dargument

Ca permet d'accéder aux éléments avec une écriture plus courte : liste_darguments[i].entier au lieu de liste_darguments[i].valeur.entier

Parce que tu utilises la difficulté de réinventer la roue (pour des trucs comme la sauvegarde de l'écran qui justement ne dépendent pas du programme) comme excuse pour ton FUD anti-_nostub.

./9 & ./10 Pas bete du tout pour const char * et valeur
Dès que j'ai le temps je m'y atèle Merci a vous

Un topic pour un noob en C

c'est gentil mais Jyaif est assez grand pour créer un topic pour lui même.

./15 > Nonon! J'insiste! xD

onur (./16) :

Un topic pour un noob en C

c'est gentil mais Jyaif est assez grand pour créer un topic pour lui même.

On sais que c'est toi le noob en C: la preuve tu veux coder en ETP !

en effet, je suis un noob en C. ETP je le code en C++

Oué mé Kévin il m'a di ke c'étai mal codé ton truc

Un autre probleme :
Enfin, le code suivant marche, mais je suis pas sûr de faire ca comme il faut (et surtout j'ai la vilaine impression d'écrire là où je ne devrais pas).
Alors si quelqu'un peut m'enlever ce doute... ^^

Là, ce n'est qu'un exemple, qui me sert a apprendre a manipuler les pointeurs...de pointeurs, et deja que j'ai du mal avec les pointeurs tout court...

Le code (tableaux dynamiques style JAVA -si j'ai bien compris-) : #define LIGNES 3 #define COLONNES 4 #define USE_TI89 #define USE_TI89TI #define USE_TI92PLUS #define USE_V200 #define NOSTUB #include <std.h> void afftab( unsigned char **matrice) {   unsigned char x = 0, y = 0;   while ( y < LIGNES) {     while ( x < LIGNES) {       printf("%u\n%u * %u",matrice[y][x],y,x);       ngetchx();       x++;       clrscr();     }     y++;     x = 0;   } } void __main(void ) {   unsigned char **matrice;   unsigned char x = 0, y = 0;   int i;   LCD_BUFFER svscr;   LCD_save(svscr);   clrscr();   // --- Alloc ---   matrice = malloc(sizeof *matrice * LIGNES);   if ( matrice != NULL)   {     // --- Alloc(Suite) ---     for ( i = 0; i < LIGNES ; i++)     {       matrice[i] = malloc(sizeof **matrice * COLONNES);     }     // --- Remplissage ---     while ( y < LIGNES) {       while ( x < LIGNES) {         matrice[y][x] = x++);       }       y++;       x = 0;     }     // ---Affichage---     afftab(matrice);     // ---Cleanup---     for ( i = 0; i < LIGNES ; i++)     {       free(matrice[i]);     }     free(matrice);   }   LCD_restore(svscr); }

Voilà, donc : qu'est-ce qui va pas ? Qu'est-ce qui pourrait etre amélioré ? J'attend vos avis
Merci d'avance pour vos réponses

Edit > Mise en page du source
Edit2 > Correction des indices & incrementations

C'est nul les tableaux style Java. Il vaut mieux utiliser des tableaux 2D contigus (les fameux pointeurs sur tableaux: int (*foo)[n];), c'est plus rapide et consomme moins de RAM (et moins de handles!).

Cf. http://tigcc.ticalc.org/doc/faq.html#37.

C'est nul de dire que sa façon de faire est nulle sans savoir son but.

Merci Kevin
Je me souviens avoir deja parlé de ca avec toi justement, et tu m'avais deja dit la meme chose, mais...ca ne repond pas a ma question
A savoir : est-ce que j'écris bien au bon endroit en faisant ca (lors du //remplissage) ? (On dirait bien, mais j'ai un vilain doute )

Kevin> Il se pourrait bien que j'ai besoin d'un tableau de N colonnes comprennant chacunes M_N éléments. Sauf que a la compilation, je ne connais, ni N, ni M_N

Edit> Si on peut "représenter" ca, ca donnerai :

_N0_____N1______N2_____N3_
0el0   1el0    2el0   3el0
  -    1el1    2el1   3el1
  -    1el2     -       -

(Ou '-' signifie : rien)

Le tableau de pointeurs fonctionne plutôt bien pour un tableau comme ça, mais du coup, je dirais que ta structure de données est foireuse.

Pour le cas où M_N ne dépend pas de N (c'est-à-dire le cas d'un M constant), on peut s'arranger même si on ne le connaît pas à la compilation (cf. tableaux à taille variable du standard C99).

Dude (./21) :
Le code (tableaux dynamiques style JAVA -si j'ai bien compris-) :#define LIGNES 3 #define COLONNES 4 #define USE_TI89 #define USE_TI89TI #define USE_TI92PLUS #define USE_V200 #define NOSTUB #include <std.h> void afftab( unsigned char **matrice) {   unsigned char x = 0, y = 0;   while ( y++ < LIGNES) {     while ( x++ < LIGNES) {       printf("%u\n%u * %u",matrice[y][x],y,x);       ngetchx();       clrscr();     }     x = 0;   }   return ; } void __main(void ) {   unsigned char **matrice;   unsigned char x = 0, y = 0;   int i;   LCD_BUFFER svscr;   LCD_save(svscr);   clrscr();   // --- Alloc ---   matrice = malloc(sizeof *matrice * LIGNES);   if ( matrice != NULL)   {     // --- Alloc(Suite) ---     for ( i = 0; i++ < LIGNES ; )     {       matrice[i] = malloc(sizeof **matrice * COLONNES);     }     // --- Remplissage ---     while ( y++ < LIGNES) {       while ( x++ < LIGNES) {         matrice[y][x] = x);       }       x = 0;     }     // ---Affichage---     afftab(matrice);     // ---Cleanup---     for ( i = 0; i++ < LIGNES ; )     {       free(matrice[i]);     }     free(matrice);   }   LCD_restore(svscr); }
Voilà, donc : qu'est-ce qui va pas ?

À cause des tests dans tes boucles for et while, tu vas commencer à allouer, afficher ou effacer à partir de l'indice 1 et non pas de l'indice 0 (il faudrait écrire "for (i = 0; i < N; i++)" ou mieux : "for (i = N; i--; )")

./26 > T'es sûr Zephir ?
Gros mauvais que je suis ca m'étonnerai pas remarque

Mais je pensais qu'en écrivant ca :
while ( i++ < LIGNES)
la post-incrementation se faisait apres évaluation de l'expression ce qui reviendrait a écrire while (i < LIGNES) puis qu'apres i était incrémenté (tout comme pour les 'for')
Mais comme les priorités d'évaluations je ne connais pas sur le bout des doigts, il est possible que je me soit planté

./25 > C'est vrai que je me complique peut-etre un peu la vie pour rien
Car si on regarde bien il vaudrait peut-etre mieux écrire dans ce cas :
unsigned char *monTab[COLONNES][]
non ? C'est a ca que tu fait allusion ?
[Edit]ou plutot ca : int (*foo)[n]; (C'est plutot a ca que tu fais allusion finalement ^^)[/Edit]
J'ai encore beaucoup de choses a apprendre moi

Dude (./27) :
./26 > T'es sûr Zephir ?
Gros mauvais que je suis ca m'étonnerai pas remarque

Mais je pensais qu'en écrivant ca :
while ( i++ < LIGNES)
la post-incrementation se faisait apres évaluation de l'expression ce qui reviendrait a écrire while (i < LIGNES) puis qu'apres i était incrémenté (tout comme pour les 'for')

Bah oui c'est le cas, mais si je prends une de tes boucles :

for ( i = 0; i++ < LIGNES ; )
{
    matrice[i] = malloc(sizeof **matrice * COLONNES);
}

La boucle for commence, i vaut 0. Le test est effectué, i vaut 0 donc le test est vrai, puis i est incrémenté : i vaut 1 quand le premier cycle commence.

De même, au dernier cycle : i vaut LIGNES - 1, le test est vrai, puis i est incrémenté. Tu rentres dans la boucle avec i = LIGNES.

Au final, ta boucle a tourné pour i = 1 à LIGNES au lieu de 0 à LIGNES - 1 : tu loupes l'indice 0, mais plus grave, tu dépasses de ton tableau au dernier tour de boucle.

Ah oui en effet!! #oooooooops#
Merci beaucoup Zephir
(Non mais quel gros mauvais je fais xD )

Le C est pas top à ce niveau là, t'en fais pas.

Ce que je trouve dommage avec les nouveaux langages comme le Java ou le C#, c'est qu'on régresse vers les performances et les possibilités limitées du Pascal, tout en gardant la syntaxe ambiguë et complexe du C.