Traduction d'un algorithme

Version imprimable

Salut à tous, je suis débutant en C et je cherche à traduire un algorithme :roll:

Franchement, j'ai fait ce que je pouvais car ça fait 2 jours que j'ai commencé le langage C. J'aimerais bien un peu d'aide et surtout quelques explications.

Voici l'algorithme :

Citation:

programme essai ;
contante LG_MAX<Entier> = 100 ;
type TabEntier = tableau[1..LG_MAX] de <Entier> ;

procédure ajouter(maj t <TabEntier>, maj n <Entier>, entrée v <Entier>)
Début
t[n+1] ← v ;
n ← n + 1 ;
fin ;

procédure ajout2V(maj t <TabEntier>, maj n <Entier>, entrée v1 <Entier>,
entrée v2 <Entier>)
Début
ajout(t,n,v1) ;
ajout(t,n,v2) ;
fin ;

procédure lireSécu(sortie c <Entier>)
Glossaire
chC <Chaine au format C> ;

Début
lire(chC) ;
c ← convertirAsciiEnEntier(chC) ;
fin;

procédure lireEntier(sortie c <Entier>)
Début
écrire(« qu'elle est la valeur de l'entier ? ») ;
lireSécu(c) ;
fin;

//programme principal

Glossaire
tablo<Tabentier> ;
nbElem<Entier> ;
in1 <Entier> ;
in2 <Entier> ;
choix<Caractère> ;
continuer< Chaine au format C>;

Début

nbElem ← 0 ;
écrire(« Faut-il continuer oui(yes) ? »);
lire(continuer) ;

tantque (continuer = « OUI ») ou (continuer = « yes ») faire
écrire(« Faut-il saisir 1 ou 2 valeurs ? »);
lire(choix);

si choix = 1 alors
lireEntier(in1) ;
ajout(tablo,nbElem,in1) ;

sinon

si choix = 2 alors
lireEntier(in1) ;
lireEntier(in2) ;
ajout2V(tablo,nbElem,in1,in2) ;

sinon

écrire(« Choix invalide »);

finsi ;
finsi;

écrire(« Faut-il continuer oui(yes) ? »);
lire(continuer) ;

fintantque;

fin.

et Voila ce que j'ai fait bien entendu ça ne marche pas :calim2:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 # include <stdio.h> const int LG_MAX = 100; typedef int TabEntier[LG_MAX]; void ajouter (Tabentier t[],int n,int v) { t[n+1]=v; n=n+1; } void ajout2V (Tabentier t[],int n,int v1,int v2) { ajout(t,n,v1); ajout(t,n,v2); } int lireSecu() char chC[100]={0}; { scanf("%s",chC) int c = (int) cHC; } int lireEntier() { printf("qu'elle est la valeur de l'entier ?"); lireSecu; } /*******************************************************************/ /* programme principal */ /*******************************************************************/ int main TabEntier tablo; int nbElem; int in1; int in2; char choix; char continuer[100]={0}; { nbElem=0; printf("faut-il continuer oui(yes) ?"); scanf("%s",continuer); while (continuer = "oui") or (continuer = "yes") { printf("faut-il saisir 1 ou 2 valeurs ?"); scanf("%c",choix); switch(choix) { case '1' : lireEntier(in1);ajout(tablo,nbElem,in1);break; case '2' : lireEntier(in1);lireEntier(in2);ajout2V(tablo,nbElem,in1,in2);break; default : printf("Choix invalide"); } printf("faut-il continuer oui(yes) ?"); scanf("%s",continuer); } }
Merci d'avance pour l'aide:D

14/04/2016, 08h32
ternel

Et ton ca marche pas, il se présente comment?
parce que déclarer un int (global) nommé main, pour moi, c'est un suicide.

Supprime toutes tes variables globales.

Les paramêtres sont passés par valeurs, c'est à dire que liors de l'appel d'une fonction, des variables locales sont déclarées, avec la valeur donnée lors de l'appel.
Ainsi, toute modification faite par la fonction sur ses paramètres ne sont faites que sur ces variables, pas sur les variables de l'appelant.

La solution à ce problème, en C, est d'avoir des pointeurs en guise d'argument, et d'appeler avec l'adresse de la variable à modifier.
14/04/2016, 09h23
dalfab

