Discussion :

[Hoder]

Bonjour,

J'ai un probleme vraiment etrange, je realise en ce moment un sudoku en projet que l'on doit rendre demain. Nous recuperons des sudokus sur l'entree standard puis nous devons le resoudre et l'afficher le plus rapidement possible. Il est fini mais nous avons utilise fgets() et nous pensons qu'en faisant une petite fonction maison de 4 lignes, ca devrait marcher.
Eh bien ca marche nickel mais seulement quand on compile (avec gcc) avec les sources (*.c) dans le Makefile. Si on creer des fichiers objets (*.o), et qu'on les links (toujours avec gcc), la sortie standard n'affiche plus rien tant que l'on a pas ecrit quelque chose. Si apres chaque read de ligne que je fais, je mets un write(1, "", 1) par exemple, le resultat s'affiche bien.

En somme, connaissez-vous un moyen de resoudre le probleme occassionne par le linkage des fichiers objets, bloquant l'affichage de la sortie standard ?

Merci d'avance

EDIT : En fait, non ca doit venir encore d'ailleurs mais je ne sais pas de quoi :s Mais manifestemment, ce n'est pas au niveau du code mais bien de la compilation. Voici les CFLAGS que j'ai rajoute : -O -O2 -s -W -Wall -ansi -pedantic.

RE-EDIT : En fait, c'est le CFLAGS -02 qui bloque l'affichage et -O fait carrement SegFault... Je vais devoir les enlever alors mais connaissez-vous la raison de cela ?

[gl]

RE-EDIT : En fait, c'est le CFLAGS -02 qui bloque l'affichage et -O fait carrement SegFault... Je vais devoir les enlever alors mais connaissez-vous la raison de cela ?

Tu as probablement une erreur dans ton code qui induit un comportement différent en fonction du niveau d'optimisation.

[LittleWhite]

Bonjour,

gdb et valgrind seront vos amis ( du moins les outils pour vous aider )

[Hoder]

On est repasser a une version antérieure et les optimisations ont pu être mises.
Mais justement, le truc c'est que si je compile sans ces flags, ca marchait impec', c'est seulement quand je les rajoutais.

Tu as probablement une erreur dans ton code

C'est justement ce que je me demandais, mais bon, je vais pas vous copier/coller tout mon programme, ca serait un peu long ^^
Tant pis, et merci quand meme

[Obsidian]

Il y a 99,999% de chances que ta segfault soit due à une erreur dans ton code plutôt que dans celui du compilateur. Ton code n'est pas forcement si long que tu le crois. Poste-le ici est veillant à utiliser les balises [code] et [/code].

Pour la sortie standard, sache que celle-ci bufferise par défaut tout ce que tu écris dedans jusqu'à un retour à la ligne ou si le tampon est plein. Il faudra peut-être modifier ce comportement si tu fais des manipulations particulières avec l'affichage.

[Hoder]

Ca doit etre ca, je ne pensais pas que l'entree standard bufferisait, contrairement a printf() justement.
Je vais recoder la fonction qui creait le probleme pour voir cela.

EDIT :
Ceci fonctionne :

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
 
static char     **stock_sudoku(int *finish)
{
  char          buffer[30];
  int           ctr;
  char          **tab;
 
  ctr = 0;
  tab = xmalloc(sizeof(*tab) * 11);
  while (*finish != TRUE && ctr <= 10) /* Recupere 10 lignes */
    {
      if ((fgets(buffer, sizeof(buffer), stdin)) == NULL)
        *finish = TRUE;
      else
        tab[ctr] = strdup(buffer);
      ctr++;
    }
  tab[ctr] = NULL;
  return (tab);
}
 
int             sudoku()
{
  char          **tab;
  int           finish;
 
  finish = FALSE;
  while (finish != TRUE)
    {
      tab = stock_sudoku(&finish); /* Recupere les sudokus a partir de l'entree standard */
      begin_sudoku(tab); /* Nettoie la map et fait tout l'algo sur Sudoku */
      if (finish == FALSE)
        {
          fprintl(1, DELIMITER); /* Affiche un simple delimiteur avec retour a la ligne sur l'entree standard */
          free_tab(tab);
        }
    }
  printf("FINI\n");
  return (SUCCESS);
}

