how to free malloc outside of function - c++

Question

Can't resolve this problem - my compiler allways tells me that I have some troubles with the free(pointer) function. So I'm not sure about the working of my pointers but debugging has shown that actually everything works well. Only the free function could't free the memory.
#include <stdio.h> //Bibliothek für input/output.
#include <stdlib.h> //For malloc
#include <math.h> //Bibliothek für matchematische Operationen.
#include <iostream> //Bibliothek für in/output in C++.
#include <stdbool.h> //Bibliothek für boolean
//Prototypes
int* readNumbers(int size);
int sumUpNumbers(int* sumpointer, int size);
//Main function
int main()
{
int arraySize; //Size of the malloc-array
int* pointer; //pointer for storing of the malloc-address
int total; //variable for the sumUpNumbers function
pointer = NULL; //point on zero
//inform the user before getting a number from him
std::cout << "Please give the size of array:" << std::endl;
fflush(stdout); //free the output window
//get a number for the size of array
scanf("%d", &arraySize);
//call the readNumbers function and store the first address of
//the malloc-array in pointer
pointer = readNumbers(arraySize);
//call the sumUpNumbers function and store the number in total
total = sumUpNumbers(pointer, arraySize);
fflush(stdout); //free the output window
//show the number from total
printf("\n total of the array:%d", total);
//call the free function for making the memory of
//the malloc-array free again
free(pointer);
fflush(stdin); //free the keyboard buffer
getchar(); //wait for a feedback from user
return 0; //return 0 to the machine in case if everything works well
}
//This function has a pointer extension because we want to work with the
//array outside of this function. We give the function a size of the array
//we want to build. The function builds an array and fills it with numbers
//and than gives us back the first address of the array.
int* readNumbers(int size)
{
int* array; //pointer for creating of malloc-array
int i; //counter
//pointer for storing of the first address of the array
int* helpPointer;
array = NULL; //set the pointers
helpPointer = NULL; // on zero
//create the array
array = (int *) malloc(size * sizeof(int));
//check the value of the array to be sure that we have created
//the array without errors
if(array != NULL)
{
//store the first address of the malloc-pointer
helpPointer = array;
//give some value to all the parts of array
for(i=0; i<=size; i++)
{
//inform the user
printf("\n give the %d. nummber of the array:\n", i+1);
fflush(stdout); //free the output window
//read the value
scanf("%d", array+i);
}
return helpPointer; //return the first address
}
//if something went wrong by creating of the array, do:
else
{
//tell the user, what we computer does't have enough memory
std::cout << "There is no place for saving the data in mamory";
return 0; //return with failure
}
}
//The input of this function is a pointer with the address of the malloc-array
//from the readNumbers and the size of this array. The function adds all the numbers
//from the array and gives us the result of the additation back.
int sumUpNumbers(int* sumpointer, int size)
{
int sum; //variable for storing of total value
int i; //counter
sum = 0; //set the sum on zero before work with it
//count all the values from the array
for(i=0; i<=size; i++)
{
//count one number after another
sum = sum + *(sumpointer+i);
}
return sum; //return the total value
}

Answer 1

The limits of your for loops are wrong. You are writing into one position over the end of your array, which might corrupt the memory so that later the program fails. Change the for loops to:
for(i=0; i<size; i++)

Answer 2

In the readNumbers function you have:
for(i=0; i<=size; i++)
but the array is only size elements long, so just change <= to <:
for(i=0; i < size; i++)
You have the same problem in the sumUpNumbers function. But this will most likely just result in an incorrect sum although it is technically undefined behaviour.

Answer 3

Your code has few issues:
fflush(stdin) is a generator of undefined behavior.
two incorrect counters: if size is size, you must count for(i = 0; i < size; i++)
Your int* readNumbers(int size) returns int instead of int* if array is NULL.
strange mixing of C and C++ for no obvious reason to using cin and cout
Apart from having written three obvious mistakes (1) and (2) and (3), you also push yourself to use a C++ compiler (4) for compiling something, 99% of which is plain C code. Why?
In case you replace cin and cout with appropriate scanf() and printf() calls, you get rid of C++. So you can use a C compiler. In that case make sure to also modify malloc call in order to conform the C standard:
array = malloc(size * sizeof(int)); //no result casting!
Then you get 100% C code which is easier to read, study and debug.