[besoin D'aide]projet En Langage C : Pointeurs Et Allocation Mémoire

[Reveur_ml]

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 )

---------------------------------------------------------------------

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.

[theocrite]

Petit résumé de ma situation: je suis actuellement à "cheval" entre la 2e et la 3e année de mon Ecole

Tiens un PEP

Bon j'ai pas tout lu. Je me suis arrêté quand tu as présenté la situation (ce qui est bien fait par ailleurs). Par contre si j'ai bien compris, tu as simplement copié collé ton sujet ensuite.

Il vaut mieux poser des questions simples et précises sur les sujets qui te bloquent.

[Jiriki]

Salut.

Je vais te dire ce que j'ai compris de l'énoncé sur lequel tu bloques:

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.

Déjà si tu mets cette phrase à côté d'une de celle du début, on comprend mieux:

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: [...]

Tu as déjà écris le code qui te permet de mettre en mémoire. Maintenant, il reste à écrire la partie qui lit les données dans le fichier.

Cela signifie que tu dois écrire un programme qui va lire le fichier et utiliser ce que tu as déjà écris pour le mettre en mémoire.

Donc tout va partir de la fonction shred* loadShred(char *fileName);

=> manipulation du fichier

=> création de la structure en mémoire.

---------------------------------------------------------

Pour ce qui est de la structure de ton programme,

le main va appeler cette fonction.

Pour la manipulation du fichier, il vaut mieux que tu créés des fonctions en dehors de loadShred, ce sera beaucoup plus clair.

Par exemple, une fonction pour ouvrir le fichier (et faire le test à NULL dont l'énoncé parle)

Une fonction (ou plus...) pour progresser dans la lecture du fichier.

Peut être une fonction pour fermer le fichier.

Je crois me rappeler que le type FILE est un type prédéfini, tu n'as donc pas à le créer.

Pour vérifier, tu n'a qu'à créer une variable de ce type dans un prog et vérifier si ça compile.

Au final ta fonction loadShred doit:

1- Lancer l'ouverture du fichier

2- Lancer la lecture dans ce fichier

3- Lancer la création de la structure

4- Recommencer les étapes 2-3 tant que tu n'es pas à la fin du fichier.

5- Lancer la fermeture du fichier

Voilà, en espérant que ça t'aide...

[neologix]

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.

FILE, c'est un stream. L'idée, c'est qu'en fait tout est fichier (y compris les périphériques), donc ça te permet de bosser de façon transparente sur énormément de choses différentes. A un niveau plus bas, tu as les descripteurs de fichiers.

FILE: En gros, quand tu ouvres ou créés un fichier avec fopen, on te renvoie FILE. C'est là dessus que tu travailles.

Tu n'as pas à le définir toi-même, il suffit de le déclarer avant de l'utiliser.

Exemple:

tu veux ouvrir le fichier data.txt dans le répertoire courant:

FILE *fichier;

fichier = fopen("data.txt, "r+");

pour l'ouvrir (et pouvoir écrire dedans).

Ensuite, tu lui fais des trucs (fprintf, fseek, rewind, etc).

Quand tu as fini, tu le fermes par fclose(fichier).

Je te conseille ce guide, il est clair et va vite au fait:

http://beej.us/guide/bgc/output/html/index.html

Essaie de poser des questions plus précises, parce que je t'aiderais bien, mais là j'ai les partiels qui arrivent (écolde d'ingé powaaaaaaa...)

[Captain Hadock]

Ça a l'air bien marrant tout ça.

Bon comme cela a déja été dit le type FILE est déja défini.

tu ouvre en apellant

FILE *fopen("nomdufichier","typed'ouverture")

Dans ton exemple, il s'agit seulement d'une lecture à effectuer dans un fichier texte donc ce sera du genre :

FILE *FICH_BANDE;			 /*Pointeur sur le fichier.*/

FICH_BANDE = fopen("bande21.txt","r");	 /*Ouverture du fichier bande21.txt en lecture*/

if(FICH_BANDE == NULL) /*L'ouverture a échoué*/
{
 ...	   /*La c'est à toi de voir si tu veu arreter.*/
		/*Le problème, mais si le programme fait un fgets sur un FILE* NULL, sa peut planter....*/
}

ensuite tu peux te ballader dans le fichier en utilisant

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

c'est a dire dans notre cas :

/*Une chaine de charactère char *s a été précédement défine et on lui a alouée de la mémoire pour une ligne de charactères*/
/*Et une int cmax pour le nombre maximal de char à lire avec fgets*/

fgets(s, cmax, FICH_BANDE);  
											  /* s pointe maintenant sur une chaine de char
											  contenant une ligne de FICH_BANDE (ne contenant pas plus de cmax chars)*/ 

/*cette chaine peut maintenant être affichée avec*/
printf("%s\n", s);

Si tu refait un fgets, il lira la suite du fichier.

C'est pour ça que l'on teste avec

do{
/*Ici les opérations de traitement de la ligne*/
}
while(fgets(s, cmax, FICH_BANDE))

car si un NULL est revoyé, c'est que la fin du fichier est atteinte.

Dans cette boucle, il faudra tranformer les char* "1026" en int 1026 en gros pour shématiser.

Pour cela il faut utiliser

int atoi(const char *nptr);

en envoyant un pointeur sur l'endroit ou est marqué le nombre dans la chaine de charactères.

Je ne connais pas trop cette fonction, donc je laisse le soin à d'autre de te l'expliquer.

Enfin une fois que tu en a fini avec le fichier, il faut le fermer en utilisant

fclose(FICH_BANDE);/*Fermeture du fichier*/
FICH_BANDE=NULL; /*Pas sur que ce soit necessaire...*/

Voila, cela n'est pas du tout une réponse, mais j'essai de te montrer comment tu pourrait utiliser les fonctions qui te sont imposées, ensuite à toi de structurer, d'allouer et de désalouer la mémoire pour les chaines temporaires et à remplir les structures avec le contenu des lignes du fichier.

N'étant pas du tout un expert du C, je m'excuse d'avance pour toute grossière erreur que j'aurai commise dans ce post.

[neologix]

Enfin une fois que tu en a fini avec le fichier, il faut le fermer en utilisant

fclose(FICH_BANDE);/*Fermeture du fichier*/
FICH_BANDE=NULL; /*Pas sur que ce soit necessaire...*/

fclose() te renvoie un EOF en cas d'erreur.

On peut récupérer le code de l'erreur grâce à stderr.

(Je ne suis pas non plus un gourou du C, loin de là ;-)