Discussion :

[Amnael]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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

[Amnael]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

a la ligne 15, si tu remplacer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et a quoi te sert:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bytesRead

[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().

[Amnael]

a la ligne 15, si tu remplacer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et a quoi te sert:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[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

[Amnael]

Je simplifie le code pour montrer l'erreur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int16_t * x=(int16_t*)malloc(buffsize);
	  if (x==NULL) exit (1);

Ici, la taille du tableau buffsize est 4 000

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Invité]

Essaye sa:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
}

[Amnael]

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

[Invité]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
    }
}

[Matt_Houston]

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

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

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.

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.

[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".

[Bousk]

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