Discussion :

[Dihydrro]

Bonjour je cherche à faire une copie d'un tableau 2D

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
char    **init_sudok(char **sudoku)
{
    char    **sudoku_init;
    int i;
    int j;
 
    sudoku_init = malloc(9);
    i = -1;
    while (sudoku_init && ++i < 9)
    {
        j = -1;
        sudoku_init[i] = malloc(9 + 1);
        while (sudoku_init[i] && ++j < 10)
            sudoku_init[i][j] = sudoku[i][j];
        ft_putstr(1, "Tour ");
        putnbr(1, (i + 1));
        ft_putstr(1, "\n");
        ft_putstr(1, sudoku_init[0]);
        if (i > 0)
            ft_putstr(1, sudoku_init[1]);
        ft_putstr(1, "\n");
    }
    return (sudoku_init);
}

L'initialisation se déroule correctement, au début, mais au fur et à mesure les données des deux premières lignes changent. Pour voir l'évolution des ces lignes je les affiches à chaque tour de la grande boucle, voici ce que ça donne :

Tour 1
1...32..7
Tour 2
1...32..7
..56...4.
Tour 3
1...32..7
..56...4.
Tour 4
1...32..7
..56...4.
Tour 5
▒32..7
..56...4.
Tour 6
▒@▒7
..56...4.
Tour 7
▒@▒`▒..56...4.
Tour 8
▒@▒`▒▒▒1..56...4.
Tour 9
▒@▒`▒▒▒▒▒..56...4.
Je ne vois pas d'où sortes ces caractères et comment y remédier. :/

[o_Nejma]

Bonjour,

Je pense que l'erreur provient de la zone mémoire pointée par le paramètre de service char **sudoku. Est-ce que tu peux nous donner le bout de code où cette fonction est appelée?

Code :

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

1
2
3
char    **init_sudok(char **sudoku)
 
            sudoku_init[i][j] = sudoku[i][j];//sudoku[i][j]: source de données et peut être mal initialisée

[Dihydrro]

Je reçois le sudoku de base en argument de mon programme, un argument = une ligne et je le stock de cette manière :

Exemple : ./solver.exe "..578..6." "...1.9.8." ""89.....5." "4...7..39" "..6...1.." "97..6...5" ".3.....26" ".8.6.7..." .2..938.."

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
int	main(int argc, char **argv)
{
	char  **sudoku;
	int   i;
	int   j;
 
	if (argc != 10)
    		return (0);
  	sudoku = malloc(9 * 9 + 9);
  	i = -1;
  	j = 0;
  	while (++i < 9)
  	{
    		sudoku[i] = malloc(9 + 1);
    		sudoku[i] = argv[++j];
    		sudoku[i][9] = '\n';
  	}
	prepare_solv(sudoku);
  	return (0);
}

Et voici ma fonction qui fais appel à init_sudok() :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void	prepare_solv(char **sudoku)
{
	char **first_sudok;
	char **second_sudok;
 
	first_sudok = init_sudok(sudoku);
	solver(first_sudok, sudoku, 0, 0, 1);
	second_sudok = init_sudok(sudoku);
	solver(second_sudok, sudoku, 8, 8, -1);
	if (compare_sudok(first_sudok, second_sudok))
		putsudoku(second_sudok);
	else
		write(1, "Plusieurs solutions", 20);
}

[Sve@r]

Code :

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

1
2
	char **sudoku;
	sudoku = malloc(9 * 9 + 9);

Bonjour

Déjà ici ça ne va pas. sudoku est un char** donc un truc destiné à recevoir l'adresse de départ d'une zone de char*. Chaque char* de ladite zone recevra ensuite, lui, l'adresse de départ d'une zone de char.
Il s'ensuit que sudoku doit allouer n <char*>. Or toi, tu lui alloues n <char>. Et comme un char (zone prévue pour stocker un caractère) n'est pas un char* (zone prévue pour stocker l'adresse d'un caractère), ça ne peut pas aller.
Accessoirement, si le "+9" veut montrer l'espace pour le '\0', alors vaut mieux écrire "9 * (9+1)" pour bien montrer aux autres lecteurs qu'on alloue 9 chaines de 9 caractères (parce que moi j'ai galéré 10mn avant de comprendre le but)...

Code c :

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

1
2
   		sudoku[i] = malloc(9 + 1);
    		sudoku[i] = argv[++j];

Bon ben que dire devant ce genre d'instruction. Le plus terrible, c'est que ça ne te choque même pas d'affecter deux valeurs différentes à la même variable. Tu peux me dire à quoi tu penses au moment exact où tu écris ça ???

[Médinoc]

En fait, vu qu'un sudoku est un tableau 2D de taille connue à la compilation, le plus simple serait de le déclarer en tant que tableau statique 9×9 dans une struct; ainsi, pour chaque nouvelle grille, il suffira d'un malloc(sizeof(struct sudoku)) et la copie peut se faire par un simple memcpy()...

[Dihydrro]

Par contre je ne peux pas utiliser memcpy, pour effectuer ce programme j'ai seulement le droit d'utiliser malloc/free/write.
C'est vrai que le main ne ressemblait à rien je l'avais codé il y a un bon moment, je l'ai corrigé, mais mon problème reste le même.

Mon problème risque-t-il pas d'être le même avec une structure? Tout comme il devrait être le même dans un tableau de char de 81 cases, non?

Ce qui m'étonne vraiment c'est que lorsque je copie la première ligne cela se déroule correctement. Mais à partir de la cinquième ligne, les caractères de la première ligne se modifient par ces caractères étranges petit à petit après chaque copie de ligne.