Bonjour,  

Je suis entrain de lire le manuel sur le language c,  mais je suis en perdu sur les fonctions, notamment sur les exercices que vous avez donnés.

Je voudrais une correction si possible, parce je n'arrive pas à trouver de solution.

Salut,

Peux-tu me donner l'énoncé des exercices ?

Après si tu as besoin d'aide je peux t'aider à comprendre le principe des fonctions afin que tu réussisses par toi-même.

Salut, 

Pardon, j'ai loupé quelque part en écrivant. En fait je parlais des tableaux et non les fonctions, le point dans le cours c'est *Passage de tableaux à une fonction*.

Les exercices sont juste en desous, je n sais pas si je dois écrire les questions !!! 

Bonjour AlainKarhagomba,

Les membres du forum ne sont pas les auteurs du cours, ni les auteurs des exercices, ce sont des utilisateurs du site, comme toi, qui aident bénévolement les autres. J'ajouterais que nous ne sommes pas dans ta tête pour savoir exactement quel exercice te pose problème, ce que tu as essayé de faire, et sur quoi tu bloques et que sans ces informations personne ne peut t'aider.

Fournis le plus d'information possible sur ton problème.

Poste ton code sur le forum en cliquant sur le bouton </>, et il y aura certainement quelqu'un pour t'aider dans la mesure de leurs compétences et temps libre.

-
Edité par Dlks 3 juin 2021 à 15:35:42

Personne sur ce forum t'as donné d'exercice à faire et je suis trop faignant pour les chercher.

Mais je peux quand même t'aider à trouver des solutions à tes exercices, il suffit de faire une recherche sur ce forum et tu trouvera une multitude de corrigé de ces exercices.

Si ton problème consiste à donner en argument un tableau dans une fonction tu dois écrire ça en argument de ta fonction :

/*juste un prototype de fonction pour montrer l'exemple
* avec un tableau de int
*/
void test(int *tab);

//losrque tu appelles ta fonction tu lui donnes ton tableau ou/et son adresse

test(&tableau);
test(tableau);

Si tu lui donnes l'adresse avec '&' le pointeur de int en paramètre qui s'appelle tab ira sur l'adresse de ton tableau

Manah3 a écrit:

Si tu lui donnes l'adresse avec '&' le pointeur de int en paramètre qui s'appelle tab ira sur l'adresse de ton tableau

En principe quand on passe un tableau en argument à une fonction, on envoi l'adresse de son premier élément !

C'est justement ce que renvoi le nom du tableau seul sans artifice ex :

test(tableau);

Je ferais plutôt :

void test(int tab[], int taille);

1) On voit immédiatement que la variable à passer en argument est un tableau et non un pointeur (c'est pas pareil...)

2) En général on a besoin de connaître la taille.

Mais bon, il reste à attendre qu'AlainKarhagomba nous en dise plus (quel est l'énoncé de l'exercice, quelle est la difficulté)...

Une bonne pratique à commencer à mettre en œuvre est de préférer utiliser des déclarations comme :

void test(size_t taille, int tab[taille]);

C'est une recommandation dans la charte de la prochaine norme C23. Cela peut améliorer la lisibilité de certains prototypes et donner des indications au compilo pour des optimisations plus agressives.

White Crow a écrit:

Une bonne pratique à commencer à mettre en œuvre est de préférer utiliser des déclarations comme :

void test(size_t taille, int tab[taille]);

C'est une recommandation dans la charte de la prochaine norme C23. Cela peut améliorer la lisibilité de certains prototypes et donner des indications au compilo pour des optimisations plus agressives.

Ha ? ça y est, les VLA ne sont plus le mal ? goto va se sentir abandonné .

drx a écrit:

White Crow a écrit:

Une bonne pratique à commencer à mettre en œuvre est de préférer utiliser des déclarations comme :

void test(size_t taille, int tab[taille]);

C'est une recommandation dans la charte de la prochaine norme C23. Cela peut améliorer la lisibilité de certains prototypes et donner des indications au compilo pour des optimisations plus agressives.

Ha ? ça y est, les VLA ne sont plus le mal ? goto va se sentir abandonné .

Il ne s'agit pas de VLA, mais juste de la notation VLA. Les VLA restent optionnels.

drx a écrit:

White Crow a écrit:

Une bonne pratique à commencer à mettre en œuvre est de préférer utiliser des déclarations comme :

void test(size_t taille, int tab[taille]);

C'est une recommandation dans la charte de la prochaine norme C23. Cela peut améliorer la lisibilité de certains prototypes et donner des indications au compilo pour des optimisations plus agressives.

