Dynamic memory allocation - C++ - c++

Question

I'm in the process of teaching myself C++ and am currently learning about dynamically allocating memory. Here's the code that I'm currently working with:
#include <iostream>
using namespace std;
int *memAdd(int* dyn_Point, int *lenPoint){
int *new_Dyn_Point = new int[*lenPoint * 2];
*lenPoint = *lenPoint * 2;
for(int i = 0; i < *lenPoint; i++){
new_Dyn_Point[i] = dyn_Point[i];
}
delete lenPoint;
delete[] dyn_Point;
return new_Dyn_Point;
}
int main(){
int len = 2;
int *lenPoint = &len;
int current = 0;
int val;
int *dyn_Point = new int[len];
cout << "Input a value for point 1: ";
cin >> val;
dyn_Point[current] = val;
while(val > 0){
current++;
cout << "Input a value for point " << current+1 <<" (0 to exit): ";
cin >> val;
if(current+1 == len){
*dyn_Point = *memAdd(dyn_Point, lenPoint);
cout << len;
}
dyn_Point[current] = val;
}
for(int i = 0; i < len; i++){
cout << &dyn_Point[i] << "\n";
cout << dyn_Point[i] << "\n\n";
}
delete[] dyn_Point;
}
My Question: When adding more memory does it have to increment by a certain value?
Whenever I start with a value in my "len" variable that's not 2 my program will crash either as soon as I try and allocate more memory or after more memory has been allocated and even more has to be added a second time.
Is this how it's supposed to be or am I missing something entirely here?

Answer 1

Your while loop need a break
while() {
//do your steps
break;
}
In function memAdd following changes required :
// *lenPoint = *lenPoint * 2;
// above line need to be commented else it will trouble the loop condition by causing over flow:
for(int i = 0; i < (*lenPoint-1); i++){
// for loop is corrected to resolve the over flow
Below delete is unnecessary since you didn't allocate memory
using this variable
// delete lenPoint;
For your question: When adding more memory does it have to increment by a certain value?
There is no hard and hard fast rule on this regard. std::vector<> double its size( memory allocation) whenever it is needed more memory. It is slightly different than your approach. You are doubling memory before reaching the allocated upper limit.
**Edit**
Compiled full code as OPs request
#include <iostream>
using namespace std;
int *memAdd(int* dyn_Point, int *lenPoint){
int *new_Dyn_Point = new int[*lenPoint * 2];
// *lenPoint = *lenPoint * 2;
for(int i = 0; i < (*lenPoint-1); i++){
new_Dyn_Point[i] = dyn_Point[i];
}
//delete lenPoint;
delete[] dyn_Point;
return new_Dyn_Point;
}
int main(){
int len = 2;
int *lenPoint = &len;
int current = 0;
int val;
int *dyn_Point = new int[len];
cout << "Input a value for point 1: ";
cin >> val;
dyn_Point[current] = val;
while(val > 0){
current++;
cout << "Input a value for point " << current+1 <<" (0 to exit): ";
cin >> val;
if(current+1 == len){
*dyn_Point = *memAdd(dyn_Point, lenPoint);
cout << len<<"\n";
}
dyn_Point[current] = val;
break;
}
for(int i = 0; i < len; i++){
cout << dyn_Point[i] << "\n";
cout << &dyn_Point[i] << "\n\n";
}
delete[] dyn_Point;
}

Answer 2

"My Question: When adding more memory does it have to increment by a certain value?"
Of course you have to manage your memory allocations using a design like this.
In particular you should obey the Rule of Three (Five), and to copy all of the existing elements, when reallocating memory to increase to the necessary amount.
The much better choice than doing it all yourself (which is likely to be error prone), is to use a
std::vector<int> dyn_point;
and/or alike in your class.
Memory management is taken care of in the container implementations, and you don't need to bother about it.