Mais on voulait augmenter la vitesse en evitant de passer par fgets qui serait peut-etre plus long qu'une fonction a nous de 3 lignes ^^.
On a fait une fonction qui recupere toujours le meme nombre de caracteres (vu que les cases des sudokus donnees sont toujours de 21 caracteres :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
char            *get_next_line(const int fd)
{
  char          buffer[20];
  char          *line;
  int           nb_read;
 
  if (!(nb_read = read(fd, buffer, 21)))
    return (NULL);
  buffer[nb_read] = '\0';
  line = strdup(buffer);
  return (line);
}

Suite a ce recode, je n'ai plus le probleme, mais un autre est apparu. Ca SegFault toujours au return de la fonction sudoku() (la fonction appellant sudoku() est le main et il n'y a rien d'autre apres cela, mais si on met un printf() dans le main, rien ne s'affiche, voici ce que me sort gdb : "Program received signal SIGSEGV, Segmentation fault. 0x00000000 in ?? ()").

Malgre ca, j'ai rajoute dans le Makefile -0 et -02, et la, plus rien ne rentre sur l'entree standard ^^. Normalement, je ressors un truc dans le style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
|------------------|
| 4 8 9 3 1 7 6 2 5|
| 6 5 1 2 4 8 9 7 3|
| 3 2 7 9 6 5 8 1 4|
| 9 7 8 5 3 2 1 4 6|
| 5 3 6 4 8 1 7 9 2|
| 2 1 4 7 9 6 5 3 8|
| 1 9 5 8 2 3 4 6 7|
| 8 4 3 6 7 9 2 5 1|
| 7 6 2 1 5 4 3 8 9|
|------------------|
####################

(Ca rend mieux sur console )
Mais la, il me ressort :

Code :

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

1
2
3
4
5
 
|------------------|
|------------------|
####################
FINI

Mais sans SegFault ^^

[bizulk]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
char            *get_next_line(const int fd)
{
  char          buffer[20];
  char          *line;
  int           nb_read;
 
  if (!(nb_read = read(fd, buffer, 21)))
    return (NULL);
  buffer[nb_read] = '\0';
  line = strdup(buffer);
  return (line);
}

ça sera bien de tester la validité de ton paramètre et d'initialiser tes variables.
le test du retour de read est foireux, regarde le manpage. Que se passe-t-il lorsque read retourne -1 ?
Mais surtout, pourquoi demander un read de 21 octets quand ta chaîne en prend 20 seulement ? cela aurait du être au maximum

Code :

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

sizeof(buffer)

. Je pense que ton problème vient surtout de là.
Ca serait une bonne chose aussi de tester le retour de strdup, voir même de sans passer car maintenant tu va devoir libérer cet espace ailleurs que dans la fonction qui l'a crée ? Pourquoi ne pas créer buffer[] en dehors de la fonction et le passer en paramètre ? Ca serait plus sur et aussi plus rapide que de demander d'empiler cette chaine a chaque appel de cette fonction.
Moi j'aurai gardé le fgets.

Dans stock_sudoku( :

Code :

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

1
2
char          **tab;
tab = xmalloc(sizeof(*tab) * 11);

mouai, pkoi pas un char * tab [11] ?
D'après ton commentaire tu veux récupérer 10 lignes mais tu en réserves 11
D'ailleurs dans ta boucle tu va de 0 à 10 inclus, ça doit te faire bizarre quand tu as saisis tes 10 lignes.
Moi j'aurai putôt vérifié que fgets retournait buffer mais bon ...

Code :

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

1
2
3
      else
        tab[ctr] = strdup(buffer);
      ctr++

Y'a rien qui cloche pour toi là ?
Un conseil pour éviter toute réflexion à la relecture, utilises des balises pour tes instructions de contrôle mais si il n'y a qu'une ligne ?

[Hoder]

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
 
char            *get_next_line(const int fd)
{
  char          buffer[21];
  char          *line;
  int           nb_read;
 
  bzero(buffer, sizeof(buffer));
  line = NULL;
  nb_read = 0;
  if (!(nb_read = xread(fd, buffer, sizeof(buffer))))
    return (NULL);
  buffer[nb_read] = '\0';
  line = strdup(buffer);
  return (line);
}

J'ai initialise toutes les variables et rajoute xread() qui permet de verifier si read() a eu un probleme (je l'avais pas fais cette fois parce qu'un peu la flemme, desole).

Et pour strdup, bah j'en ai besoin vu que je dois stocker mon tableau. Donc que je fasse le buffer dans get_next_line() ou dans stock_sudoku(), dans tout les cas, faut que je malloc et que je stockes (a moins que tu ne vois un autre moyen - ceci dit, j'aurai aussi pu faire une matrice...).

