Problème de realloc

Version imprimable

Problème de realloc

Bonjour, j'ai un soucis avec mon realloc qui provoque visiblement une fuite mémoire avec un invalid next size.

Mais je ne vois pas du tout le soucis dans le code..
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int main(){ int buffsize=4; int init_size=4; int16_t * x=(int16_t*)malloc(buffsize*sizeof(int16_t)); int16_t i; int bytesRead; char *fi="test.wav"; FILE *fd_waveFile=NULL; wavfile head_waveFile; int cpt=0; wavRead(&fd_waveFile,fi,&head_waveFile); while ((bytesRead = fread(&i, sizeof(int16_t),1, fd_waveFile)) > 0){ if(cpt==(buffsize-1)){ x=(int16_t*)realloc(x,init_size*sizeof(int16_t)); buffsize=buffsize+init_size; } x[cpt]=i, cpt++; } return(0); }
L'erreur:

*** glibc detected *** ./test:realloc: invalid next size : une adresse mémoire

suivi d'une bonne vingtaine de ligne de bactrace.

15/11/2016, 08h57
Invité

C'est du C non?
fd_waveFile c'est un pointeur de fichier? a quoi sert "wavRead(&fd_waveFile,fi,&head_waveFile);", parce que si c'est une fonction qui permet de lire entete wav du fichier pointer par "fd_waveFile", il y-a un soucis puisque fd_waveFile == NULL. Donc il n-'y a aucun fichier ouvert.

Non c'est bien du c++;

et l'argument qui te dérange est un argument en sortie c'est donc normal qu'il ait cette forme là.

Code:

