Absence d'une variable dans la sortie

**Redgard** · 11/01/2018, 17h35

Bonjour à tous et merci de prendre le temps de me lire.

Débutant en C, je réalise un petit programme prenant un verbe, extrayant sa racine puis le conjuguant au subjonctif.

Or il semblerait que je rencontre un problème avec ma fonction VerbRacine qui ne renvoie pas comme j'ai prévu la racine du verbe. Je présume que c'est parce que je l'ai mal pensé, mais je n'arrive pas très bien à comprendre pourquoi... :s

Si quelqu'un a une idée de ce qui cloche, je suis preneur.

Bonne journée,
Red'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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> 
 
#ifndef boolean
#define boolean
#define TRUE 1
#define FALSE 0
#endif // !boolean
 
 
 
// ============================== FONCTIONS APPELEES =========================================
 
// calcul la taille du verbe
int SizeVerb(char verbe[]) {
	int i = 0;
 
	while (verbe[i] != '\0')
	{
		i++;
	}
 
	return i;
}
 
//crée la racine du verbe
void VerbRacine(char verbSource[], char verbRacine[]) {
	int i = 0;
	int z = SizeVerb(verbSource) - 1;
 
	//recopie le tableau en s'arrêtant 2 lettres avant la fin.
	while (i < z)
	{
		verbSource[i] = verbRacine[i];
		i++;
	}
 
	verbRacine[i] = '\0';
}
 
 
// ======================================== FONCTION MAIN ========================================
int main() {
	// demande le verbe
	char reponse[30];
 
	printf("Entrez un verbe du premier groupe: ");
	scanf("%s", reponse);
 
	//créer une racine
	int longueur = SizeVerb(reponse);
	char *repUtilisateur;
 
	repUtilisateur = (char *)malloc((longueur + 1) * sizeof(char));
 
	VerbRacine(reponse, repUtilisateur);
 
	// imprime la conjugaison du verbe à l'écran.
	char *pron[6];
 
	pron[0] = "JE";
        pron[1] = "TU";
        pron[2] = "IL";
        pron[3] = "NOUS";
        pron[4] = "VOUS";
        pron[5] = "ILS";
 
	char *term[6];
 
	term[0] = "ASSE";
	term[1] = "ASSES";
	term[2] = "AT";
	term[3] = "ASSIONS";
	term[4] = "ASSIEZ";
	term[5] = "ASSENT";
 
	for (int i = 0; i < 6; i++)
	{
		printf("QUE %s %s%s \n", pron[i], repUtilisateur, term[i]);
	}
 
	free(repUtilisateur);
 
	return 0;
}

**foetus** · 11/01/2018, 17h55

L'erreur est ligne 35

Sinon tu fais appel à 2 fois à ta fonction SizeVerb (ligne 52 et ligne 30 (appel à 57)) dont 1 qui ne sert à rien.
Et tu pourrais faire le malloc dans la fonction VerbRacine

Pourquoi n'utilises-tu pas strlen

?

**Redgard** · 11/01/2018, 18h41

Dans?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

		verbSource[i] = verbRacine[i];

Une autre personne vient de me le dire, je présumais que j'ai inversé. Mais concrètement, j'ai du le lire à haute voix pour que la faute m'apparaisse... dyslexie*

D'ailleurs, cette personne m'a conseillé de préférer les char* aux char[] dans les paramètres des fonctions (en bref, utiliser les pointeurs). Tu confirmes? quelle intérêt?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//crée la racine du verbe
void VerbRacine(char* verbSource, char* verbRacine) {
	int i = 0;
	int longueur = SizeVerb(verbSource);
 
        verbRacine = (char *)malloc(( longueur + 1) * sizeof(char));
 
	//recopie le tableau en s'arrêtant 2 lettres avant la fin.
	while (i < longueur - 2)
	{
		verbRacine[i] = verbSource[i];
		i++;
	}
        verbRacine[i] = '\0';
]