Merci pour l'astuce du sizeof(buffer) dans le read() aussi, j'avais jamais pense a ca et c'est vrai que ca me sera bien pratique a l'avenir, pour modifier buffer sans devoir modifier tout le reste.

Code :

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

1
2
3
4
 
      else
        tab[ctr] = strdup(buffer);
      ctr++;

Mouais, c'est vrai que c'est un peu moche ^^ A l'origine, ca servait de le mettre ici mais apres, j'ai prefere utiliser une variable pour remplir le role, enfin bref.

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
 
static char     **stock_sudoku(int *finish)
{
  int           ctr;
  char          **tab;
 
  ctr = 0;
  tab = xmalloc(sizeof(*tab) * 10);
  while (*finish != TRUE && ctr <= 10)
    {
      if ((tab[ctr++] = get_next_line(0)) == NULL)
        *finish = TRUE;
    }
  tab[ctr] = NULL;
  return (tab);
}

Et au final, ca marche encore sans les flags d'optimisations sinon, avec -0 et/ou -02 : get_next_line me renvoit directement NULL.
Mais au moins ca ne SegFault plus a la fin, ca devait sans doute etre du au buffer trop petit comme tu me l'as fait remarquer.

[bizulk]

• Je ne connais pas xread et xmalloc
• Oui tu aurais pu faire une matrice parce que la taille de ton tableau est définie avant exécution. Tu verras que cette gestion de l'allocation de mémoire peut te jouer des tours.
• Préférer bzero à memset (regarde le manpage de cette fonction)
• Si read return l'erreur -1 tu fais comme si tout allait bien ...
• Je t'ai conseillé d'initialiser ta mémoire ailleurs car tu retournes tab qui est une variable locale et tu dois avoir un warning la-dessus. Ca fonctionne car tu alloues de la mémoire dynamiquement, mais ce n'est pas des habitudes a prendre .

Code :

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

1
2
3
    else
        tab[ctr] = strdup(buffer);
      ctr++;

Je crois que tu ne m'a pas compris, quoiqu'il arrive tu incrémentais ctr alors que aurais du le faire que si ta chaîne est validée.

Code :

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

1
2
 
 if ((tab[ctr++] = get_next_line(0)) == NULL)

T'est sur de ce que tu fais là ? Que les habitués de la norme me corrigent mais d'après moi cela se passe dans cet ordre :

