Bonjour,
Je cherche a comprendre ou se trouve le problem.
Le proramme n'a pas de warning mais doit etre interrompu et ne renvoi pas les bonnes valeurs.
Voici le code:

1. include <stdio.h>
2. include <stdlib.h>
3. include <math.h>
4. include <string.h>
5. define MAX_SIZE 1500
6. define BINDATA "F:/231A4bindata.dat"
7. define EPSILON .01

void getArray (double **data, int *numValues);
void sortArray (double **data, int *numValues);
void printArray (double **data, double *average, int *numValues);
void hiLoEqual (double **data, double *average, int *numValues);
void stdDev (double **data, double *average, int *numValues);
void getMedian (double **data, int *numValues);
void getMode (double **data, int *numValues);

int main() {

double average;
int numValues=0;
double* data = malloc(MAX_SIZE * sizeof(double));
getArray(&data, &numValues);
sortArray(&data, &numValues);
printArray(&data, &average, &numValues);
hiLoEqual (&data, &average, &numValues);
stdDev (&data, &average, &numValues);
getMedian (&data, &numValues);
getMode (&data, &numValues);

return 0;

}

/*Function getArray dynamically declares an array of 1500 doubles
and fills by reading from a binary file. Array is resized to
numValues.
*/
void getArray (double **data, int *numValues) {

FILE * readfile;

int ndx = 0, rowCount = 0;
int dblsize = sizeof(double);

*data = (double *)malloc(MAX_SIZE * dblsize);

readfile = fopen (BINDATA, "rb");
*numValues = fread (*data, dblsize, MAX_SIZE, readfile);
fclose(readfile);

printf ("");

*data = (double *) realloc (*data, *numValues);

}

/* function sortArray sorts double *data in descending order*/
void sortArray (double **data, int *numValues) {

int ndx, ndx2, max;
double hold, sum = 0;

for (ndx = 0; ndx <= *numValues - 2; ndx++) {
max = ndx;
for (ndx2 = ndx + 1; ndx2 <= *numValues - 1; ndx2++)
if ((*data)[ndx2] > (*data)[max])
max = ndx2;
hold = (*data)[max];
(*data)[max] = (*data)[ndx];
(*data)[ndx] = hold;
}

}

/*prints array in descending order and prints out highest, lowest, and average value
The sum of the data set is calculated in during the sort, and used to caluclate the average
afterwards.*/

void printArray (double **data, double *average, int *numValues) {

int ndx, rowCount = 0;
double sum = 0;

printf ("Number of values is %d.\n", *numValues);

printf ("\nSorted array\n\n");
for (ndx = 0; ndx < *numValues; ndx++){
printf("[%d]\t%6.2f\t", ndx, *(*data + ndx));
rowCount++;
if (++rowCount == 5){
printf ("\n");
rowCount = 0;
}
sum += (*data)[ndx];
}

*average = sum / *numValues;

printf ("\nHigh is %13.2f\n", (*data)[0]);
printf ("Low is %14.2f\n", (*data)[*numValues - 1]);
printf ("Average is %10.2f\n", *average);

}

//Displays how many values are above, below, and equal to the average

void hiLoEqual (double **data, double *average, int *numValues) {

int ndx, above = 0, below = 0, equal = 0;

for (ndx = 0; ndx < *numValues; ndx++) {
if ((*data)[ndx] > *average + EPSILON)
above++;
else if ((*data)[ndx] < *average - EPSILON)
below++;
else
equal++;
}

printf ("\n= average: %6d\n", equal);
printf ("\n> average: %6d\n", above);
printf ("\n< average: %6d\n", below);

}

/* Finds the standard deviation of the data set.*/
void stdDev (double **data, double *average, int *numValues) {

int ndx, sizeData = *numValues;
double sumSqrs = 0, variance, stdev;
double mean = *average;

for (ndx = 0; ndx < sizeData; ndx++)
sumSqrs += (*data)[ndx] * (*data)[ndx];

variance = (sumSqrs / sizeData - 1) - (mean * mean);

stdev = variance * variance;

printf ("\nStandard Deviation: %.2f\n", stdev);

}

//Calculates and displays the median of the data set

void getMedian (double **data, int *numValues) {

double median;

if (*numValues % 2 == 0)
median = (*data)[*numValues /2 - 1];
else
median = (*data)[*numValues / 2];

printf ("\nMedian :\t%.2f\n", median);

}

/* Finds and prints the mode of the data set. This algorithm
has been optimized for a sorted list*/

void getMode (double **arr, int *numValues) {

double mode;
int numData = *numValues;
int count = 1, modeCount = 0, ndx;

for (ndx = 1; ndx < numData; ndx++) {
if ((*arr)[ndx] == (*arr)[ndx - 1])
count++;
else {
if (count > modeCount){
mode = (*arr)[ndx - 1];
modeCount = count;
}
count = 1;
}

}

printf ("\nThe number %.2f occurs %d time(s)\n", mode, modeCount);

}

