Printf ne fonctionne plus

Malikemal · 05/06/2011, 13h59

Bonjour à tous,

Je suis en train d'écrire une fonction de chiffrement en césar, et j'ai un problème ... La fonction marche sans problème, mais quand je fais appelle à la dite fonction, dans le main, et que je veux afficher le résultat avec un printf, celui-ci ne fonctionne pas. Après plusieurs tests, j'ai vu que ça fonctionnait à chaque fois sauf quandje voulais afficher la chaine de caractère qui venait de la fonction cesar ... Pour récupérer le texte au clavier, j'utilise une fonction de mon cru qui renvoie un tableau qui a exactement la taille voulue ! Je met le fichier source en PJ si vous voulez.. Voici donc le CS de la fonction de saisie :

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
 
char *saisie(void)
{
    char *tab = NULL;
 
    tab = malloc(1000 * sizeof(char));
 
    if(tab)
    {
 
        fgets(tab, 999, stdin); /* Pour pourvoir placer le '\0' */
 
        if((strchr(tab, '\n')) == NULL) /* Si le texte est trop grand pour le tableau */
        {        
            tab = utilBuffer(tab);
 
            if(tab == NULL)
                return NULL;
        }
 
        else if    (strlen(tab) != 999) /* Si le tableau est trop grand pour le texte */
        {
            tab = realloc(tab, strlen(tab) * sizeof(char));
        }
 
        return tab;
    }
 
    else
        return NULL;
}
 
char *utilBuffer(char *tab)
{    
    char *temp = malloc(500 * sizeof(char));
 
    if(temp == NULL)    
        return NULL;
 
    size_t size;
    fgets(temp, 499, stdin);
 
    if((strchr(temp, '\n')) == NULL)
    {    
        temp = utilBuffer(temp);
    }
    size = (strlen(tab) + strlen(temp)) * sizeof(char);
    tab = realloc(tab, size); /* On réajuste le tableau */
    strcat(tab, temp); /* On rajoute */
    return tab;
}

Celui de la fonction qui convertit les valeurs en nombres ASCII :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int conversionAscii(char lettre)
{
    int nombre = -1; /* Contiendra la valeur ASCII */
    nombre = (int) lettre; /* On cast lettre pour qu'il nous donne la valeur ASCII de sa lettre*/
 
/* On vérifie si 'nombre' est bien un code de la table ASCII*/
    if(!isascii(nombre))  
        return -1;
    else
        return nombre;
}

La fonction de cryptage :

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
 
char* cesar(void)
{
    int i = 0;
    char *texte = malloc(100); /* Texte à crypter ou décrypter */
    char *result = NULL; /* Texte crypter ou décrypter */
    int *valeurAscii = NULL; /* Tableau contenant les valeurs Ascii des lettres de 'texte' */
    long decalage = 3; /* Décalage à opérer */        
 
    texte = saisie();
    result = malloc(sizeof(*texte)); 
    valeurAscii = malloc(strlen(texte) * sizeof (int));
 
    for(i = 0; texte[i]; i++)
    {
        valeurAscii[i] = conversionAscii(texte[i]);
 
            if(valeurAscii[i] + decalage > 255) /* Si jamais la valeur ASCII est trop grande */
                valeurAscii[i] = (valeurAscii[i] + decalage) - 255;
 
            else
                valeurAscii[i] = valeurAscii[i] + decalage;
 
        result[i] = toascii(valeurAscii[i]);
    }
 
    return result;
 
 
}

et voila la fonction principale :

Code :

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

1
2
3
4
5
6
 
int main()
{
printf("%s", cesar());
return 0;
}

Je suis sur que la fonction marche car j'ai fait un fprintf dans un fichier texte, et ça ma donné le bon crypt. Si vous voulez plus de précisions je suis à votre service !

Merci,

**Lucien63** · 05/06/2011, 17h02

Dans la fonction cesar

Code :

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

result = malloc(sizeof(*texte));

l'espace alloué pour result fait la taille d'un char, ce n'est pas suffisant pour ce que tu veux faire.

Malikemal · 05/06/2011, 17h05

Je vais corriger ça, mais à supposer que ce soit ce qui cause le problème ça m'aurait mis "Segmentation Fault" non ?

**Lucien63** · 05/06/2011, 17h16

