How to allocate a struct and then increase its size? - c++

Question

I have a struct data
struct dataStruct{
int mID;
float mX;
};
a fillData method
void fillData(data *pt)
{
pt = new data(10);
}
and the main function
int main(int argc, char** argv)
{
dataStruct *myData;
fillData(myData);
myData[4].mID = 10;
std::cout << myData[4].mID << " " << myData[5].mID << std::endl;
}
and a couple of questions:
how can allocate myData inside the fillData method so that the allocation is not local to fillData?
Can the size of myData be increased by later calls to fillData and thus changing the size from i.e. 10 to 100 ?
Would it be better to manage the dataStruct pointer using std::unique_ptr ?

Answer 1

I am guessing at what you want, as it is not clear.
Here is a much better way to handle a collection of objects whose size needs to change dynamically:
struct dataStruct
{
dataStruct() : mID(0), mX(0.0f) {} // default to value 0
dataStruct(int mID, float mX) : mID(mID), mX(mX) {}
int mID;
float mX;
};
int main(int argc, char** argv)
{
std::vector<dataStruct> myData(10); // create 10 objects with values 0
myData[4].mID = 10;
std::cout << myData[4].mID << " " << myData[5].mID << std::endl;
// now resize to 100 objects, with 0 values for any new objects
myData.resize(100);
std::cout << myData[4].mID << " " << myData[99].mID << std::endl;
}
Live example:
http://ideone.com/5nyPOp
No memory leaks! No uninitialized data (which is used in your original code). And good debug compilers will bounds check for you.

Answer 2

For the first question, fillData() needs to accept either a reference
void fillData(data *&pt) // makes change of pt visible to the caller
{
pt = new data(10);
}
int main()
{
data *pointer;
fillData(pointer);
}
or a pointer to a pointer
void fillData(data **pt) // makes change of *pt visible to the caller
{
*pt = new data(10);
}
int main()
{
data *pointer;
fillData(&pointer); // pass the address of pointer
}
For the second question, somehow fillData() needs to be told how many objects to allocate, and be able to release.
void fillData(data *&pt, int size)
{
delete [] pt;
pt = new data[size];
}
int main()
{
data *pointer = NULL; // otherwise first call of fillData() will fail on the delete statement
fillData(10);
// use pointer like an array of 10 elements
fillData(20); // note previous contents of pointer are lost
// use pointer like an array of 10 elements
}
Answer to your third question: Short answer: No.
Longer answer to your third question: If you want a resizable set of your data, use a standard container (like std::vector<data>) instead. One advantage of this is that standard containers can be resized cleanly (e.g. if resizing from 10 to 20 elements, the first ten elements are retained).
Note: it is possible to resize things allocated directly with operator new (e.g. with additional book-keeping to keep track of current and new sizes) but I have not done it in the examples above - because using a standard container is a vastly better approach in practice.