Langage C

[Rockleader]

Effectivement Dzlogic il s'agissait bien de cela merci ! Et merci pour les précisions !

[Rockleader]

Autre question, quand au paramètre d'une fonction ou procédure; ne peut on pas inclure de tableau en argument d'une fonction ?


Par exemple, j'ai fait quelque chose de ce style là; mais cela ne passe pas au compilateur.

Code: Tout sélectionner

int triParInsertion(int Tab[int N]); /*1*/

int main()
{
/*fonction main*/
triParInsertion(T[nb]); /*T[nb rempli au préalable dans la fonction*/

return 0;

}
int triParInsertion(int Tab[int N]) /*2*/

{
/*corps de la fonction*/
return Tab[N]; /* qui serait donc trié après avoir été modifié par la fonction*/
}



Hors pour les lignes noté 1 et 2 en com le compilateur me dit qu'il attend une expression devant le int (à priori celui du N) mais j'avoue que je ne comprend pas ce qui coince; le C serait incapable de gérer l'espace mémoire d'un tableau à utiliser dans une fonction à moins de donner une valeur précise au maximum de valeur du tableau ? Auquel cas il est impossible de les manipuler en entrée de fonction.

[Dlzlogic]

Bonjour,
On peut passer n'importe quoi en paramètre de fonction.
En C, un tableau est une zone mémoire d'une certaine longueur connue (oublie les déclaration de longueur variable dont on a parlé) et qui commence à un certain endroit.
Je prends l'exemple de la fonction strcat. Son prototype est
char *strcat(char *dest, char *source);
Une chaine de caractère est un tableau. Sa longueur n'est pas écrite, mais c'est la position du zéro terminal qui la donne.
Mais je vais pas te faire un cours sur les paramètres des fonctions, et sur les tableaux, cela fit 2 chapitres très importants de C.

Le prototype d'une fonction qui prend un tableau en paramètre pourrait être
int Fonction(float Tab[], int N);
Mais il y a d'autres méthodes.

PS. tu peux faire l'économie d'un bouquin, certains t'ont dit que c'était pas la bonne méthode, mais là, c'est à dire sur ce type de sujet évoqué (paramètres, fonction, tableau, pointeurs) ça n'aurait pas été du luxe.
Je suis sûr que chez les bouquinistes, tu peux en trouver de pas chers.

[fatal_error]

effectivement, c'est pas du luxe, c'est du gachis.
le siteduzero de mémoire,
une simple recherche: how to pass an array in c suffit!

[Rockleader]

effectivement, c'est pas du luxe, c'est du gachis.
le siteduzero de mémoire,
une simple recherche: how to pass an array in c suffit!

Ce qui me gêne dans un bouquin c'est que c'est statique, alors que le langage lui peut évoluer d'une façon ou d'une autre.

On en a eu la preuve l'autre jour lorsqu'Ampholyte vous a appris qu'on pouvait déclarer des tableaux sans leur mettre une taille fixe au début.






Ensuite; merci pur le tableau en paramètre, quand on y réfléchit c'est logique; mais je peux pas l'inventer^^en cours on fait surtout de la spécification de programme et au final on a aucune syntaxe c'est à nous de les rechercher.


Effectivement la prochaine fois j'irai faire un tour sur le sdz; je crois me rappeler que le tuto de matéo sur le C était plutôt bien fait lorsque j'y avais jeté un coup d’œil il y a quelques années è_é

Merci à vous deux.

[fatal_error]

je sais pas trop ce qu'Ampholyte m'a appris, mais en tout cas

Code: Tout sélectionner

/* En C99 l'écriture suivante est autorisée */
int N = 0;
scanf("%d\n", &N);

int tab[N] = {0};


c'est un code faux.
N n'est pas connu à la compilation.

On peut en revanche effectivement déclarer un tableau sans mettre une taille fixe si on l'initialise:
int a[]={1,2,3};
char* s="toto";

edit: oui effectivement en C99 on a les arrays avec taille non connue à la compilation
http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444
edit: et la doc de GCC
http://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html

[Dlzlogic]