Merci de votre aide.

met ca dans valgrind ca devrait te dire ce qui ne va pas.

tu perds de la memoire alloue dynamiquement. qui est alloue dans main et dans getarray

Valgrind, c'est pas sous Linux?
En tout cas je ne lai pas.
Pour ce qui est de liberer la memoire allouee, je dois mal m'y prendre.
J'ai place free(data); et ca ne marche toujour pas.
Le programme s'arrete toujours.

"Valgrind, c'est pas sous Linux?"
Ou *-BSD.

Si tu utilise un autre OS, cherches un outil equivalent.

Voila je ne pense plus avoir de problem de memoire alloue.
Cela dit il j'ai un autre problem. Le programme devrait creer a fichier contenant plusieurs doubles (pas plus de 1500) et ensuite les trier et les comparer.

Quelqu'un pourrait m'aider?

mon code:

//Defined Values

1. define _CRT_SECURE_NO_DEPRECATE
2. define INPUTFILE "F:\\Data.dat"
3. define OUTPUTFILE "F:\\Report.txt"
4. define READ "rb"
5. define WRITE "w"
6. define ARR_SIZE 1500
7. define ROWSIZE 5
8. define EPSILON .01

//Included Libraries

1. include <stdio.h>
2. include <stdlib.h>
3. include <math.h>

//Function Prototypes
FILE * get_file(char myFile[], char myOption[]);
double * get_memory(int dataSize);
int get_data(FILE * myFile, double * myData, int dataSize);
void check_memory(double * myData, int dataSize, int numElem);
void selectionSort(double array[], int numElem);
void write_info(double * myData, int dataSize, int numElem);
void write_values(double * myData, FILE * output_file, int numElem);
void write_hi_lo(double * myData, FILE * output_file, int numElem);
double write_average(double * myData, FILE * output_file, int numElem);
void write_abo_bel_equ(double * myData, FILE * output_file, int numElem, double Average);
void write_deviation(double * myData, double Average, FILE * output_file, int numElem, int dataSize);
void write_median(double * myData, FILE * output_file, int numElem);
void write_mode(double * myData, FILE * output_file, int numElem);
void close_file(FILE * myFile);
void close_memory(double * myData);

//Main Function
int main(void)
{

FILE * input_file = get_file(INPUTFILE, READ);
FILE * output_file = get_file(OUTPUTFILE, WRITE);

int dubSize = sizeof(double);
double * data = get_memory(dubSize), average;
int numElem = get_data(input_file, data, dubSize);
check_memory(data, dubSize, numElem);
selectionSort(data, numElem);
write_values(data, output_file, numElem);
write_hi_lo(data, output_file, numElem);
average = write_average(data, output_file, numElem);
write_abo_bel_equ(data, output_file, numElem, average);
write_deviation(data, average, output_file, numElem, dubSize);
write_median(data, output_file, numElem);
write_mode(data, output_file, numElem);
close_file(output_file);
close_memory(data);

return 0;
}

//Takes in char parameters for File Location and File Options, returns pointer to file
FILE * get_file(char myFile[], char myOption[])
{
FILE * filepointer = fopen(myFile, myOption);

if(filepointer)
return filepointer;

printf("The file %s was not able to be accessed in %s mode\n\n",
myFile, myOption);
exit(1);
}

//Returns pointer to location of dynamically alloted memory
double * get_memory(int dataSize)
{
return malloc(ARR_SIZE * dataSize);
}

/* Places the data from a binary file into a memory location, returns number of
items read. */
int get_data(FILE * myFile, double * myData, int dataSize)
{
int numRead;

numRead = fread(myData, dataSize, ARR_SIZE, myFile);

fclose(myFile);

return numRead;
}

//Reallocates the memory down to the needed amount of space
void check_memory(double * myData, int dataSize, int numElem)
{
realloc(myData, dataSize * numElem);
}

//Sorts the values of an array in DESCENDING order
void selectionSort(double array[], int numElem)
{
int fill, i, lastIndex = numElem - 1;
int minIndex;
double temp;

for (fill = 0 ; fill < lastIndex; fill++)
{
minIndex = fill;

for(i = fill + 1; i <= lastIndex; i++)
{
if (array[i] > array[minIndex])
minIndex = i;
}

if (minIndex != fill)
{
temp = array [fill];
array[fill] = array[minIndex];
array[minIndex] = temp;
}
}
}