Pour le malloc dans la fonction: je sais pas... peut être?
Dans l'idée le premier, sert à déterminer la taille de la liste repUtilisateur, et le deuxième sert à interrompre prématurément la copie de la première liste dans la seconde, pour enlever la terminaison "-ER".
J'ai un peu du mal à voir comment synthétiser les deux en un... est-ce que ça ne peut pas produire des problèmes, que je déclare la longueur de la liste dans la fonction? de même que la liste ne soit pas définit alors qu'elle est employé par une fonction?

pour strlen:
Je ne connais pas encore cette commande. il faut que je regarde la documentation.
à son nom, je présume que ça veut dire "string lenght".
Le compilateur utilisé par ma formation en ligne ne gère pas la bibliothèque string.h

... toujours le même problème. Ce qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdio.h>
#include <stdlib.h> 
 
#ifndef boolean
#define boolean
#define TRUE 1
#define FALSE 0
#endif // !boolean
 
 
 
// ============================== FONCTIONS APPELEES =========================================
 
// calcul la taille du verbe
int SizeVerb(char verbe[]) {
	int i = 0;
 
	while (verbe[i] != '\0')
	{
		i++;
	}
 
	return i;
}
 
//crée la racine du verbe
void VerbRacine(char *verbSource, char *verbRacine) {
	int i = 0;
	int longueur = SizeVerb(verbSource);
 
	verbRacine = (char *)malloc((longueur + 1) * sizeof(char));
 
	//recopie le tableau en s'arrêtant 2 lettres avant la fin.
	while (i < longueur - 2)
	{
		verbRacine[i] = verbSource[i];
		i++;
	}
 
	verbRacine[i] = '\0';
}
 
 
// ======================================== FONCTION MAIN ========================================
int main() {
	// demande le verbe
	char reponse[30];
 
	printf("Entrez un verbe du premier groupe: ");
	scanf("%s", reponse);
 
	//créer une racine
	char *repUtilisateur;
 
	VerbRacine(reponse, repUtilisateur);
 
	// imprime la conjugaison du verbe à l'écran.
	char *pron[6];
 
	pron[0] = "JE";
    pron[1] = "TU";
    pron[2] = "IL";
    pron[3] = "NOUS";
    pron[4] = "VOUS";
    pron[5] = "ILS";
 
	char *term[6];
 
	term[0] = "ASSE";
	term[1] = "ASSES";
	term[2] = "AT";
	term[3] = "ASSIONS";
	term[4] = "ASSIEZ";
	term[5] = "ASSENT";
 
	for (int i = 0; i < 6; i++)
	{
		printf("QUE %s %s%s \n", pron[i], repUtilisateur, term[i]);
	}
 
	free(repUtilisateur);
 
	return 0;
}

**Matt_Houston** · 11/01/2018, 20h53

Envoyé par foetus

Et tu pourrais faire le malloc dans la fonction VerbRacine

Question de point de vue sur la conception d'APIs. Perso j'évite de confier cette tâche à l'appelé quand c'est possible et je m'explique :

ça multiplie les responsabilités : on extrait un radical ou on gère la mémoire ? Faut choisir.
Cela force à inclure stdlib.h et c'est moins générique : j'avais peut-être un buffer déjà tout prêt, pas de bol !
C'est moins flexible : si je veux plutôt allouer mon buffer en statique ou sur la pile, pas de bol !
Cela force à faire de la gestion d'erreur au milieu du traitement : j'ai pas envie d'avoir à gérer une erreur d'allocation quand je suis en train de manipuler des chaînes.

Envoyé par Redgard

... toujours le même problème.

Cela ne fonctionne pas parce que tu as réalisé plusieurs modifications en même temps, qui ont introduit d'autres erreurs. Si tu avais simplement corrigé le défaut que foetus a mentionné, tu aurais constaté que ton programme fonctionne (à peu de choses près). Ne fais qu'une seule chose à la fois.

Envoyé par Redgard

D'ailleurs, cette personne m'a conseillé de préférer les char* aux char[] dans les paramètres des fonctions (en bref, utiliser les pointeurs). Tu confirmes? quelle intérêt?

C'est surtout : quel intérêt de préférer l'autre notation ([]) ? Le compilateur interprètera de toute manière le paramètre comme un pointeur. Il n'y a pas d'avantage à utiliser cette notation, sauf à ne pas vouloir faire comme tout le monde. Personnellement je ne l'emploie qu'à un seul endroit et c'est uniquement par habitude / convention : int main(int argc, char *argv[]) { ... .