• tab[ctr]= get_next_line(0))
• ctr++
• comparer tab[ctr] à NULL ce qui peut être le cas (car tu n'initialise pas tab). Mais ce qui n'est surement pas ce que tu souhaitais tester.

Code :

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

1
2
  tab = xmalloc(sizeof(*tab) * 10);
  while (*finish != TRUE && ctr <= 10)

Ta boucle n'est pas bonne c'est ctr<10.

S'il s'agit d'un sudoku, pourquoi saisir 10 lignes de 20 caractères ?

[bizulk]

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
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
 
#define TRUE 1
#define FALSE 0
#define ROW 9
#define COL 10
 
typedef char LINE[COL] ;
 
// attention avec fgets : http://c.developpez.com/faq/index.php?page=clavier_ecran#CONS_fgets
int get_next_line(LINE line)
{		char c ;
	if (line == NULL) return 1 ;
 
	if ( fgets(line, COL, stdin) != line )
	{
		printf("could not read line\n") ;
		return 1 ;
	}
	// lire le buffer d'entree pour vider le tampon jusqu'à \n
	do
	{
		c = getc (stdin) ;
	} while ( c != '\n') ;
 
	if (strlen(line) < (COL-1))
	{
		printf("invalid line\n") ;	 
		return 1 ;
	}
	return 0 ;
}
 
int stock_sudoku(LINE tab[])
{
	int           ctr;
	int ret = 0 ;
	if (tab == NULL) return 1 ;
 
	for (ctr = 0 ; (ret == 0) && (ctr < ROW) ; ctr++)
	{
		ret = get_next_line(tab[ctr]) ;
		if ( 0 !=ret)
		{printf("could not read table at line : %d\n", ctr) ;}
	}
	return ret ;
}
 
 
int main (int argc, char * argv[])
{
	int i ;
	int ret = 0 ;
	LINE tab[ROW] ;
	LINE tutu ;
 
	printf("test unitaire saisie ligne : ") ;
	get_next_line (tutu) ;
	printf("%s\n", tutu) ;
 
	memset (tab, 0 , sizeof(tab)) ;
 
	ret = stock_sudoku(tab) ;
	if( ret != 0 )
	{
		printf("could not read table\n") ;
		return -1 ;
	}
	for (i = 0 ; i < ROW ; i++)
	{
		printf("%s\n", tab[i]) ;
	}
	return 0 ;
}

[diogene]

@bizulk

Je t'ai conseillé d'initialiser ta mémoire ailleurs car tu retournes tab qui est une variable locale et tu dois avoir un warning la-dessus

Il n'est pas du tout déconseillé de retourner la valeur d'une variable locale (comme ici). C'est même le cas le plus fréquent. Par contre, il ne faut pas retourner l'adresse d'une variable locale.

Code :

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

 if ((tab[ctr++] = get_next_line(0)) == NULL)

T'est sur de ce que tu fais là ? Que les habitués de la norme me corrigent mais d'après moi cela se passe dans cet ordre :
tab[ctr]= get_next_line(0))
ctr++
comparer tab[ctr] à NULL ce qui peut être le cas (car tu n'initialise pas tab). Mais ce qui n'est surement pas ce que tu souhaitais tester.

Non, cette expression n'est pas évaluée de cette façon : Il n'y a pas comparaison de tab[ctr] à NULL, mais comparaison à NULL de la valeur de l'expression

Code :

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

tab[ctr++] = get_next_line(0)

L'évaluation se fait de la façon suivante :
1- Evaluation de get_next_line(0) qui donne un valeur V (égale à la valeur retournée par la fonction)
2- Evaluation de l'adresse A correspondant à tab[ctr]
L'ordre des évaluations peut être 1 puis 2 ou 2 puis 1. Ce n'est pas spécifié.

3- Placement de la valeur V à l'adresse A (si besoin est, la valeur V est convertie au préalable en le type du contenu de A et prend la valeur V').
V (ou V') est la valeur de l'expression (celle qui sera comparée à NULL).
4- Incrément de ctr
L'ordre des évaluations peut être 3 puis 4 ou 4 puis 3. Ce n'est pas spécifié.

[diogene]

@bizulk

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
int get_next_line(LINE line)
{		char c ;
	if (line == NULL) return 1 ;
 
	if ( fgets(line, COL, stdin) != line )
	{
...
	}
	// lire le buffer d'entree pour vider le tampon jusqu'à \n
	do
	{
		c = getc (stdin) ;
	} while ( c != '\n') ;
 
...
}

Le test pour vider le tampon est erroné : fgets() place le '\n' dans line si il y a suffisamment de place pour le stocker. Dans ce cas, le buffer est vide et le do while nous oblige à taper une ligne supplémentaire pour avoir le '\n'.
On ne doit faire cette boucle que si le '\n' n'est pas déjà dans line et donc si line était trop petit pour contenir la ligne entrée.

[bizulk]

Oui oui on retourne une variable locale bien sur je ne sais pas ce qui m'a pris.

pour fgets :
Non puisque fgets lit COL-1 caractères (les 9 chiffres). '\n' étant le dixième il est tout de suite dépilé il n'y a pas a retaper [enter].
Fais le test ...

Merci d'avoir corrigé l'évaluation des expressions. Néanmoins cette écriture n'aide pas à la clarté du code.

[diogene]

Non puisque fgets lit COL-1 caractères (les 9 chiffres). '\n' étant le dixième il est tout de suite dépilé il n'y a pas a retaper [enter].
Fais le test ...

Ce n'est pas très sérieux, cette entrée qui ne marche que si on tape un nombre de caractères qui ne tiennent pas dans le buffer. Alors qu'il est si simple de tester la présence du '\n' :

Code :

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

1
2
3
4
5
       if(strchr(line,'\n') == NULL)
	 do
	 {
		c = getc (stdin) ;
	  } while ( c != '\n') ;

Néanmoins cette écriture n'aide pas à la clarté du code.

Certes !