Je crois tout de même utile que certaines choses soient dites.
Depuis la version C99, il n'est pas obligatoire de fixer la dimension d'un tableau.
Donc apparemment (j'ai pas vérifié, puisque je n'ai pas gcc) le code suivant est bon
int Fonction(int N)
{
float Tab[0];
...
}
Cependant, je déconseille à Rockleader d'utiliser cela.
Par contre, le code suivant se compilera sans difficultés
{
char *s="toto";
}
Mais provoquera très probablement des catastrophes à l'exécution.
Question à fatal_error : ça t'est arrivé souvent d'initialiser un tableau, autrement d'à zéro, au moment de sa déclaration ?

[Rockleader]

Code: Tout sélectionner

/* En C99 l'écriture suivante est autorisée */
int N = 0;
scanf("%d\n", &N);

int tab[N] = {0};

Pour reprendre le code cité par fatal.

Ici, int N=0 je pense ne sert à rien étant donné que N est modifié dans le scanf par l'utilisateur.

Ensuite je ne pense pas qu'il soit utile, ni "logique" dans la mesure ou N peut être quelconque d'affecter la valeur 0 dans la tableau tab[N]


En réalité le code suivant passerait très bien sous gcc.

Code: Tout sélectionner

int N;
scanf("%d\n", &N);

int tab[N];

A priori écrire cela à l'air de vous choquer, mais franchement moi ça ne me choque pas plus que ça; que l'on attribue une valeur précise à N ou qu'on laisse cette valeur se décidé à l’exécution, le programme est obligé d'allouer un espace mémoire pour N; à partir de là peu importe ce qu'on met dedans.

En tout cas c'est comme ça que je vois les choses; et ça permet de ne pas avoir des tableaux trop grand ou petit par rapport à notre problème étudié. Au final on a directement la taille effective équivalente à la taille réelle.

[fatal_error]

ben que ca te choque ou pas, c'est pas dans la norme ANSI(c90) (mais c'est dans celle du C99)

Quant à gcc, je sais pas comment tu compiles, mais si tu compiles en c89 ou ansi, pedantic, tu verras que tu te prends un warning

Code: Tout sélectionner

gcc -std=c89 -pedantic-errors main.c -o test
main.c: In function ‘test’:
main.c:4:2: erreur: ISO C90 forbids variable length array ‘a’ [-Wvla]

voir http://gcc.gnu.org/onlinedocs/gcc/Warnings-and-Errors.html , pour les options

[Dlzlogic]

Bonjour, Rockleader,
Décidément tu as l'esprit de contradiction, et aussi plein d'idées sur pas mal de choses.
Je te rappelle que tu es au B-A-Ba de l'apprentissage du C. En la matière, il n'y a pas à trouver cela logique ou pas. Le C est un langage, il sert d'interface entre l'homme et la machine. Il a été écrit par des individus MM. Kernigham et Ritchie. Plus tard, d'autres sont intervenus pour modifier certaines choses, elles ne sont ni plus ni moins logiques qu'avant.
Par ailleurs tu n'as rien compris à la ligne int tab[n]={0};
Quand tu voudras écrire un langage, tu pourras le faire, mais pour l'instant, tu demandes de l'aide, on te donnes des conseils, tu en fais ce que tu veux, mais surtout évite de donner ton avis.
N'oublie pas pas que sur ces sujets, c'est toi qui poses les questions, c'est pas toi qui nous expliques.

[Rockleader]

Dzlogic; je ne sais pas pour toi, mais je n'aime pas apprendre des trucs pour apprendre...je pense qu'il est toujours mieux de faire son propre avis sur la chose plutôt que de toujours recopier bêtement des choses que l'on ne comprends pas.

En parlant de ne pas comprendre, tu m'affirmes que je n'ai pas compris la ligne int tab[n]={0}

J'accepte cette remarque; mais derrière tu n'expliques pas ce que je n'y aurais pas compris, donc bon...loin de moi la prétention d'expliquer des choses; mais tu ne m'empêcheras pas de donner mon avis, car un avis c'est ce que l'on retient de ce que l'on a appris; donc oui je préfère te donner mon avis plutôt que des truc appris par cœur sans réfléchir.
Tu n'as peut être pas la même méthode; mais moi c'est comme ça que je fonctionne, je préfère toujours me poser des questions sur ce que j'apprends.




Pour fatal; la ligne qui se lance sur windows quand on compile à partir de code block est la suivante:

mingw32-gcc.exe -c adresse.c -o adresse.o

Donc à priori on n me précise pas si c'est du c89 ou 99; ou alors je ne regarde pas au bon endroit; ou alors c'est encore autre chose.

Je vais de ce pas jeter un oeil sur le lien.