1
2
3
4
5
6
7
8
9
void wavRead(FILE **p_wav, char *filename, wavfile *p_header) {
	//fopen_s(p_wav, filename, "rb"); //Windows version
	*p_wav = fopen(filename, "rb");
	if (*p_wav == NULL) {
		fprintf(stderr, "Can't open input file %s\n", filename);
		exit(1);
 
......
	}

Par contre là mon erreur a évolué et ne vient plus du realloc j'ai une segfault avant

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int main(){
	int init_size=2000;
	int buffsize=init_size*sizeof(int16_t); //4 000
	int16_t * x=(int16_t*)malloc(init_size*sizeof(int16_t));
	int16_t i;
	int bytesRead;
	char *fi="test.wav";
 
 
	FILE *fd_waveFile=NULL;
	wavfile head_waveFile;
	int cpt=0;
	wavRead(&fd_waveFile,fi,&head_waveFile);
 
	while ((bytesRead = fread(&i, sizeof(i),1, fd_waveFile)) > 0){
		if(cpt==(buffsize)){
			//x=(int16_t*)realloc(x,init_size*sizeof(int16_t)); j'ai commenté ça pour tester
			buffsize=buffsize+init_size*sizeof(int16_t);
		}
		x[cpt]=i,
 		std::cout << "cpt=" << cpt << std::endl;
		std::cout << "buffsize=" << buffsize << std::endl;
		cpt++;
	}
return(0);
}

On sort avec une seg fault avec

buff size=4000
cpt=2013

15/11/2016, 09h17
Invité

a la ligne 15, si tu remplacer :

Code:

x=(int16_t*)realloc(x,init_size*sizeof(int16_t));

par

Code:

x=(int16_t*)realloc(x,buffsize*sizeof(int16_t));

et a quoi te sert:

Code:

bytesRead
15/11/2016, 09h18
Bktero

Que te dit valgrind ?

Tu as des problèmes avec realloc et pourtant tu ne vérifies ni le retour de malloc(), ni celui de realloc(). Ce n'est peut-être pas ça, mais ce n'est néanmoins pas une bonne idée.

Pourquoi réallouer avec init_size et non buffer_size ? Question inverse avec malloc().
15/11/2016, 09h20
Amnael

Citation:

Envoyé par Ratator

a la ligne 15, si tu remplacer :

Code:

x=(int16_t*)realloc(x,init_size*sizeof(int16_t));

par

Code:

x=(int16_t*)realloc(x,buffsize*sizeof(int16_t));

et a quoi te sert:

Code:

bytesRead

Le problème ne vient plus de là étant donné que j'ai commenté le realloc et que je ne le fais pas.

En outre, je préfère augmenter la taille de 4000 à chaque fois que de mettre au carré la taille...
15/11/2016, 09h23
Invité

Tu fais x[cpt] = i et si cpt est >= init_size?

int16_t * x=(int16_t*)malloc(init_size*sizeof(int16_t)); avec init_size = 2000

Et sur ton erreur cpt == 2013 :aie:
15/11/2016, 09h28
Amnael
Je simplifie le code pour montrer l'erreur.
Code:

1 2 int16_t * x=(int16_t*)malloc(buffsize); if (x==NULL) exit (1);
Ici, la taille du tableau buffsize est 4 000
Code:

1 2 3 4 5 6 while ((bytesRead = fread(&i, sizeof(i),1, fd_waveFile)) > 0){ x[cpt]=i, std::cout << "cpt=" << cpt << std::endl; std::cout << "buffsize=" << buffsize << std::endl; cpt++; }
Ici cette boucle va fonctionner jusqu'à cpt=2013 avant de faire une erreur de segmentation.

On est bien d'accord pour dire que 2013 < 4000 ?

Mon tableau est donc suffisamment large pour contenir la donnée et ici cela n'explique pas l'erreur de segmentation.

Essaye sa:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <string>
#include <vector>
 
int main(){
	std::vector<int16_t> x;
	int16_t i;
	std::string fi = "test.wav";
	FILE *fd_waveFile=NULL;
	wavfile head_waveFile;
	wavRead(&fd_waveFile,fi.data(),&head_waveFile);
	while ( fread(&i, sizeof(int16_t),1, fd_waveFile) > 0){
            x.push_back( i);
	}
    return(0);
}

15/11/2016, 09h37
Amnael

Ton code ne compile pas. (en tout cas chez moi).
15/11/2016, 09h41
Invité
Citation:

Envoyé par Amnael

Ton code ne compile pas. (en tout cas chez moi).

Oublie pas d'inclure ton header contenant tes wav... focntions et rajoute std=c++11 aux options de compilation

Tu peux aussi, faire:
Code:

1 2 3 4 5 6 7 wavRead(&fd_waveFile,fi.data(),&head_waveFile); if( fd_waveFile != nullptr) { while ( fread(&i, sizeof(int16_t),1, fd_waveFile) > 0){ x.push_back( i); } }
15/11/2016, 10h43
Matt_Houston

Citation:

Envoyé par Amnael

On est bien d'accord pour dire que 2013 < 4000 ?

Ben oui. Mais pas pour affirmer que 2013 * sizeof(uint16_t) < 4000 .

Citation:

Envoyé par Amnael

Mon tableau est donc suffisamment large pour contenir la donnée

Ben non, l'opérateur [] n'adresse pas en octets mais en blocs de taille sizeof(uint16_t). Lorsque cpt == 2013 tu as donc déjà bien dépassé la borne haute de ton bloc mémoire car tu adresses à partir de l'octet 4026.

Citation:

Envoyé par Amnael

et ici cela n'explique pas l'erreur de segmentation.

Ben si.

Une chose à prendre en compte lorsque l'on utilise realloc : on n'affecte jamais la valeur de retour de cet appel directement à la variable fournie en premier argument. Si l'opération foire, le bloc original est perdu (voir la page de man).

D'une manière générale, utilise plutôt un std::vector comme on te le conseille.
15/11/2016, 11h36
ternel

En fait, en C++, on n'utilise jamais malloc, realloc, calloc et free.

static_cast<T*>(malloc(sizeof(T))) se remplace avantageusement par new T(...), lui-même remplacé par make_unique<T>(...).
static_cast<T*>(malloc(N*sizeof(T))) se remplace avantageusement par std::array<T, N>(), ou std::vector<T> (si le nombre réel d'éléments n'est pas connu).

note: A la définition usuelle de jamais: "sauf si on a prouvé que c'est la meilleure solution".
15/11/2016, 11h42
Bousk

Puisque tu prétends être en C++, pourquoi char*, alloc, realloc et non string et vector ? :weird:
Si c'est juste pour avoir cout, c'est pas vraiment du C++. Utilise printf et fais du C ? :calim2: