Les pointeurs, aide SVP

Bonjour,

J'ai fait une source avec plusieurs fichier *.cpp et plusieurs fichiers *.h
Dans un fichier main.cpp, j'ai créé un pointeur BYTE *LesOctets;
Je n'ai donc à ce moment pas encore alloué d'espace pour la mémoire...
Je souhaite le faire par le biais d'une fonction (déclarée dans un autre fichier) qui a pour prototype
BOOL LectureFichier(char * NomDeFichier, BYTE *Buffer);
Dans laquelle je vais rentrer dans BYTE *Buffer le nom LesOctets.
C'est à dire qu'en utilisant cette fonction, je vais écrire (dans le fichier main.cpp ou est déclaré le pointeur BYTE *LesOctets):
LectureFichier(szFileName,LesOctets);

Durant cette fonction, je souhaite allouer de la mémoire pour le pointeur LesOctets, en faisant:
Buffer = new BYTE[tailleFichier] //TailleFichier étant calculée juste avant.
Dans la fonction, l'allocation de mémoire fonctionne parfaitement, mais lorsque je souhaite utiliser le pointeurs LesOctets dans le fichier main.cpp, le pointeur reste NULL. Je n'arrive donc pas à récupérer les octets que je viens de rentrer dans le pointeur LesOctets dans le fichier main.cpp.

Or, ceci doit être possible, comme on peut le trouver dans plusieurs fonctions standard du c++, telles que sprintf(szBuffer,"texte formatté",...);

Je ne sais pas comment faire, si quelqu'un peut m'aider, ça serait bien sympathique.
Je pourrais peut être donner mon code source pour exemple:

//fichier main.cpp
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HANDLE hFile;
static TCHAR szFileName[MAX_PATH], szTitleName[MAX_PATH];
static BYTE *LesOctetsDuFichier;
TCHAR TestBuffer[5000];
static DWORD iFileSize;
int wmId, wmEvent;
RECT rect;
PAINTSTRUCT ps;
HDC hdc;