[Dlzlogic]

Excuse ma brutalité, mais étant donné qu'au bout de 3 ans d'informatique, tu sembles être toujours au point de départ, ta méthode ne parait pas la meilleure.
Généralement quand on demande de l'aide et des conseils, c'est qu'on est prêt à les accepter.
Si Fatal et moi te disons de déclarer un tableau avec une dimension connue, fais-le et passe à autre-chose.
Par exemple renseigne-toi sur l'initialisation, c'est une notion fondamentale.

[Doraki]

En réalité le code suivant passerait très bien sous gcc.

Code: Tout sélectionner

int N;
scanf("%d\n", &N);

int tab[N];

A priori écrire cela à l'air de vous choquer, mais franchement moi ça ne me choque pas plus que ça;

Et que penses-tu du code

Code: Tout sélectionner

int N;
int tab[N];

?

[fatal_error]

Si Fatal et moi te disons de déclarer un tableau avec une dimension connue

Je ne partage pas cet avis.

Tu as raison de poser les questions quand tu comprends pas plutot que d'appliquer betement.

Maintenant il est clair qu il manque la demarche de chercher l information par soi meme (en meme temps pe qu il y a plein de sujets que tu ne poses pas parce que tu as cherche toi meme, mais dans tes interventions on a l impression qu il n y a pas grand effort fait :s)

Que ce soit les flux, les options de compilation ou encore la syntaxe du langage.

[Dlzlogic]

Donc, manifestement il parait nécessaire d'expliquer le problème de l'allocation mémoire, de la libération de mémoire.
Lorsque le compilateur transforme un code écrit par un humain, en code machine, il effectue un certain nombre d'opérations : en vrac vérification de la syntaxe, les mots clé, la ponctuation, les opérateurs etc.
Puis il vérifie l'indépendance des blocs, c'est à dire en gros, la parité des accolades, des parenthèses, des crochets etc.
Puis il commence à écrire son code. Il y a des traitements linéaires, des sauts, des adresses etc.
Quand il trouve un tableau, il doit réserver un espace mémoire. Ca se manifeste par un début et une longueur. Le début, c'est pas dur, par contre, pour la longueur, il y a deux solutions
- soit c'est une longueur connue définie par une constante, éventuellement par une directive de compilation (#define), auquel cas, c'est pas dur
- soit c'est une longueur actuellement inconnue, alors le programmeur a dû prévoir dans son code une fonction d'allocation de mémoire (malloc ou calloc) pour l'attribuer à un tableau. Le programmeur devra savoir qu'il doit libérer cet espace mémoire quand il n'en aura plus besoin.

Dans la version C99, apparemment, les auteurs ont prévu de faire cette allocation mémoire, ainsi que sa libération, automatiquement, si aucune des deux méthodes que j'ai décrites n'a été utilisée par le programmeur. La grosse qualité du C, à mon avis, est qu'on sait toujours ce qu'on fait, pourquoi, ce qui se passe etc. Là, justement, dans cette allocation automatique, c'est un cas où on ne sait pas ce qui se passe, il n'y a pas de possibilité de contrôle (sauf try ... catch, mais je sais pas si c'est vraiment portable).

Donc, puisque tu veux savoir toutes les explications, maintenant, tu sais, mais j'ai essayé de simplifier.
Il a fallu que je lise beaucoup et pendant longtemps avant de comprendre le début de ces choses;
Lorsque dans mon bouquin il est écrit "pour faire ceci, faites cela", je le fais et je comprends pourquoi quelques années plus tard.

[ampholyte]

Bonjour,

Je me permets d'apporter une petite précision.

Comme il a déjà été dit et re-redit, la meilleure façon de progresser c'est de fouiller, pratiquer, fouiller, pratiquer.

Tu as une question ? Tu fouilles sur le net, dans la doc. Les questions que tu te poses ont déjà été traitées des centaines et des centaines de fois.

Pour rappel, il est toujours mieux d'initialiser ces variables pour connaître l'état de la mémoire à l'instant T donnée.

Code: Tout sélectionner

int N; /* Je ne connais pas la valeur de N */
int N = 0; /* Je sais que N vaut 0 */


En reprenant l'exemple précédent :

Code: Tout sélectionner

int N = 0;
scanf("%d", &N);


Ta remarque était plus que justifier. Quel interêt d'initialiser N à 0 sachant qu'on l'initialise depuis le scanf. Tout simplement parce que le jour où tu décides d'initialiser N autrement tu seras qu'au départ il vaut 0. (On verra un exemple d'erreur possible)