Je vais corriger ça, mais à supposer que ce soit ce qui cause le problème ça m'aurait mis "Segmentation Fault" non ?

Pas forcement.

Il n'y a pas que cela :
tu fait des malloc un peu partout et jamais de free,

fonction cesar :

Code :

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

1
2
3
4
5
char *texte = malloc(100); // char *texte = malloc(100*sizeof(char)); 
 
//....
 
texte = saisie();

ton espace alloué est perdu a jamais

Malikemal · 05/06/2011, 17h17

Ooooups ! Je vais de suite corriger ça et je reposte en EDIT, le fichier corrigé .... J'en profite pour voir si ça remarche !

EDIT : Ca ne marche toujours pas ....

**jeroman** · 05/06/2011, 18h25

Il y a plein de fuites de mémoire potentielles dans ton code. De plus, ta fonction de saisie est plutôt bancale, elle manque de logique. Si la chaine dépasse, elle appelle une autre fonction pour concaténer (et une fois maximum).

Cela fait un peu "usine à gaz" manquant de cohérence.

Je te propose une solution un peu plus clean :

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
#define TAILLE_MAX_SAISIE 10 /* valeur arbitraire, à modifier si besoin */
 
char * saisie(void)
{
	char tab[TAILLE_MAX_SAISIE];
	char * chaine = NULL;
	size_t taille_totale = 1; /* la chaine contient au moins '\0' */
	int fin_boucle = 0;
 
	do
	{
		size_t taille_saisie;
 
		fgets(tab , TAILLE_MAX_SAISIE , stdin);
		{
			char * supp_lf;
			supp_lf = strchr(tab , '\n'); /* on vire le '\n' s'il est présent */
			if (supp_lf != NULL)
			{
				*supp_lf = '\0';
				fin_boucle = 1;
			}
		}
		taille_saisie = strlen(tab);
		taille_totale += taille_saisie;
		if (taille_totale == 1 /* on cree une chaine vide meme si on n'a rien saisi pour éviter un crash */ || taille_saisie != 0)
		{
			char * tmp_realloc;
			tmp_realloc = realloc(chaine , taille_totale);
			if (tmp_realloc != NULL)
			{
				if (chaine == NULL)
					*tmp_realloc = '\0'; /* lors de la 1ere alloc, on met '\0' comme 1er caractère (à cause du strcat plus bas) */
				chaine = tmp_realloc;
			}
			else
			{
				free(chaine);
				chaine = NULL;
				break;
			}
			strcat(chaine , tab);
		}
	} while (fin_boucle == 0);
 
	return chaine;
}

Quelques remarques :

Code :

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

result = malloc(sizeof(*texte));

ouch ! Tu confonds apparemment sizeof et strlen. En tout cas, le résultat de sizeof ici est... 1 !
De plus, n'oublie pas le '\0' final de ta chaine, il doit être compté.

Ton tableau valeurAscii ne sert à rien du tout. Tu peux mettre le résultat de ton calcul directement dans ta chaine.

Il n'y a de free nulle part !

**ailonn** · 13/06/2011, 11h49

Bonjour,

Je viens de survoler le sujet et il me semble que ca n'a pas ete dit, meme si je ne pense pas que ca resolve le probleme mais voila:

Envoyé par Malikemal

Code :

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

1
2
3
4
5
6
 
int main()
{
printf("%s", cesar());
return 0;
}

Il manque un '\n' a ton printf avant le dernier ".

Bonne journee!

**Overcrash** · 13/06/2011, 12h02

Envoyé par ailonn

Bonjour,

Je viens de survoler le sujet et il me semble que ca n'a pas ete dit, meme si je ne pense pas que ca resolve le probleme mais voila:

Il manque un '\n' a ton printf avant le dernier ".

Bonne journee!

Il est pas obligatoire

?
En tout cas il n'afflue en rien le fonctionnement du printf.

**ailonn** · 13/06/2011, 12h40

A ma connaissance printf bufferise et le '\n' est la pour lui dire fin de buffurisation.
Dans le cas present je ne suis pas sur que ca derange mais dans d'autre cas ou les printf sont dans differentes fonctions, ou simplement plusieurs d'affiler, ca peut donner des effets assez interessants du genre oublier les '\n' sur tout les printf et avoir une longue tres longue chaine de caractere qui va s'afficher au return du main.
Pour tester:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int main()
 {
   printf("Salut");
   printf(" comment");
   printf(" vas");
   printf(" tu?");
   sleep(5);
   printf("\n");
   return (0);
}