Attention : ce que j'ai écrit ici n'est valable que pour les déclarations de paramètres de fonction ! Il y a bien une différence entre char s1[] = "string"; et char *s2 = "string";, par exemple.

Ah, pense aussi à ajouter un const avant l'astérisque dans une déclaration pour préciser que le contenu d'une chaîne ne sera pas modifié par le code qui utilise la variable. Ici, la chaîne source n'est pas sensée être modifiée, déclare donc ta fonction comme ceci : void VerbRacine(const char *verbSource, char *verbRacine). Tu indiques ainsi au compilateur (et à tes relecteurs qui comprendront mieux le rôle de chaque paramètre !) qu'on ne doit pas accéder au contenu de verbSource en écriture. Ton erreur aurait ainsi pu être détectée à la compilation.

Envoyé par Redgard

pour strlen:
Je ne connais pas encore cette commande. il faut que je regarde la documentation.
à son nom, je présume que ça veut dire "string lenght".

Tu as correctement deviné -> http://en.cppreference.com/w/c/string/byte/strlen (garde l'adresse de ce site sous le coude)

**foetus** · 12/01/2018, 01h57

Envoyé par Matt_Houston

Question de point de vue sur la conception d'APIs. Perso j'évite de confier cette tâche à l'appelé quand c'est possible et je m'explique :

ça multiplie les responsabilités : on extrait un radical ou on gère la mémoire ? Faut choisir.
Cela force à inclure stdlib.h et c'est moins générique : j'avais peut-être un buffer déjà tout prêt, pas de bol !
C'est moins flexible : si je veux plutôt allouer mon buffer en statique ou sur la pile, pas de bol !
Cela force à faire de la gestion d'erreur au milieu du traitement : j'ai pas envie d'avoir à gérer une erreur d'allocation quand je suis en train de manipuler des chaînes.

Tu as tout à fait raison sur certains points, mais cette fonction est là pour faire une copie [partielle] d'une chaîne de caractères

: donc ce n'est pas déconnant que ce soit elle qui prenne la longueur de la source, initialise la destination en conséquence et fasse la copie.
Surtout qu'ici, c'est une copie partielle, certes simple (avec un -2), mais tu sors de ta fonction de la logique propre à cette copie.
Avec le verbe choir, tu dois retirer 3 lettres

Tu parles de la gestion d'erreur. Mais que ce passe-t-il si la source est vide ? que se-passe-il si ta destination est nulle (dans le cas présent) ?
En C, tu dois en permanence faire de la programmation [ultra] défensive : retour booléen [bien passé ou pas] + paramètre pointeur d'une énumération pour toutes les erreurs possibles.

Sinon, pour les autres allocations, statique, dynamique, sur la pile : 1) ici on en gère une seule 2) tu peux passer en paramètre une énumération "type d'allocation" qui permet d'initialiser ou pas la destination
Et ainsi, ce paramètre permet de faire une documentation adéquate de la fonction

Et pour stdlib.h, je n'ai jamais eu de considération de la sorte : c'est la librairie standard, un malloc je pense doit être "cross-platform". Je ne vais pas modulariser mon programme pour avoir une [grosse ou petite] partie de mon programme sans aucun include

**Redgard** · 12/01/2018, 07h37

Envoyé par Matt_Houston

Question de point de vue sur la conception d'APIs. Perso j'évite de confier cette tâche à l'appelé quand c'est possible et je m'explique :

ça multiplie les responsabilités : on extrait un radical ou on gère la mémoire ? Faut choisir.
Cela force à inclure stdlib.h et c'est moins générique : j'avais peut-être un buffer déjà tout prêt, pas de bol !
C'est moins flexible : si je veux plutôt allouer mon buffer en statique ou sur la pile, pas de bol !
Cela force à faire de la gestion d'erreur au milieu du traitement : j'ai pas envie d'avoir à gérer une erreur d'allocation quand je suis en train de manipuler des chaînes.