Concernant l'initialisation de tableau en C standard. Personnellement je ne recommande pas d'utiliser l'allocation de tableau à taille variable si on ne comprend pas correctement l'allocation dynamique. C'est un choix personnel de ne pas utiliser ce genre de chose. Je préfère un bon calloc / realloc / free.

Il y a plusieurs manières d'initialiser un tableau :

Code: Tout sélectionner

/* Méthode 1 */
int tab[5];
tab[0] = 0;
tab[1] = 0;
tab[2] = 0;
tab[3] = 0;
tab[4] = 0;

/* Avec une boucle for */
int tab[5];
int i = 0;
for (i = 0; i  Impossible de le savoir.

[CODE]int tab[10];
int i = 0;

printf("%d", tab[i]);


Même problème le tableau n'étant pas initialisé, il est impossible de savoir ce qu'il contient.

J'espère que tu auras compris l'importance de l'initialisation.

[Rockleader]

Excuse ma brutalité, mais étant donné qu'au bout de 3 ans d'informatique, tu sembles être toujours au point de départ, ta méthode ne parait pas la meilleure.
Généralement quand on demande de l'aide et des conseils, c'est qu'on est prêt à les accepter.
Si Fatal et moi te disons de déclarer un tableau avec une dimension connue, fais-le et passe à autre-chose.
Par exemple renseigne-toi sur l'initialisation, c'est une notion fondamentale.

*Un an seulement^^j'ai bien bidouillé avant mais je n'ai jamais eu de véritables cours à proprement parlé.

J'accepte les conseils; ne crois pas que ce que vous me dites tombe dans l'oreille d'un sourds, derrière je fais des test, c'est en forgeant que l'on devient forgeron.


J'admet ce que fatal vient de dire; je passe souvent une bonne demi heure si ce n'est plus sur des erreurs; lorsque c'est une erreur de logique je fini par la débusquer et la corriger; mais lorsque cela vient de la syntaxe, c’est vrai que j'ai souvent tendance à demander sans chercher au préalable je vous l'accorde.

En revanche si je poste un code qui ne fait pas un résultat attendu (en fait c'est que la construction de l'algo est mauvaise ou que son codage est mal interprété); je ne poste jamais ce genre de soucis sans y avoir bien réfléchie avant.

Et que penses-tu du code
Code:
int N;
int tab[N];

Là tout de suite, je ne peux pas le tester; mais en répondant à chaud pour moi ça ne passe pas la compilation car dans ton bout de code N ne sera jamais initialisé.

Ta remarque était plus que justifier. Quel interêt d'initialiser N à 0 sachant qu'on l'initialise depuis le scanf. Tout simplement parce que le jour où tu décides d'initialiser N autrement tu seras qu'au départ il vaut 0. (On verra un exemple d'erreur possible)

Je comprends mieux pourquoi tu avais écris cela; en revanche, je vais à présent t'expliquer pourquoi moi je ne le fais pas, j'ai peut être tort, mais c'est ce que j'ai cru être une bonne méthode jusqu'à aujourd'hui; et si ce n'est pas la bonne, je serais ravis de changer en sachant ce que cela apporte de mauvais.



Bref; pourquoi je n'initialise pas les valeurs d'un tableau avant de commencer à le traiter; tout simplement car si je fais une coquille dans mon algorithme; comme tu dis lorsque j'afficherais le contenu de la case d'un tableau, je vais avoir un nombre aléatoire donné au hasard à la création du tableau.

Ainsi donc si je vois 58595095 en faisant un affichage d'une case je verrais bien qu'il y a un problème à la l'excécution; alors que si j'initialise a valeur à 0...et que derrière j'ai un programme qui me calculera des valeurs faisant éventuellement intervenir un 0 (ce qui n’est pas même pas si rare que ça) je ne détecterai pas l'erreur au premier coup d’œil.

Tu me diras ça dépend donc de ce que fera le corps du programme.






Ensuite, pour la taille fixe du tableau; l'an dernier en ada, on nous a souvent bassiner qu'il était plus pratique d'utiliser des tableau à taille variables; mais que le langage ne permettait pas cette option, on était obligé de mettre une valeur maximale.
Si tu as une spec qui te dit que tu dois traiter les valeur entre 0 et 500; bon bah ok tu déclare ton Tab[500] ou Tab[N] en ayant au préalable défini N en constante. Là je vous rejoins.


