Assigning objects to objects

I get a fatal error when the following lines are run. foe is an array of objects (representing monsters in a game I'm making), nummonsters is the number of monsters in that array. When they are destroyed, I run this loop to remove the dead monsters (by swapping their position with the last one, and reducing the scope of the array).

Does the following look ok?

Code:

     for (int i=0; i<nummonsters; i++){
         if (foe[i]->hp<=0) {foe[i]=foe[nummonsters]; nummonsters--; return;}
     }

I have never used the 'foe[i]=foe[nummonsters]' thing before. Must I manually assign each variable :

Code:

foe[i]->a=foe[nummonsters->a;
foe[i]->b=foe[nummonsters->b;
foe[i]->c=foe[nummonsters->c;

etc.

You'd be better off using a vector rather than an array. Also make them dynamic, so killing them off is as easy as deleting the memory.

Your error would appear to be that you're assigning to foe[nummonsters] which being a total of the monsters is likely one higher that the last index in the array.

Array indices run from 0 to (nummonsters - 1), so accessing foe [nummonsters]
is out of bounds

EDIT: Too slow!!!

>>I have never used the 'foe[i]=foe[nummonsters]' thing before. Must I
manually assign each variable :

as far as I know, your compiler should automatically implement an assignment
operator overload for your class, which in most cases is suitable, so yes this
should be ok as opposed to assigning every variable

>>foe[i]->a=foe[nummonsters->a;

missing square brace, and it's probably meant to be the '.' operator instead of
the '->' operator. Also, variables in your class should be labelled private,
allowing access like this breaks the idea of encapsulation.

Bangs head: yes, the nummonsters was 1 larger than the last element. Thanks for that

Also, every time I use '.' in place of '->' things just stop working. I prefer '.', but it doesn't seem to work for me.

I prefer to use the primitive array: there will not need to be that many monsters in play at a time, so I wouldn't save space, and I also think an array is easier to use.

One more thing: is the way I'm doing it going to cause memory leaks, since I haven't properly deleted the data before overwriting it? I've done most of my OO programming in Java, so am not sure how much memory management C++ does on its own.

I prefer to use the primitive array: there will not need to be that many monsters in play at a time, so I wouldn't save space, and I also think an array is easier to use.

A std::vector is likely to be easier than a manually managed dynamic array.

For example, we can write a function object that tells us if the foe is dead:

Code:

// Foe class example
class Foe
{
public:
	int hitPoints() const;
	// ...
private:
	// ...
};

// function object class example
class FoeIsDead
{
public:
	bool operator()(const Foe& foe) const
	{
		return foe.hitPoints() <= 0;
	}
};

Now, we can do what you wanted to do, in a single line:

Code:

std::vector<Foe> foes; // vector of foes
// ...
// remove the foes that are dead
foes.erase(std::remove_if(foes.begin(), foes.end(), FoeIsDead()), foes.end());

Instead of having to keep track with a nummonsters variable, we just use foes.size() if necessary.

One more thing: is the way I'm doing it going to cause memory leaks, since I haven't properly deleted the data before overwriting it? I've done most of my OO programming in Java, so am not sure how much memory management C++ does on its own.

Overwriting does not cause memory leaks. What would cause a memory leak is if delete[] is not called for the dynamic array, but if you use a std::vector, then the delete[] is done for you automatically.