Je suis pas aussi loin, donc je comprends pas tout ^^'. va falloir que je fasse quelques recherche.
Mais, dans une formation en ligne que j'ai suivis, le gars disait de limiter ses fonctions à un seul tâches qui peut être résumer en une seul phrase. Dans le cas contraire, c'est que tu veux en faire trop.

Cela ne fonctionne pas parce que tu as réalisé plusieurs modifications en même temps, qui ont introduit d'autres erreurs. Si tu avais simplement corrigé le défaut que foetus a mentionné, tu aurais constaté que ton programme fonctionne (à peu de choses près). Ne fais qu'une seule chose à la fois.

Je manque encore de méthodologie et de rigueur. j'essaie d'éviter ce genre de chose mais j'ai tendance à vouloir aller trop vite.

Attention : ce que j'ai écrit ici n'est valable que pour les déclarations de paramètres de fonction ! Il y a bien une différence entre char s1[] = "string"; et char *s2 = "string";, par exemple.

bah si je ne trompe pas, "s1" est une liste/array, tandis que "s2" est le pointeur. Parcontre va falloir que je continue à étudier ça parce que je vois pas toutes les nuances au niveau de ce qui se passe dans la ram.
Pour s1, tu initialises une liste de caractères que tu remplis avec "string". en bref dans la mémoire, tu vas retrouvé un emplacement avec l'adresse de la liste et un autre contenant la chaine de caractère "string".
Tandis qu'avec "s2", tu initialises un pointeur dont l'adresse pointe faire une liste/ array de caractères et là????

Ah, pense aussi à ajouter un const avant l'astérisque dans une déclaration pour préciser que le contenu d'une chaîne ne sera pas modifié par le code qui utilise la variable. Ici, la chaîne source n'est pas sensée être modifiée, déclare donc ta fonction comme ceci : void VerbRacine(const char *verbSource, char *verbRacine). Tu indiques ainsi au compilateur (et à tes relecteurs qui comprendront mieux le rôle de chaque paramètre !) qu'on ne doit pas accéder au contenu de verbSource en écriture. Ton erreur aurait ainsi pu être détectée à la compilation.

En fait l'intérêt de la constante, c'est de passer une zone de la mémoire en ROM (Read Only Memory)

Tu as correctement deviné -> http://en.cppreference.com/w/c/string/byte/strlen (garde l'adresse de ce site sous le coude)

Merci, je vais l'ajouter à ma liste; ça m'en fera deux. Quelqu'un m'avait donné celui là déjà http://www.cplusplus.com

Le projet est restreint aux verbes du premier groupe. Maintenant, si je devais faire qu'il détecte les autres groupes, je rajouterai surement une fonction en if qui vérifie les 3 dernières lettres et les compare à différentes combinaison de caractères, pour déterminer si c'est un du 1, 2 ou 3 groupe.

___________________________________________________________________

Je viens de faire le test en reprenant mon code original et en faisant quelques modification et effectivement ça marche .... parcontre je ne sais pas pourquoi :/
Je vais devoir comparer.

En tout cas merci pour votre aide et pour vos conseils

Nom : C2.PNG
Affichages : 190
Taille : 14,8 Ko

Nom : C2.PNG
Affichages : 190
Taille : 14,8 Ko

**foetus** · 12/01/2018, 10h29

Envoyé par Redgard

Pour s1, tu initialises une liste de caractères que tu remplis avec "string". en bref dans la mémoire, tu vas retrouvé un emplacement avec l'adresse de la liste et un autre contenant la chaine de caractère "string".
Tandis qu'avec "s2", tu initialises un pointeur dont l'adresse pointe faire une liste/ array de caractères et là????

Non, c'est un truc avec lequel j'ai du mal aussi et qui est ultra-dépend du compilateur

Lorsque tu fais ceci, en théorie, ta variable sera mise dans une mémoire "lecture seule".
Donc avec :