Ha ? ça y est, les VLA ne sont plus le mal ? goto va se sentir abandonné .

C'est vraiment une bonne chose de dire au revoir au Goto !! 🤩

Manah3 a écrit:

C'est vraiment une bonne chose de dire au revoir au Goto !! 🤩

Ce n'est pas ce qu'on a dit, et je ne vois pas pourquoi ce serait une bonne chose qu'il disparaisse. C'est utile, en tout cas ça m'est utile. Il ne faut pas l'utiliser à mauvais escient, mais ça sert. Perso, j'en ai dans presque toutes mes fonctions de construction, pour déconstruire proprement en cas d'erreur :

MyStruct* createMyStruct(void)
{
//construction
	MyStruct* result = malloc(sizeof(*result));

	if(!result)
		return NULL;

	result->picture = loadImg("toto.png");
  
	if(!result->picture)
		goto err_1;
	
	result->music = loadSong("tata.mp3");
  
	if(!result->music)
		goto err_2;
	
	return result;
  
//déconstruction propre
err_2:
	destroyPic(result->pic);
	
err_1:
	free(result);
   
	return NULL;
}

Après, je me suis fixé des règles comme ne jamais retourner en amont, c'est juste pour me diriger vers la sortie.

Bonne continuation.

-
Edité par drx 3 juin 2021 à 22:24:13

@drx:
Surprenant, je trouve ça élégant malgré tout
Ça évite de faire N fois le free() dans le code ...
Tu as sûrement programmé en assembleur autrefois (ou encore …)

C'est un style simple et élégant, assez ancien, et que l'on retrouve par exemple dans le code du noyau de linux. C'est en quelque sorte une façon de faire du try/catch/finally en C.

Une autre utilisation «acceptable», c.est-à-dire qui ne fout pas le bordel dans le flux, est de simuler un continue ou un break nommé quand tu as des boucles imbriquées ⇒

for( i=0; i<MAX_I; i++) {

    blablabla

    for( j=0; j<J_MAX; j++ ) {

        blablabla

        for( k=0; k<K_MAX; k++ ) {

            blablabla
            // ici on veut faire un break mais pour sortir de la boucle du i
            // et comme break i n'existe pas …
            if (machin) goto break_i;

            blablabla

            // ici en revanche on veut faire un continue sur le j
            // et comme continue j n'existe pas …
            if (truc) goto cont_j;

            blablabla

        }

        blablabla

        cont_j:
    }

    blablabla

}
break_i:

Il y a d'autres utilisations «valides» du goto, par exemple dans du code généré pour des automates à états.

On peut toujours se débrouiller sans les goto, mais en général ça embrouille le code, ça rajoute des variables dont le but est de gérer le flux … bref c'est pas folichon.

Un goto c'est comme un couteau :

• bien utilisé il coupera ta viande à la perfection, il fait ce pour quoi il a été prévu ;
• utilisé incorrectement comme un tournevis, il fera mal son boulot et tu te retrouve avec une maintenance de merde, un vis explosée impossible à changer sans te donner une tonne de boulot ;
• utilisé comme arme il fera sans doute correctement ton boulot mais peu de personnes comprendront le pourquoi du comment de ton geste et ne voudront pas te suivre dans ta folie.

White Crow a écrit:

Un goto c'est comme un couteau :

• bien utilisé il coupera ta viande à la perfection, il fait ce pour quoi il a été prévu ;
• utilisé incorrectement comme un tournevis, il fera mal son boulot et tu te retrouve avec une maintenance de merde, un vis explosée impossible à changer sans te donner une tonne de boulot ;
• utilisé comme arme il fera sans doute correctement ton boulot mais peu de personnes comprendront le pourquoi du comment de ton geste et ne voudront pas te suivre dans ta folie.

Géniale la comparaison. Très souvent on entend que le goto est le mal en ne pensant qu'aux 2 derniers cas, ceux que le débutant va envisager pour se débarrasser rapidement d'un problème au lieu d'aller chercher le bon outil.
J'ajoute juste qu'il faut justement utiliser le bon outil même pour couper et quand on veut plein de belles tranches (ce qui est le cas le plus fréquent), c'est la trancheuse à jambon la plus efficace (appelée for while ou if suivant le modèle!)

Je vois qu'on a de bons cuisiniers ...
J'aime bien l'idée du goto pour faire un break sur plusieurs boucles. Je n'ai jamais eu à le faire mais on ne sait jamais ...
Si je suis dans une fonction, le return fait souvent office de break/goto