Thread: Overwriting Array with New Array

yes
you make knowledgeBase pointer to record

Code:

record* knowledgeBase ;

and initialize it using new

also - do not forget to delete it afterwards

Have you considered just using a std::vector<record> as a member variable instead? Also, why not just use the constructor?

I have, but it messed things up in ways I'm not really prepared to fix.

If that is the case, then you will find that with vart's suggestion, you may mess things up in even more ways that you are probably also not prepared to fix.

And I can't use it in the constructor because in record, there's a string entry that needs to have a variable put in at run time.

Well, firstly you say you want an array of "undefined" length. Of course, an array must have a length, just that its length may be unknown at compile time (e.g., it is a dynamically allocated array, as per vart's suggestion). But then you want to initialise this array with an initialiser list, which implies that you know its length at compile time.

I suggest that you use a std::vector<record>, and then have record provide a default value for strings that are not specified. Later, when these values are known, you can assign them.

It's not impossible.
std::vector will grow and shrink dynamically. You don't have to worry about a thing.

What I meant by "not prepared to fix" was that I would have to entirely rewrite the code, which is not something I really want to do... Not that I couldn't fix the problems.

Ah, that's fair enough.

Not 100&#37; sure what you mean, but if I'm taking it right, I technically DO know the length at runtime. The thing is, the length is going to change so often as I'm developing that I don't want to have to go through all my code and change the length every time I change the array around.

It's my turn to be unsure of what you mean

As I noted, you definitely know the array length at runtime. The question then is: do you know the array length at compile time? If you do and this value is prone to changes during development, the solution is to define a static constant (or an enum) that holds the fixed array length, and then use this throughout the relevant code. When you decide that the length needs to be changed, just change the value of that static const size_t member variable (or enum).

If you do not know the array length at compile time, then you should use a std::vector. Of course, you could still use a std::vector even if you know the array length at compile time, though arguably something like std::tr1::array would be more appropriate than std::vector.

Use push_back() to add a string and erase() to delete something and the std::vector will automatically manage size for you.
Vart means that you create an array on the heap:

Code:

record* p = new record[n];

The only problem is that you must remember the size yourself and delete, reallocate and copy if it gets too big:

Code:

int size = 100;
int curelement = 0;
record* p = new record[size];
//...

if (curelement + 1 > size) // Not enough room, reallocate
{
	record* p2 = new record[size * 2];
	memcpy(p, p2, size);
	size *= 2;
	delete [] p;
	p = p2;
}

Of course, you should really use std::copy, but that's another matter.

As for the size issue, that's really unimportant at this point. I just need to know how I could have it redefine the array. 'vart' gave an answer, though I really don't understand it fully.

The size issue matters as it is at the heart of the problem. vart's solution describes a dynamically allocated array, which is the raw version of std::vector as provided by the core language. std::vector is its standard library equivalent. If the size of the array is unknown at compile time, you should use a dynamically allocated array, which means that you should use std::vector unless you have a good reason to use its core language version.

Fairly sure. I actually tried it at one point, but even when I went through and changed everything, it just caused too many problems due to how my program is currently structured.

Since std::vector is the standard library version of a dynamically allocated array, if std::vector is causing problem due to how your program is structured, a dynamically allocated array will cause the same problems, and worse.

What I need to know is how to in essence "reinitialize" the array in that separate function. To redefine it entirely.

You will have to (manually) assign the array elements to the member array in that function. The initialiser list cannot be used.