Bonjour.

A partir des valeurs d'un tableau initial d'entiers crée par une fonction generationTableau, je veux créer 2 tableaux comprenant respectivement les valeurs inférieures et supérieures à une valeur donnée. Pour cela, je veux utiliser une fonction récursive que j'appelle separation.
Or, bien qu'utilisant les realloc pour conserver en mémoire mes tableaux après la fin de l'appel à la fonction, je ne retrouve plus les valeurs ensuite. Pourtant, ces valeurs existent à chaque appel récursif puisque je peux faire afficher l'indice 0 de l'un d'eux ...
Voici mon petit code-source :
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <iostream>
#include <cstdlib>
 
int* generationTableau(int nbValeursAGenerer, int min, int max, int *tab,
		int tailleTab) {
 
	if (nbValeursAGenerer == 0) {
		return tab;
	} else {
		int tailleCourante = tailleTab - nbValeursAGenerer + 1;
		tab = (int*) realloc(tab, tailleCourante * sizeof(int));
		tab[tailleCourante - 1] = rand() % max + min;
 
		return generationTableau(nbValeursAGenerer - 1, min, max, tab,
				tailleTab);
	}
}
 
void separation(int nbValeursRestantATester, int p, int *T, int tailleT,
		int *Tinf, int *tailleTinf, int *Tsup, int *tailleTsup) {
 
	if (nbValeursRestantATester > 0) {
		int indice = tailleT - nbValeursRestantATester;
		std::cout << "nbValeursRestantATester : " << nbValeursRestantATester
				<< std::endl;
		std::cout << "T[" << indice << "] = " << T[indice] << std::endl;
		if (T[indice] > p) {
			*tailleTsup += 1;
			Tsup = (int*) realloc(Tsup, *tailleTsup * sizeof(int));
			Tsup[*tailleTsup - 1] = T[indice];
			std::cout << "Tsup[" << *tailleTsup - 1 << "] = "
					<< Tsup[*tailleTsup - 1] << std::endl;
			std::cout << "Tsup[0] = " << Tsup[0] << std::endl;
		} else if (T[indice] < p) {
			*tailleTinf += 1;
			Tinf = (int*) realloc(Tinf, *tailleTinf * sizeof(int));
			Tinf[*tailleTinf - 1] = T[indice];
			std::cout << "Tinf[" << *tailleTinf - 1 << "] = " << T[indice]
					<< std::endl;
		}
		nbValeursRestantATester -= 1;
		separation(nbValeursRestantATester, p, T, tailleT, Tinf, tailleTinf,
				Tsup, tailleTsup);
	}
}
 
void afficherTableau(int nbValeursAAfficher, int *tab, int tailleTab) {
	if (nbValeursAAfficher > 0) {
		std::cout << tab[tailleTab - nbValeursAAfficher] << std::endl;
		afficherTableau(nbValeursAAfficher - 1, tab, tailleTab);
	}
}
 
int main() {
 
	int *tab = NULL;
	int tailleTab = 20;
	int p = 30;
 
	int *Tinf = NULL;
	int *Tsup = NULL;
	int tailleTinf = 0, tailleTsup = 0;
 
	std::cout << " ---- " << std::endl;
	tab = generationTableau(tailleTab, 0, 100, tab, tailleTab);
	afficherTableau(tailleTab, tab, tailleTab);
	std::cout << " ---- " << std::endl;
	separation(tailleTab, p, tab, tailleTab, Tinf, &tailleTinf, Tsup,
			&tailleTsup);
 
	std::cout << "tailleTinf  = " << tailleTinf << std::endl;
	std::cout << "Tinf[0] = " << Tinf[0] << std::endl;
	// afficherTableau(tailleTinf, Tinf, tailleTinf);
	// std::cout << "Tsup " << *tailleTsup << std::endl;
	// afficherTableau(*tailleTsup, Tsup, *tailleTsup);
 
	return 0;
}
Je me plante ou ?