Maintenant si tu n'as pas de spec; l'utilisateur entre 600 alors que ta taille max est à 500...ok tu peux faire boucler ton prog pour obligé l'utilisateur à faire ça, mais si lui n'a pas besoin de tester ton prog sur 500 mais 600 et qu'il ne peut pas, il va juste fermer le programme et aller en chercher un autre qui lui permettra de faire cela car le tien ne répondra pas à ses attentes.


Je dirais donc (et oui c'est mon avis^^) taille fixe lorsqu'on a une spec donné ou que l'on s'en impose une; mais dans le cas où l'on est pas sur de l'utilisation qui sera faite; une taille variable me semble plus adapté.



Maintenant comme Dzlogic l'a souligné; après un an, je n'en suis encore qu'au tout début; on peut dire que le c est réellement le premier langage que j'apprend vu qu'ada reste quand même un langage que je vais qualifier "d'esthétique" mais qui ne sera pas trop prêt du niveau machine. Mais je préfère grandement discuter de ce que je pense d'une utilisation de telle ou telle structure plutôt que d'appliquer bêtement la première que l'on va me donner.


Cela dit on est d'accord, à l'avenir j'essaierais de faire un peu plus de recherches avant de poster :lol3:

[ampholyte]

Ainsi donc si je vois 58595095 en faisant un affichage d'une case je verrais bien qu'il y a un problème à la l'excécution; alors que si j'initialise a valeur à 0...et que derrière j'ai un programme qui me calculera des valeurs faisant éventuellement intervenir un 0 (ce qui n’est pas même pas si rare que ça) je ne détecterai pas l'erreur au premier coup d’œil.

Tu me diras ça dépend donc de ce que fera le corps du programme.

Le problème est que c'est une mauvaise façon de déboguer ton programme.

Si N = 1049503859 tu vas donc déclarer un tableau de cette même taille. Imagine la capacité mémoire que cela consomme.

1 ) Supposons que l'on déclare un tableau de long double. Tu vas donc avoir une consommation mémoire de 1049503859 * 10(octets) = 10495038590 octets c'est à dire (en gros) 10 000 Mo soit 10Go de mémoire ce qui ne pourra jamais fonctionner sur un PC standard. Ton programme va planter et ton PC aussi pour le coup x).

Du coup est-ce que tu penses que c'est une bonne solution ?

2) Supposons que ton N = 0 (cela peut arriver !) du coup ton exemple précédent n'est plus valable.

Très souvent (comme pour le main) 0 signifie que tout s'est bien passée et 1 signifie qu'une erreur a eu lieue (ou une autre valeur). Je ne vais pas te faire un cours sur les erreurs, mais il existe des solutions pour voir ce qu'il se passe en mémoire et executer ton programme étape par étape.

Ensuite, pour la taille fixe du tableau; l'an dernier en ada, on nous a souvent bassiner qu'il était plus pratique d'utiliser des tableau à taille variables; mais que le langage ne permettait pas cette option, on était obligé de mettre une valeur maximale.
Si tu as une spec qui te dit que tu dois traiter les valeur entre 0 et 500; bon bah ok tu déclare ton Tab[500] ou Tab[N] en ayant au préalable défini N en constante. Là je vous rejoins.

Je suis d'accord, sauf quand tu as besoin d'optimiser la mémoire. Supposons que je possède au maximum 10 000 valeurs.

Est-ce vraiment judicieux de déclarer un tableau de 10000, si l'on souhaite entrer une seule valeur ? A ton niveau tu n'en es pas encore à ce stage mais c'est bien d'avoir un aperçu de la consommation mémoire d'un programme.

Pourquoi utiliser 40 000 octets (tableau de int sur 32bits) alors que 4 octets peuvent suffir ?

[Rockleader]

Je pense que l'on va tout de même commencé à y toucher un peu avec les cours de complexité.

[Dlzlogic]

Bonjour,
Ce qu'a expliqué Ampholyte concerne la bonne gestion de la mémoire, les manières d'éviter les erreurs (ie, pas la façon d'en faire moins, mais la façon d'en faire pas du tout).
Les problèmes liés à la complexité concernant les algorithmes beaucoup plus que la gestion de la mémoire et l'art de la bonne programmation.