//Prints out values
void write_values(double * myData, FILE * output_file, int numElem)
{
int Counter, rowCount = 0;

fprintf(output_file, "Number of values input: %i\n\n", numElem);

printf("Number of values input: %i\n\n", numElem);

for(Counter = 0; Counter < numElem; Counter++)
{
fprintf(output_file, "[%2i]%11.2lf ", Counter, myData[Counter]);
printf("[%2i]%11.2lf ", Counter, myData[Counter]);

if (++rowCount == ROWSIZE)
{
fprintf(output_file, "\n");
printf("\n");
rowCount = 0;
}
}

fprintf(output_file, "\n\n");
printf("\n\n");
}

//Determines and prints out the highest and lowest values.
void write_hi_lo(double * myData, FILE * output_file, int numElem)
{
double High, Low;
int Counter;

High=Low=myData[0];

for(Counter = 0; Counter < numElem; Counter++)
{
if(myData[Counter] > High)
High = myData[Counter];
else if(myData[Counter] < Low)
Low = myData[Counter];
}

fprintf(output_file, "High:\t\t\t\t%6.2lf\n\n", High);
fprintf(output_file, "Low:\t\t\t\t%6.2lf\n\n", Low);
printf("High:\t\t\t\t%6.2lf\n\n", High);
printf("Low:\t\t\t\t%6.2lf\n\n", Low);
}

//Determines, prints and returns average.
double write_average(double * myData, FILE * output_file, int numElem)
{
double Average = 0;
int Counter;

for(Counter = 0; Counter < numElem; Counter++)
Average += myData[Counter];

Average = Average / numElem;

fprintf(output_file, "Average of the Data Set:\t %5.2lf\n\n", Average);
printf("Average of the Data Set:\t %5.2lf\n\n", Average);

return Average;
}

//Determines and prints out the values Above, Less or Equal to Average
void write_abo_bel_equ
(double * myData, FILE * output_file, int numElem, double Average)
{
int Counter,
GreaterThan = 0, LessThan = 0, EqualTo = 0;

for(Counter = 0; Counter < numElem; Counter++)
{
if(myData[Counter] > Average)
GreaterThan++;
else if(myData[Counter] < Average)
LessThan++;
else if(fabs(myData[Counter] - Average) == EPSILON)
EqualTo++;
}

fprintf(output_file, "Above Average:\t\t\t%6i\n", GreaterThan);
fprintf(output_file, "Equal to Average:\t\t%6i\n", EqualTo);
fprintf(output_file, "Below Average:\t\t\t%6i\n\n", LessThan);
printf("Above Average:\t\t\t%6i\n", GreaterThan);
printf("Equal to Average:\t\t%6i\n", EqualTo);
printf("Below Average:\t\t\t%6i\n\n", LessThan);
}

//Determines the standard deviation of a set of data
void write_deviation
(double * myData, double Average, FILE * output_file, int numElem, int dataSize)
{
double * devArr = malloc(numElem * dataSize), Deviance = 0;
int Counter;

for(Counter = 0; Counter < numElem; Counter++)
{
devArr[Counter] = myData[Counter] - Average;
devArr[Counter] *= devArr[Counter];
Deviance += devArr[Counter];
}

Deviance /= numElem-1;

fprintf(output_file, "Standard Deviation:\t\t%6.2lf\n\n", Deviance);
printf("Standard Deviation:\t\t%6.2lf\n\n", Deviance);

free(devArr);
}

//Determines and prints out the median value of a set of data
void write_median(double * myData, FILE * output_file, int numElem)
{
double Median = myData[numElem / 2];

fprintf(output_file, "Median:\t\t\t\t%6.2lf\n\n", Median);
printf("Median:\t\t\t\t%6.2lf\n\n", Median);
}

//Determines and prints out the mode of a set of data
void write_mode(double * myData, FILE * output_file, int numElem)
{
int i, j, maxRepeats = 0;
double Mode = 0;

for(i = 0; i < numElem; i++)
{
j = 1;

while(myData[i] == myData[i+j])
++j;

if(j > maxRepeats)
{
Mode = myData[i];
maxRepeats = j;
}
}

fprintf(output_file, "Mode:\t\t\t\t%6.2lf\n\n", Mode);
fprintf(output_file, "Times Mode occurs:\t\t%6i\n\n", maxRepeats);
printf("Mode:\t\t\t\t%6.2lf\n\n", Mode);
printf("Times Mode occurs:\t\t%6i\n\n", maxRepeats);

}

//Closes a file
void close_file(FILE * myFile)
{
fclose(myFile);
}

//Frees up memory
void close_memory(double * myData)
{
free(myData);
}

Et tu as fait tourner un logiciel de verification de la memoire?

Aussi met ton code sur un wall comme http://pastebin.com/

Je sais pas si ca a un impact mais a un moment tu fais un realloc sans recuperer sa valeur de retour, donc dans le cas ou ta memoire est encombree et ou realloc ne peut pas fusionner le segment que tu lui donnes avec le prochain segment, il te renvoie une autre adresse que celui que tu lui passe en parametre. A mon avis tu dois segfault sur ca.