Bonjour,
Il y a des erreurs de syntaxe qui font que le programme n'a pas de sens.
* Dans une déclaration de fonction, on ne doit rien mettre entre la liste des paramètres et le corps (tu as pu voir des exemples le faisant sur du très vieux C). Regarde ta fonction lireSecu() et ta fonction main().
* La syntaxe du 'if'/'while'/'switch' doit être suivi d'une unique expression entre parenthèses. Il faut remplacer while (continuer = "oui") or (continuer = "yes"){ par while ( strcmp(continuer,"oui")==0 || strcmp(continuer,"yes")==0 ) {.
* La comparaison des chaînes ne se fait pas par un '==' mais par une fonction, exemple ci-avant.
Comme dans tout langage, il est impératif d'apprendre un minimum les règles sinon tu n'y arrivera pas.
14/04/2016, 09h26
jopopmk
Citation:

Envoyé par leternel

[..]parce que déclarer un int (global) nommé main, pour moi, c'est un suicide.[..]

Je pense que c'est l'entête de sa fonction, en fait il a traduit "texto" son pseudo-code.
On a d'ailleurs une autre version google trad like ici :
Code:

1 2 3 4 5 6 7 8 9 // entête int lireSecu() // variable locale char chC[100]={0}; // corps de fonction { scanf("%s",chC) int c = (int) cHC; }
En gros, guwop, avant même de voir le fonctionnement du passage de param par pointeur, il va falloir regarder comment écrire correctement une fonction en C. Peut-être que cette page te sera utile et n'hésite pas à parcourir quelques tuto.

Citation:
Envoyé par guwop
franchement j'ai fait ce que je pouvais car ça fait 2 jours que j'ai commencé le langage C , j'aimerai bien un peu d'aide et surtout quelques s'explications
Code:

1 2 3 4 5 void ajouter (...,int n,...) { ... n=n+1; }
Bonjour

Ce genre de syntaxe ne peut pas fonctionner en C. Parce qu'en C, un type simple (int, char, etc) est passé par "recopie" à une fonction. Il en résulte qu'en écrivant n=n+1, tu ne fais que incrémenter une variable interne à ta fonction, variable qui sera supprimée quand la fonction se termine. Mais rien ne remontera à l'appelant.
Donc en imaginant que tu écrives
Code:

1 2 3 4 5 int main() { int x=100; ajouter(..., x, ...); }
Ben ton x restera quand-même à 100. Et donc sans utiliser l'outil adéquat, tu ne peux pas faire modifier ta variable dans une fonction.

L'outil adéquat est l'adresse. Si tu passes l'adresse (mémoire) de ta variable à ta fonction, celle-ci pourra alors taper dans la zone associée à cette adresse (donc la variable) et si elle modifie cette zone, la variable liée sera alors réellement modifiée.
Cela se traduira, dans le main, de cette façon
Code:

1 2 3 4 5 int main() { int x=100; ajouter(..., &x, ...); }
Et ta fonction, qui reçoit une adresse, devra alors la stocker dans un pointeur (type de variable permettant de stocker une adresse). Et un pointeur se déclare toujours en indiquant le type de ce vers quoi il pointe (ici "int"), cela donnera dans ta fonction
Code:

1 2 3 4 5 void ajouter (...,int *n /* ou int* n signifiant "n est un pointeur sur un int" */,...) { ... (*n)=(*n)+1; // La zone qui est "pointée par n" récupère la valeur qui s'y trouve incrémentée de 1 }
Ce problème ne se pose pas pour le tableau car le nom d'un tableau est déjà une adresse (donc c'est le vrai tableau qui est modifié).

Mais malheureusement, en 2 jours de C je ne pense pas que tu aies acquis de bases suffisamment solides pour t'attaquer à la compréhension des pointeurs...

merci les gars j'ai une bonne note grâce à vous :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <stdio.h>    
#include <stdlib.h>   
#include <string.h>  
#define TMAX 100
 
 
 
void ajout ( int t[],int *n, int v)     
{                                   
 
 t[*n+1] = v;
 *n=*n+1; 
}
 
