Je travaille sur un petit projet à moi ( c´est rien de passionnant, c´est des petits travaux ici et là pour l´expérience ) . J´ai un objet ( qui vise à lire un TGA ) dans lequel une fonction nommée `read(const char *file ) ` lance les lignes suivantes:

FILE *tga = fopen(file, " rb");
if(tga == NULL)
{
return false;
}

Peu importe ce que je fais, le pointeur tga est toujours égal à NULL et c´est false qui est retourné. Quelqu´un a une idée de ce qui peut causer ça ? Je suis un peu ( lire: complètement ) perdu... le fichier existe et tout semble normal ( c´est pas le premier fopen que je fais, quand même... ) . C´est quand même un objet important et assez gros ( du moins, selon mes standards ) alors j´espère vraiment que c´est un détail que j´ai merdé.

Merci...

J´ai fait un petit test...

Si je prends la fonction read et que j´enlève tout ce qui vient après le fopen ( en laissant le fopen et le test tga == NULL comme ils sont), l´ouverture de fichier a lieu correctement.

Or, selon le debugger, dès que je remets le reste de la fonction en place, l´ouverture ne se fait plus ( tga devient égal à NULL après l´ouverture).

Je suis vraiment absolument perdu.

La fonction fopen est trés stable et fiable. Si le pointeur retourné est NULL c´est que le fichier est pas trouvé.

Pour ne pas t´embrouiller utilise des noms de variables plus claire, genre " filename" au lieu de " file" . .. " filehandle" au lieu de " tga" ( ou " file" tout court a la limite).

Pour debugger ca, il faut tracer pas a pas, c´est le meilleur moyen de comprendre ce qu´il se passe ( en general les debutant font des hypotheses sur leurs erreurs qui sont fausses)

Merci pour ta réponse,

" La fonction fopen est trés stable et fiable. Si le pointeur retourné est NULL c´est que le fichier est pas trouvé."

Je vois mal comment ça pourrait être le cas... J´ai essayé de virer la variable `file` ( le paramètre de la fonction read) et de taper directement le path vers le fichier entre guillemet. Ça foire quand même.

En ce qui concerne tracer pas à pas... j´ignore ce qu´il faut faire exactement pour en arriver là, j´ai simplement mis des breakpoints autour du fopen pour voir à quel moment ça merdait...

Je vais quand même essayer de mettre des noms de variable plus clairs... sait-on jamais.

Ça va probablement être une fausse hypothèse de débutant mais...

Pour que le prog arrive à trouver le fichier seulement quand je ne laisse que le fopen ( et rien d´autre) dans ma fonction... est-ce que ça peut vouloir dire que certaines actions qui ont lieux pendant la fonction ( je créé des instances de quelques objets par exemple) peuvent avoir été placées AVANT le fopen ( automatiquement, par le compilo) et entrées en conflit ( pour cause d´une erreur que je n´aurais pas vu) avec le fopen ?

Je suis vraiment à court d´explication hehe

La reponse a ce genre de probleme est simple, le chemin que tu indique est faux . ..

Pour etre sur, utilise des noms avec le chemin complet !

car :

fopen("Monimage.tga", " rb");

ne te permets pas d´etre sur dans quel repertoire l´image ca etre chargee ( c´est le repertoire du projet ou celui ou est lancee l´exe)...

par contre, un

fopen("C:\Monimage.tga", " rb");

sera bien plus fiable.

Ensuite tu pourra ajuster

Pour que le prog arrive à trouver le fichier
seulement quand je ne laisse que le fopen
( et rien d´autre) dans ma fonction

Ben si le reste de ton code detruit la moitie de la memoire, il y a des chance que plus rien ne marche correctement en effet.
Dans les autres cas, tu as raison, c´est une hypothese de debutant fausse !

Regle de base dans la programmation : " Il ne se passe jamais rien ne mysterieux ! "

" Il ne se passe jamais rien ne mysterieux ! "

Hehehe, pour être honnête, je trouve mon problème plutôt mystérieux .

J´ai essayé un path absolu vers le fichier, le résultat n´est malheureusement pas plus satisfaisant. Ça fonctionne seulement si j´élimine les memcmp que je fais un peu plus loin...

Je vais probablement finir par tout simplement envoyer tout ça dans la corbeille heh.

Il y a du progrès, je viens de réussir à faire foirer l´ouverture du fichier même en ne faisant pas les memcmp hehehe .

il doit etre tout pourri ton code dit moi

Ouais, j´ai beaucoup de mal à travailler proprement... J´essais au mieux de mes capacités mais je manque d´habitude et je devrais vraiment lire un document sur les normes de propreté en C++.

En gros je pense simplement que j´ai merdé avec les variables et leur contenu...

Donc, pour faire les choses correctement est-ce que je dois faire

fopen("C:\Monimage.tga", " rb");

ou

fopen("C:\\Monimage.tga", " rb");

avec deux \ ?

C´est justement ce que j´allais conseiller !

Oui bien sur, si tu utilises une constante caractère pour le chemin du fichier ne pas oublier le \\, sinon c´est le ´M´ qui est considéré comme séquence d´échapement ( le compilateur doit te prévenir d´ailleurs).

Sinon il me semble que fopen positionne le errno, donc en faisant un perror tu pourrais avoir plus de précision sur pourquoi il a pas réussie à l´ouvrir ( problèmes de droits par exemple . ..)

Nope, le compilo ne se plaignait pas du \M. En clarifiant mes noms de variables et en utilisant \\ pour le path absolu, ça a solutionné le problème.

Merci !

maintenant je dois réparer le buffer overflow que j´ai créé avec mon décodeur pour le RLE ( ça va faire mal).

Hahahaha j´ai fait ( je résume grossièrement) l´opération suivante:

char buffer[1];
fread(buffer, 1, 1, fichier);

et j´ai utilisé ( unsigned int)buffer dans mes boucles au lieu de ( unsigned int)buffer[0].

J´te jure, tu sais que tu as du talent quand tu fais des boucles avec les valeurs entières non signées formées avec des adresses plutôt que des chiffres .

Merci à vous, je pense que ça conclu mon questionnement pour ce problème.

arf !

En tout cas, oui, j´avais déja remarqué que pour les noms de fichiers, faut bien mettre \\ comme dans les printf

Oui desolé pour le \\

De tout facon des que tu as des guillemets, le \ est utilisé pour rentre des codes speciaux ( \n par exemple . .. ) Donc pour mettre un vrai \, faut utilise le code \\

Ouais je sais, c´est simplement que l´habitude d´écrire les paths avec un seul \ a pris le dessus .

J´ai réussi à faire fonctionner mon programme ( il n´est pas terminé mais le TGA se charge et je l´affiche sans problème).

Je pense qu´au final, je vais simplement noter ça comme un problème de rigueur dans ma nomenclature.

Merci à tous.

Les backslash, c´est toujours emmerdant en C, je ne te raconte pas la tete que ça devait avoir en mémoire ton nom de fichier s´il insérait les caracteres d´échappements a chaque fois

Essaie les slash / il me semble que le C tolere cela ( comme la norme Unix)
En tout cas, il les toleres dans les include :

1. innclude < gl/gl.h>