**Zebrure** · 13/06/2011, 13h04

Envoyé par ailonn

A ma connaissance printf bufferise et le '\n' est la pour lui dire fin de buffurisation.
Dans le cas present je ne suis pas sur que ca derange mais dans d'autre cas ou les printf sont dans differentes fonctions, ou simplement plusieurs d'affiler, ca peut donner des effets assez interessants du genre oublier les '\n' sur tout les printf et avoir une longue tres longue chaine de caractere qui va s'afficher au return du main.
Pour tester:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int main()
 {
   printf("Salut");
   printf(" comment");
   printf(" vas");
   printf(" tu?");
   sleep(5);
   printf("\n");
   return (0);
}

Bonjour. printf est en effet une fonction temporisé, mais « \n » n'est pas là pour vider le tampon mais pour indiquer new line. Ici le message est affiché lors du printf("\n"); simplement parce que le programme se termine et que le tampon est alors vidé ; un exemple pour vous en convaincre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int main()
 {
   printf("Salut");
   printf(" comment");
   printf(" vas");
   printf(" tu?");
   printf("\n");
   sleep(5);
   return (0);
}

aura le même comportement que le code que vous avez donné.

Pour vider le tampon et provoquer l'affichage du texte, il faut utiliser fflush sur le flux de sortie :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int main()
 {
   printf("Salut");
   printf(" comment");
   printf(" vas");
   printf(" tu?");
   fflush( stdout );
   sleep(5);
   return (0);
}

**ailonn** · 13/06/2011, 13h20

Ton premier exemple n'est pas concluant. Si j'ai bien compris l'affichage ne devrais se faire qu'apres 5 secondes alors qu'il est directe et on attend 5 seconde avant la fin de l'execution.
Il se peut que la demande de nouvelle ligne declenche le vidage du tampon.

Mais je reconnais que vider le tampon est aussi efficace pour declencher l'affichage.
Merci je ne le savais pas et

**Overcrash** · 14/06/2011, 11h26

Envoyé par ailonn

A ma connaissance printf bufferise et le '\n' est la pour lui dire fin de buffurisation.
Dans le cas present je ne suis pas sur que ca derange mais dans d'autre cas ou les printf sont dans differentes fonctions, ou simplement plusieurs d'affiler, ca peut donner des effets assez interessants du genre oublier les '\n' sur tout les printf et avoir une longue tres longue chaine de caractere qui va s'afficher au return du main.
Pour tester:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int main()
 {
   printf("Salut");
   printf(" comment");
   printf(" vas");
   printf(" tu?");
   sleep(5);
   printf("\n");
   return (0);
}

A ta connaissance

?

le "\n" est en aucun cas la fin de bufferisation ou encore le vidage de la mémoire tampon ... Pour vider la mémoire tampon je connais fflush.
Le "\n" est uniquement un saut de ligne.

Faut pas non plus dire n'importe quoi ...
Je sais pas ou tu as vu ça mais j'aimerais bien avoir la source.

Pour infos :

\n
passe à la ligne
\r
renvoie le curseur en début de ligne
\t
tabulation
\v
tabulation verticale
\b
retour en arrière
\a
« alerte » (sonore ou visuelle)

Et encore si tu as des doutes : http://compute.cnr.berkeley.edu/cgi-...n-cgi?printf+1

ce qui revient au man printf

**diogene** · 14/06/2011, 12h07

En fait, il y a trois modes de fonctionnement pour les flux d'E/S :
1- non tamponnées : la transmission se fait aussi tôt que possible
2- totalement tamponnées : la transmission est faite lorsque le tampon est plein
3- tamponnées par ligne : la transmission est faite lorsque le tampon est plein ou lorsqu'un '\n' est trouvé dans le flux

Les flux stdout et stdin, par défaut, ne sont totalement tamponnés que dans le cas où ils correspondent à un dispositif non interactif. Dans le cas de la console, cela laisse à l'implémentation les choix 1 et 3. Et si la console est tamponnée il ne reste que le choix 3 : la transmission se fera bien sur un '\n'

Printf ne fonctionne plus

C

Vue hybride

Discussions similaires

Partager

Partager