assume that we created dynamically allocated memory such as:
int SIZE = 10;
int *p = new int[SIZE];
for(int i = 0; i < SIZE; ++i)
p[i] = i;
it will assing 0 to 9 to our pointer array.
Then i wanted to add 10,11,12 to the array
can i do :
p[10] = 10;
p[11] = 11;
p[12] = 12;
or should i do:
delete[] p;
size = 13;
p = new int[SIZE];
for(int i = 0; i < SIZE; ++i)
p[i] = i;
You have to reallocate memory for the array of a greater size. Otherwise the program will have undefined behavior.
For example
int SIZE = 10;
int *p = new int[SIZE];
for(int i = 0; i < SIZE; ++i)
p[i] = i;
int *tmp = new int[SIZE + 3];
std::copy( p, p + SIZE, tmp );
delete []p;
p = tmp;
p[SIZE++] = 10;
p[SIZE++] = 11;
p[SIZE++] = 12;
Or instead of the last three statements you can write
for ( const int &value : { 10, 11, 12 } ) p[SIZE++] = value;
Of course in such cases it is better to use the standard container std::vector.
In fact the code above is similar to the following
#include <vector>
//...
std::vector<int> v( 10 );
for ( int i = 0; i < v.size(); i++ ) v[i] = i;
v.reserve( 13 );
for ( const int &value : { 10, 11, 12 } ) v.push_back( value );
except that all the memory management is done internally by the vector.
p[SIZE++]?
std::vector would move, if possible...The second option is the correct way. The first option won't always complain, but you are writing to memory that has not been set aside for your array; it has been set aside for something else, and you don't know what. Sometimes it will behave okay, sometimes it won't. Assigning to an array outside its range is Undefined Behavior, and we should avoid it.
In your first example suggestion:
p[10] = 10;
p[11] = 11;
p[12] = 12;
You will be overwriting memory that you don't own, which can lead to a crash. You need to reallocate your original array.
const int oldSize = SIZE;
SIZE = 13;
int *newP = new int[SIZE];
memcpy(newP, p, oldSize * sizeof(int));
for (int i = oldSize; i < SIZE; ++i)
{
newP[i] = i;
}
delete[] p;
p = newP;
Your second example would work, but is slightly less efficient, because you're re-calculating the values with each reallocation. In my example above, you only re-calculate the new values.
Alternatively, you should look at std::vector which is designed specifically for this purpose (a dynamically sizing array).
std::vector<int> p;
for (int i = 0; i < 10; ++i)
{
p.push_back(i);
}
Here the std::vector manages the allocation internally, so you don't have to worry about new and delete.
memcpy usually is invalid if complex objects are involved (like std::string). For consistency, I'd then avoid memcpy even for types where it actually is allowed in favour of the C++ means like std::copy.
C++, why don't you use avector<int>directly?vectoris not used.malloc(),calloc(),realloc(). But usage of those functions (from C) is discouraged in C++, for various reasons - in particular, it gives undefined behaviour is used to allocate memory for C++ class types that have a non-trivial constructor or destructor.