Forum Clubic

[Besoin d'aide]Projet en langage C : pointeurs et

Bonjour à toutes et à tous,

Si je viens vers vous ce soir, c’est pour demander humblement de l’aide.
En effet, voilà 1 semaine que je planche sur un projet en C…et malgré tous mes efforts je n’avance que très lentement.
La date limite approche, il me reste moins d’une semaine pour terminer mon travail, et je suis très loin du but.

Ce que j’attends de vous?
Pas que vous me pondiez un code que je pourrais copier / coller, mais uniquement des conseils, des explications, des pistes. Vous pouvez même ne pas taper une seule ligne de C dans vos réponses, et vous contenter de me guider un peu, cela me sera déjà énormément utile (vraiment).

Pourquoi je n’y arrive pas seul?
Petit résumé de ma situation: je suis actuellement à “cheval” entre la 2e et la 3e année de mon Ecole, il ne me manque que 2 crédits (sur 60) de 2A pour valider mon année, sans quoi je resterai bloqué l’année prochaine et ne pourrai pas passer en 4A.
Ces 2 crédits, je ne peux les obtenir qu’avec ce projet; mais cela fait 2 ans que je n’ai pas touché au C et même en reprenant assidument mes anciens cours, cela me prend énormément de temps pour me remettre à niveau.
Qui plus est, ce projet est censé être fait en binôme, mais étant le seul 3A de ce cours, je me retrouve seul, les autres ses connaissant et ayant déjà formé leurs binômes…ce qui n’arrange vraiment pas ma situation.

Je vais maintenant vous montrer le sujet et ce que j’ai déjà codé.
Le thème est le suivant: vous connaissez ces fameuses machines qui coupent les documents “ultra confidentiels” en fines bandelettes? Dans ce projet, on nous donne ces bandelettes (sous forme d’images) et le but est d’essayer de trouver laquelle va à côté de laquelle, pour reconstituer le document original.
Au début de ce projet, on nous donne des fichiers texte contenant les valeurs des pixels des bords gauche et droit de chaque bandelette; il “suffit” alors de voir quels sont les bords ayant le plus de similitudes pour reconstituer le document.

C’est facile sur le papier, mais concrètement…enfin je vous laisse lire la suite.
(Si vous êtes encore là à me lire, après mon discours d’intro, j’ai de la chance :p)


Contexte

On cherche à reconstituer un document détruit par un destructeur de documents. Il faut retrouver l’ordre des images des bandes de papier pour créer l’image du document original. Ce problème est complexe à double titre:

-Le nombre de configurations possible est factorielle le nombre de bandelettes. Ainsi le nombre d’arrangements possible pour 20 bandelettes est 20! = 2.43290200817664e+18 ce qui est déjà considérable.

-Il s’agit ici de documents “scannés” donc des images et non les vrais documents informatiques. Même si on est capable de recréer tous les documents possibles, reconnaître celui qui est identique au document original est en soi un problème complexe.

Nous essayerons de trouver des solutions approchées, pour le moment ce projet consiste à charger en mémoire des données représentant des bandelettes, c’est ces données que nous utiliserons dans nos algorithmes de reconstruction.

Les données sont les images des bandelettes, une image est composée d’une matrice de pixels (abréviation de picture element"), chaque pixel a une valeur entre 0 et 255 (0 pour le noir, 255 pour le blanc, et un dégradé de gris entre les deux).

Pour reconstituer le document nous allons simplement agencer les bandelettes, les unes à côté des autres en essayant de satisfaire au mieux une contrainte de continuité sur els bords, pour cela nous n’avons besoin que de la liste des valeurs des pixels sur les bords droit et gauche de chacune des images.

Ce travail a été fait pour vous (pour vous éviter d’avoir à gérer les notions d’image). Les données que vous manipulerez sont déjà extraites dans des fichiers. Il s’agit de suites de nombres qui sont les valeurs des pixels des bords des bandelettes.


Le programme

Voici le format des fichiers représentant nos données:

slice length 1710
252 252
252 252
252 246
237 252
252 250
244 234

(il y a 1710 lignes dans cet exemple)

La première ligne donne l’information du nombre de données, les lignes suivantes sont les valeurs des pixels des bords gauche et droit.
Nous allons écrire un programme qui lit le contenu de tels fichiers et qui les met en mémoire dans la structure de données suivante:

typedef struct
{
int size;
unsigned char *data;
} vector;

Ceci permet de définir un nouveau type de “vector” permettant de regrouper sous un même nom de variable:
-un pointeur sur les valeurs des pixels du bord des bandelettes
-et le nombre d’éléments pointés.

typedef struct
{
char id[1024];
vector *left;
vector *right;
} shred;

Ceci définit un nouveau type “shred” qui permet de regrouper sous un même nom de variable ce dont nous avons besoin pour représenter une bandelette:
-un identifiant de bandelette (c’est tout simplement le nom de fichier dans lequel on a lu les valeurs).
-2 pointeurs sur des “vector” qui contiennent les données des bords gauche et droit de la bandelette.

Ecrivez les fonctions d’allocation et désallocation mémoire du type vector avec les prototypes suivants:

vector *vectorAllocate (int size);
void vectorDestroy(vector *v);


Etapes à suivre:

1-écrivez la fonction d’allocation et écrivez un appel de cette fonction dans le main.
2-mettez y juste quelques données que vous écrirez directement dans le code.
3- affichez ces données.
4-puis appelez la fonction de désallocation.

Avec la même méthodologie vous écrirez les fonctions d’allocation et désallocation du type shred avec les prototypes suivants:

shred* shredAllocate(int leftSize, int rightSize);
void shredDestroy *s);

Jusqu’ici, tout va bien, j’ai réussi (en une semaine) à tout coder.
Voici ce que j’ai pour l’instant codé, cela se compile bien, je ne pense pas qu’il y aie de fautes.
Chaque fonction étant bien détaillée dans l’énoncé, je ne pense pas avoir à mettre de commentaires dans le code.
Si celui-ci est obscur, n’hésitez pas à me demander et j’ajouterai tous les commentaires nécessaires.



#include <stdio.h>
#include <stdlib.h>



typedef struct
	{
	int size;
	unsigned char *data;
	} vector;




typedef struct
	{
	char id[1024];
	vector *left;
	vector *right;
	} shred;




vector *vectorAllocate (int size)
	{
	vector *ptr = (vector*) malloc(sizeof(vector));
	ptr->size=size;
	ptr->data = (unsigned char*) malloc(ptr->size * sizeof(unsigned char));
	return(ptr);
	}




void vectorDestroy(vector *v)
	{
	free(v->data);
	free(v);
	}




shred* shredAllocate(int leftSize, int rightSize)
	{
	shred *ptr = (shred*) malloc(sizeof(shred));
	ptr->left = vectorAllocate(leftSize);
	ptr->right = vectorAllocate(rightSize);
	return(ptr);
	}




void shredDestroy(shred *s)
	{
	free(s->left);
	free(s->right);
	}




int main()
	{

	vector *tmp;
	shred *tmp2;

	tmp=vectorAllocate(1710);
	tmp->data[2]=250;
	tmp->data[1709]=10;
	printf("\n %d , %d \n",tmp->data[2], tmp->data[1709]);

	tmp2 = shredAllocate(1710,1710);
	tmp2->left->data[0]=1;
	tmp2->left->data[1]=2;
	printf("\n %d , %d \n",tmp2->left->data[0], tmp2->left->data[1]);

	vectorDestroy(tmp);
	shredDestroy(tmp2);
	return 0;
	}	


Maintenant on passe à la phase suivante…
Et sincèrement , ce n’est pas juste difficile pour moi, c’est tout bonnement incompréhensible.

Un exemple tout bête: dans ce qui va suivre, le prof parler du type “FILE”, mais qu’est-ce que c’est?
Quelque chose d’inclus dans les librairies, quelque chhose que je dois définir moi même?
Un autre: il ne précise pas combien de fonctions je dois coder en tout; tout cela est-il une seule grosse foction? Chaque point abordé est il une fonction? Je n’en ai aucune idée.

Je bloque complètement…des explications, des conseils, je vous en prie, me seraient Extrêmement utiles.

Voici donc la suite du projet (à noter que ce n’est loin d’être la fin…mais je préfère déjà me concentrer sur cette partie, plutôt que de m’étaler sur tout en même temps).


Vous allez écrire la fonction de lecture de données dans le fichier avec le prototype suivant:

shred* loadShred(char *fileName);

Cette fonction a comme unique paramètre le nom du fichier à charger, et retourne un pointeur sur la structure de données qu’il aura alloué (en appelant les fonctions précédemment définies) et rempli.

Pour pouvoir lire dans un fichier il faut l’ouvrir, lire les données puis le fermer, cela se fait grâce aux fonctions fopen, fgets, fclose de la librairie stdio (standart input output). La fonction fopen prend en paramètre le nom de fichier à ouvrir et ce que l’on veut en faire: lire ("r"ead) ou écrire ("w"rite). Elle retourne une valeur de type FILE c’est le descripteur de fichier qui idetifie le fichier que l’on est en train de manipuler. L’appel à cette fonction devrait donc ressembler à ça:

FILE *file;
file = fopen(fileName, "r");

Vous testerez que la variable file est différente de NULL pour vous assurer d’une bonne ouverture du fichier. Vous pouvez alors lire le contenu du fichier ligne à ligne grâce ç la fonction fgets dot le prototype est le suivant:

char * fgets(char * s, int size, FILE * steam);

Les paramètres sont, dans l’ordre: la chaîne de caractères qui contiendra ce qui est lu dans le fichier (c’est à vous de donner un pointeur vers une zone de mémoire allouée), le nombre d’éléments alloués pour la chaine de caractères, et enfin le descripteur de fichier sur lequel on veut effectuer la lecture.

La fonction fgets retourne NULL quand elle arrive en fin de fichier ainsi le code suivant permet d’afficher le contenu d’un fichier.

while(fgets(buffer, 1024, file))
printf("%s\n", buffer);

Où buffer est un tableau de char de 1024 éléments.
Pour en finir avec le fichier il faut le fermer cela se fait avec la fonction fclose que l’on applique sur le descripteur de fichier. Le nombre de fichiers ouverts en même temps est limité, il faut donc toujours bien penser à fermer les fichiers une fois qu’on a fini de s’en servir.

fclose(file);

Il vous faut maintenant manipuler ce buffer pour en extraire les informations voulues car les chiffres qu’il contient ne sont pas directement utilisables; en effet il ne s’agit pas de nombre mais d’une chaine de caractères représentant ce nombre. Une fonction de la “stdlib” nous permet de faire cette traduction:

int atoi(const char *nptr); // Ascii TO Integer

Elle prend en paramètre un pointeur sur le début de l’endroit où est écrit le nombre et retourne l’entier correspondant (le const signifie que cette fonction ne modifiera pas le contenu des valeurs pointées).

Pour finir, vous écrirez une fonction d’affichage:

void printShred(shred *s);

que vous appellerez dans le main pour finir de tester votre fonction loadShred en affichant les données chargées.

Conclusion:
A la fin de la séance, vous devriez avoir écrit un programme qui lit un fichier texte de description de bord de bandelette, alloue la mémoire nécessaire, met les données en mémoire, affiche les valeurs lues, puis désalloue la mémoire. Tout ceci sans erreur ni fuite mémoire.

Lors de la prochaine séance, nous fabriquerons une liste chaînée pour charger en mémoire plusieurs bandelettes, nous pourrons alors faire des comparaisons et commencer la reconstruction du document détruit.


Même si je saisis dans l’ensemble l’algorithme de cette partie du code, si quelqu’un pouvait se dévouer pour me le réexpliquer plus en détails, ne serait-ce que ça, m’aiderait Beaucoup.

Je vous remercie d’avance pour votre soutien (et j’en ai besoin).
Si certains points ne sont pas clairs, n’hésitez pas à me poser des questions, j’y répondrai au plus vite.

Sur ce, je vous remercie déjà d’avoir lu jusqu’ici mon message, mais aussi d’avance pour vos réponses.
Bonne soirée et bonne continuation.
Un élève en école d’inge, honteusement faible en C.

Je n’ai rien noté d’anormal dans la première partie, perso, je met toujours les pointeurs à NULL après déallocation mais ce n’est pas obligatoire

FILE est un type de la libc : il te permet de manipuler les fichiers via un pointeur sur ce même type.
Je ne comprend pas vraiement où tu bloques mais bon en gros on te demande :

  • d’ouvrir le fichier de description : ca se fait via la fonction fopen qui te renverra un pointeur sur FILE,
  • de lire ce fichier : sachant que tu as défini 2 structures, il faudra donc que tu fasses une boucle tant que pas EOF (End Of File = fin de fichier), lecture de shred, affichage de la taille et des données (donc des 2 vecteurs), fermeture du fichier.

Pour la lecture, contrairement à ton prof, j’utiliserais plutot fread qui lira sizeof(struct shread) plutot qu’une chaine de caractère, pour le reste, je ne vois pas où sont les difficultés.
Précise les points qui te sembles sombres.

Si j’ai bien compris, le but de ce TP est uniquement de charger les données d’une “tranche” contenue dans un fichier, dans la structure de données.
il faut donc:

  • ouvrir le fichier

  • lire l’entête “slice length 1710” pour allouer la bonne taille de structure de données: 1710 dans l’exemple

  • lire toutes les lignes et remplir en même temps en RAM (avec chaque ligne de type: "22 252")

  • fermer le fichier (et garder un accès aux données en RAM pour les TP suivants)
    -désallouer les données

  • pour ce qui est de la création des fonctions: normalement, tu devrais pouvoir découper en fonctions comme tu veux, tant que c’est logique, mais ça dépend du profs (et de ses lubies), j’ai eu par exemple un prof qui refusait de voir du récursif (et sans raison) un autre qui voulait que TOUT soit factorisé: même 3 lignes de codes qui se répètent à 2 endroits: parfois au détriment des perfs: bref, les profs, faut pas les contredire, essaye de faire en fonction de ce qu’il a l’air de dire.
    Pour ma part, bien découper en fonction pas trop longues, mais pas trop imbriquées non plus, et surtoue qui répond à un besoin précis et logique, et pas juste une sous-partie de fonction.

Pour la lecture du fichier: dans l’énoncé, il y a tout ce qu’il faut:
fopen t’alloue une variable de type FILE, dont tu récupère le pointeur: donc un FILE* que tu utilise en argument de touts les fonctions qui agissent sur le fichier: fread, fscanf etc…

l’exemple qu’il donne t’affiche le contenu du fichier, il suffit de remplacer le printf par ton traitement pour remplire les variables:


FILE *file;
file = fopen(fileName, "r");


while(fgets(buffer, 1024, file))
printf("%s\n", buffer);

fclose(file);

Ensuite les String que tu lit contiennent exactement le contenu du fichier donné en exemple:

pour ma part j’aurait carément utilisé un scanf("%s %s %d",&header1, &header2, &size) pour l’entête puis un scanf("%d %d",&leftvalue, &rightvalue) pour chaque ligne de données: pour lire directement les données depuis le format “String”, mais si tu veux respecter l’énoncé du TP, il faut passer par la lecture d’une chaîne de caractères char*, et la “parser” pour retrouver les données, et les traiter.
je ne sait pas si je suis clair, mais ton fichier contient de L’ASCII, et il faut découper autour des “espaces” et des retours chariot pour retrouver les nombres, et ensuite convertir ces nombres ascii en binaire, ce que fait sa fonction “atoi” d’une façon très compliquée. Avec le scanf, tu fait tout ça directement: tu lit ligne par ligne, tu sépare sur les espace, et tu converti en entier avec le pattern “%d”.
tu peut aussi le faire dans un 2ème temps avec un sscanf(linetoparse,"%d %d",&leftvalue, &rightvalue)
avec linetoparse: le contenu de ton buffer, leftvalue et righet value les 2 entiers que tu lit à chaque ligne.

Edit: je croit que la solution de KarlKox est d’utiliser des fichiers binaires lus par “fread”, mais ça ne correspond pas à l’énoncé, et si le prof teste ton programme, il le fera avec des fichiers texte, et pas des fichier binaires.
D’ailleurs le traitement des “exceptions”, c’est à dire les cas d’erreur on il faut afficher un message d’erreur explicite, sont à traiter: il faut tester le retour non-null de la fonction fopen pour afficher un message “fichier inexistant”, s’il y a d’autres cas d’anomalies possibles: mauvais format de fichier etc. il doit falloir les traiter aussi, pour avoir les points “bonus” :wink:

PS: j’emploie souvent le terme “String” pour désigner les char* contenant une chaine de caractère, c’est une confusion liée au fait que ce terme est employé dans d’autres langages, je te laisse corriger mes erreurs.

Oui je parle de fread dans le cas où sont fichier est binaire :slight_smile:

plus en detaille que ça sans montrer le code c dur :stuck_out_tongue:

en gros lire un fichier c :

ouvrir le fichier (fopen)
si erreur sortir

allouer la structure (malloc)

lire la premiere ligne dans un buffer (fgets)
recuperer le nombre de slice … nb_slices=atoi(buffer+strlen("slice length "))

faire une boucle du nombre de slice et lire les lignes suivantes
recuperer les 2 nombre de chaque ligne… p->left[i]=atoi(buffer)… p->right[i]=atoi(buffer+4)

faire une boucle sur les vecteurs et afficher

desallouer

fermer le fichier

en général on lit tout puis après seulement on affiche, si dans ton traitement qqch merde ça évitera de laisser le ficher ouvert…