switch (message)
{
//case WM_INITDIALOG:
//PopFileInitialize(hWnd);
//break;

case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Analyse les sélections de menu :
switch (wmId)
{
case IDM_FILE_OPEN:
if (PopFileOpenDlg(NULL,szFileName,szTitleName))
{
if (!LectureDuFichier(szFileName, LesOctetsDuFichier, &iFileSize))
MessageBox(hWnd,TEXT("Erreur lors de la lecture du fichier"),TEXT("Attention"),MB_OK);
else
{
//sprintf(TestBuffer,TEXT("Taille du fichier lue dans WinProc = %d"),iFileSize);
//MessageBox(NULL,TestBuffer,TEXT("Info"),MB_OK);
InvalidateRect(hWnd,NULL,TRUE);
}
}
break;

case IDM_ABOUT:
DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
if (LesOctetsDuFichier!=NULL) //si on a rentré des données dans les octets à traiter
{
GetClientRect(hWnd,&rect);
MessageBox(hWnd,TEXT("Nous sommes dans le cas ou des données sont présentes dans le buffer des octets du fichier"),TEXT("Info"),MB_OK);
DrawText(hdc,(LPCTSTR) LesOctetsDuFichier,-1,&rect,DT_LEFT);
}
// TODO : ajoutez ici le code de dessin...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}

//fichier secondaire.cpp
BOOL LectureDuFichier(PTSTR pFileName, BYTE *Buffer, DWORD *TailleDuFichier)
{
DWORD nbreOfBytesRead;
BYTE *Buffer2;
TCHAR TestBuffer[500];

HANDLE hFile=CreateFile(pFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if (hFile==INVALID_HANDLE_VALUE)
{
MessageBox(NULL,TEXT("Erreur de lecture du fichier spécifié, veuillez recommencer..."),TEXT("Erreur"),MB_OK);
return FALSE; //on sort de la fonction, car une erreur s'est produite
}

(*(TailleDuFichier))=GetFileSize(hFile,NULL);

//sprintf(TestBuffer,TEXT("Taille du fichier = %d"),(*(TailleDuFichier)));
//MessageBox(NULL,TestBuffer,TEXT("Info"),MB_OK);

Buffer2 = new BYTE[(*(TailleDuFichier))+1];

ReadFile(hFile,Buffer2,(*(TailleDuFichier)),&nbreOfBytesRead,NULL);

if (nbreOfBytesRead<(*(TailleDuFichier)))
{
CloseHandle(hFile);
delete Buffer2;
return FALSE;
}

Buffer2[(*(TailleDuFichier))]='\0'; //on met le caractère nul à la fin du buffer

if (Buffer!=NULL) {MessageBox(NULL,"Erreur de buffer non nul","info",MB_OK); delete Buffer;}

sprintf(TestBuffer,TEXT("Adresse du buffer avant new = %X"),Buffer);
MessageBox(NULL,TestBuffer,TEXT("Info"),MB_OK);

Buffer = new BYTE[(*(TailleDuFichier))+1]; //on alloue de la mémoire pour le tableau de bytes utilisé dans WinProc

sprintf(TestBuffer,TEXT("Adresse du buffer après new = %X"),Buffer);
MessageBox(NULL,TestBuffer,TEXT("Info"),MB_OK);

for (unsigned int i=0;i<(*(TailleDuFichier));i++)
*(Buffer+i)=*(Buffer2+i); //On copie les données dans le buffer que l'on pourra utiliser dans WinProc

CloseHandle(hFile);
delete Buffer2;
return TRUE;
}

En esperant avoir des réponses rapidement, merci.
:-)



JB

Salut,
Pour modifier une variable depuis une fonction, il faut passer la variable par adresse.
Meme logique pour les pointeurs: pour modifier un pointeur depuis une fonction, il faut passer le pointeur par adresse, c'est a dire un pointeur de pointeur.

ta func doit etre prototypée comme ca:
BOOL LectureFichier(char * NomDeFichier, BYTE ** Buffer);

et il faut passer &LesOctets en param.

et dans la fonction tu modifies Buffer:
*Buffer = ... ;

beaucoup plus simple en c++, passage par reference

BOOL LectureFichier(char * NomDeFichier, BYTE * (&Buffer) );

+ simple certes mais source d'erreur


personnellement je préconnise:
référence constante pour donnée non modifiable

et
adresse pour donnée modifiable

sinon, initialise bien ton ptr à NULL au début, ça pourrait éviter des erreurs et des fuites mem

++

Magic Nono: l'informagicien!

arrete, en c++ on utilise les references et on oubli les pointeurs qui sont eux sources d'erreurs et de gros plantage

d'ailleur le passage par reference est plus puissant que le passage par pointeur en c, ca créé un veritable alias de n'importe quel type

tu sais bien que le but des references c'est de ne plus avoir à utiliser de pointeurs ?

ui djl

mais
peux tu plus développer stp
("plus puissant "& "veritable alias ")
que je sache, au final, c'est tjs une adresse qui est transmise...

pkoi po les utiliser, ç change juste l'utilisation:
-> en . et *truc=... en truc=...

je trouve que ça le fait ressortir,
mais C vrai que C la vieille école du C...
++
Magic Nono: l'informagicien!

PS: certes complexes à maitriser au début, mais on fait quasi tt avec les ptr

OK les gars,

Je vous remercie bien, je vais essayer vos trucs, et je choisirai par la suite entre pointeurs et references, je verrais le plus simple...

++
et encore merci (si ca ne marche pas, je referais un message, lol)

JB

jb60 > ya pas photo, utiliser les references c'est profiter d'un fabuleux outil offert par le c++

magic_Nono > alias 'pour' n'importe quel type je voulais dire, par exemple pour les tableaux multidim

entre

void f(int *n)
{
*n = 5;
}

...

f(&n);


et

void f(int &n)
{
n = 5;
}

...

f(n);


rien que sur cette exemple simplissime on voit tout de suite que le passage par pointeur sera source d'erreur alors qu'avec reference c'est completement transparent


void f( truc **t )
{
*t = new truc[...];

for( ... )
{
(*t)[i] = ...
}
}


void f( truc * (&t) )
{
t = new truc[...];

for(...)
{
t[i] = ... ;
}
}


c'est la peine de continuer ?

J'ai une autre question...
Voilà la source que j'ai entrée (désolé djl pour ne pas avoir utilisé les références tout de suite, lol):

BOOL LectureDuFichier(PTSTR pFileName, BYTE **Buffer, DWORD *TailleDuFichier)
{
DWORD nbreOfBytesRead;
//TCHAR TestBuffer[500];

HANDLE hFile=CreateFile(pFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if (hFile==INVALID_HANDLE_VALUE)
{
MessageBox(NULL,TEXT("Erreur de lecture du fichier spécifié, veuillez recommencer..."),TEXT("Erreur"),MB_OK);
return FALSE; //on sort de la fonction, car une erreur s'est produite lors de l'accès au fichier
}

(*(TailleDuFichier))=GetFileSize(hFile,NULL);

if (*Buffer!=NULL) {MessageBox(NULL,"Erreur de buffer non nul","info",MB_OK); delete Buffer;}

*Buffer = new BYTE[(*(TailleDuFichier))+1]; //on alloue de la mémoire pour le tableau de bytes utilisé dans WinProc

ReadFile(hFile,*Buffer,(*(TailleDuFichier)),&nbreOfBytesRead,NULL);

//sprintf(TestBuffer,TEXT("Nous sommes juste après ReadFile"));
//MessageBox(NULL,TestBuffer,TEXT("Info"),MB_OK);

if (nbreOfBytesRead<(*(TailleDuFichier)) )
{
MessageBox(NULL,TEXT("Attention, le buffer ne devrait pas etre delete"),TEXT("Erreur"),MB_OK);
CloseHandle(hFile);
delete *Buffer;
return FALSE; //on sort de la fonction
}

(*Buffer)[*(TailleDuFichier)]='\0'; //on met le caractère nul à la fin du buffer

CloseHandle(hFile);
return TRUE;
}

et en fait, lorsque j'utilise une première fois la fonction, c'est bon, ca marche, mais ensuite si je réutilise ma fonction, alors une adresse est présente dans LesOctets (représenté par Buffer dans la fonction). Donc je delete cette adresse, pour réallouer une zone mémoire avec assez d'espace pour contenir les prochaines données. Or, le programme plante lorsque je suis dans la boucle
if (*Buffer!=NULL) {MessageBox(NULL,"Erreur de buffer non nul","info",MB_OK); delete Buffer;}
comme si je ne pouvais pas delete le pointeur, alors que je l'ai initialisé précédemment avec l'opérateur new...

Si quelqu'un comprends cette erreur, je suis preneur de la réponse.

Merci.

++

JB

Au fait djl,

Est-ce qu'avec un passage par référence on peut utiliser l'opérateur new et delete, comme avec des pointeurs?
Ou y'a t'il quelque chose de spécial à faire?

JB