un tableau, char s1[] = "string" tu ne pourras ni détruire ni étendre (realloc) ton tableau, et en théorie ni le modifier
un pointeur, char* s2 = "string", tu ne pourras ni détruire ni étendre (realloc) ta chaîne de caractères, mais tu pourras modifier les caractères de ta chaîne (parce que c'est le pointeur qui est constant, pas la chaîne).

**dalfab** · 12/01/2018, 12h35

Envoyé par foetus

un tableau, char s1[] = "string" tu ne pourras ni détruire ni étendre (realloc) ton tableau, et en théorie ni le modifier
un pointeur, char* s2 = "string", tu ne pourras ni détruire ni étendre (realloc) ta chaîne de caractères, mais tu pourras modifier les caractères de ta chaîne (parce que c'est le pointeur qui est constant, pas la chaîne).

Le premier est un tableau, il doit être en RAM et est modifiable; il y a donc copie d'un tableau en ROM vers un tableau en RAM à l'instanciation de la variable. On peut aussi écrire static const char s2[] = "string"; qui lui sera un tableau directement en ROM.
Le second devrait s'écrire const char* s2 = "string"; le mot const reste facultatif en C (bien la chaine puisse être en ROM!), il est devenu obligatoire en C++.

**Matt_Houston** · 12/01/2018, 23h49

Non mais en fait on s'en fout des chaînes littérales constantes ou pas..

C'était un exemple pour préciser que mon propos ne portait que dans le contexte des signatures de fonction.

Envoyé par Redgard

Je suis pas aussi loin, donc je comprends pas tout ^^'. va falloir que je fasse quelques recherche.
Mais, dans une formation en ligne que j'ai suivis, le gars disait de limiter ses fonctions à un seul tâches qui peut être résumer en une seul phrase. Dans le cas contraire, c'est que tu veux en faire trop.

Je rebondissais sur ce qu'écrivait foetus mais oui voilà, tu as saisi l'idée. Ça a à voir avec Unix et plus généralement le principe d'économie.

Envoyé par Redgard

En fait l'intérêt de la constante, c'est de passer une zone de la mémoire en ROM (Read Only Memory)

Attention : dans le cas général le mot-clef const n'est qu'une indication destinée au compilateur qu'on ne compte pas modifier le contenu de la zone mémoire en question, ce qui peut lui permettre de traduire le code différemment. Il est toujours possible de ne pas respecter ce contrat (et possiblement s'exposer à des effets indésirables).

Envoyé par Redgard

Merci, je vais l'ajouter à ma liste; ça m'en fera deux. Quelqu'un m'avait donné celui là déjà http://www.cplusplus.com

Certains diront qu'il s'agit encore d'une querelle de clochers mais je te déconseille cplusplus.com au profit de cppreference qui est plus complet, plus précis et plus exact (ainsi que plus joliment / sobrement formaté..). Ne serait-ce que parce que le premier ne traite que de C++ qui n'est pas ce qui nous intéresse ici.

Envoyé par Redgard

Le projet est restreint aux verbes du premier groupe.

Et encore : essaie de conjuguer manger..

Envoyé par foetus

mais cette fonction est là pour faire une copie [partielle] d'une chaîne de caractères

Réaliser une copie peut s'interpréter de différentes manières.

Envoyé par foetus

Tu parles de la gestion d'erreur. Mais que ce passe-t-il si la source est vide ? que se-passe-il si ta destination est nulle (dans le cas présent) ?

Tu mets des assert et tu écris ta documentation correctement ! C'est à cela que servent les préconditions. Une fois les entrées validées - le plus tôt possible - il est inutile de traiter des cas qui ne peuvent pas se produire. Tu imagines si tu devais check errno après chaque memcpy ?

Envoyé par foetus

En C, tu dois en permanence faire de la programmation [ultra] défensive : retour booléen [bien passé ou pas] + paramètre pointeur d'une énumération pour toutes les erreurs possibles.

Justement ! Moins tu fais de choses, moins tu as de cas d'erreur à prendre en compte. Encore une fois : il faut valider les entrées au plus tôt, ensuite déroule !

Envoyé par foetus

Sinon, pour les autres allocations, statique, dynamique, sur la pile : 1) ici on en gère une seule 2) tu peux passer en paramètre une énumération "type d'allocation" qui permet d'initialiser ou pas la destination

Alors j'en reviens à mon premier argument : la multiplication des responsabilités. Keep it simple !

Absence d'une variable dans la sortie

C

Discussions similaires

Partager

Partager