void ajout2V ( int t[],int *n, int v1 , int v2) 
{
	ajout(t,n,v1);
	ajout(t,n,v2); 
}
 
 
void liresecu(int *c)  
{
char chC[];           
     gets(chC);       
 
	*c=atoi(chC);      
 
}                      
 
void lireEntier (int *c) 
{
 
	printf("qu'elle est la valeur de l'entier ?\n");
	liresecu(c);									 
 
}
 
 
 
 int main(void)
{
 
 int tablo[]; 
 int nbElem;
 int in1;
 int in2;
 int i;
 char choix[];
 char continuer[];
 
 
 nbElem=0;
 
 
 
 printf("Faut-il continuer oui(yes) ?\n");
 gets(continuer);
 
 
 
               // le symbole "==" designe une égalité(comparer) et "||" un "ou" logique  
 while (strcmp(continuer,"oui")==0 || strcmp(continuer,"yes")==0 )
	{                                                              
 
	printf("Faut-il saisir 1 ou 2 valeurs ?\n");                   
 gets(choix);	                                                 
 
 
		switch(atoi(choix)) 
		{ 	
		case 1 : lireEntier(&in1); ajout(tablo,&nbElem,in1);break; 
		case 2 : lireEntier(&in1); lireEntier(&in2);ajout2V(tablo,&nbElem,in1,in2);break;
		default : printf("Choix invalide\n");
		}
 
		printf("faut-il continuer oui(yes) ?\n");
		gets(continuer);
 
	}
 
 
 
 
 return 0;
}

le prof n'as pas mis tout les points à cause de

Citation:

switch(atoi(choix))

je ne sais pas pourquoi mais bon c'est pas grave

11/06/2016, 08h50
Sve@r
Bonjour

Citation:

Envoyé par guwop

le prof n'as pas mis tout les points à cause de switch(atoi(choix)) je ne sais pas pourquoi mais bon c'est pas grave

Parce que ça
Code:

1 2 3 4 void liresecu(int *c) { char chC[]; gets(chC);
Où tu vas remplir une zone qui n'a pas de taille précise avec un nombre de caractères potentiellement infini ça ne l'a pas fait tiquer ???

Bon ben bonne chance quand tu coderas pour de vrai...
11/06/2016, 11h39
guwop

c'est en faisant des erreurs qu'on apprend ;)
19/06/2016, 10h54
Sve@r

Citation:

Envoyé par guwop

c'est en faisant des erreurs qu'on apprend ;)

En général oui... mais pas en C.

Parce que le C a un détail particulier qui en fait sa force: il ne vérifie jamais rien. Les concepteurs l'ont en effet conçu dans la philosophie "le programmeur sait ce qu'il fait". Ainsi rien ne t'intedit de définir un tableau de 10 ints et d'aller taper à loisir dans l'élément [15] ou [150] ou [-1] de ton tableau. Le compilo ne te dira absolument rien et même dans 90% des cas le programme fonctionnera sans problème immédiat. On nomme ce genre de conséquence un "comportement indéterminé" c'est à dire imprévisible. Donc tu ne peux pas prévoir son comportement. Tu n'as même pas le droit de dire "ça va planter" car dire ça c'est déjà faire une prévision ce qui va à l'encontre de la définition de "imprévisible".

Donc ça peut fonctionner. Ca peut aussi planter. Ca peut aussi fonctionner les jours pairs et planter les jours impairs (parce que par exemple tab[15] va taper dans une autre variable qui gère ta date) et dans ce cas bonjour pour trouver le bug !!!. Ca peut aussi te rebooter ton PC ou reformater ton dd (bon là je déconne car il y a des sécurités au niveau de l'OS mais c'est pour illuster au maximum ce que veut dire "imprévisible").

Donc cette philosophie fait la force du C (aucun contrôle donc toutes les ressources consacrées à faire tourner le code le plus vite possible) mais aussi une faiblesse pour le débutant.

Et donc en attendant que tu aies assez d'expérience pour avoir des chances de ne pas produire de "comportement indéterminé" c'est à ton prof de veiller au grain et te prévenir ce qu'il n'a pas fait d'où ma remarque précédente ;)
19/06/2016, 13h13
guwop

Merci , pour ton point de vue ,car je ne voyais vraiment pas les choses comme cela