Remove item from C-array and shift

[seeplus]

If you really want to do this using pointers, consider:

#include <iostream>
#include <string>

class Monster {
public:
	Monster() {};
	Monster(const std::string& name) : name(name) {}

	std::string getName() const { return name; }

private:
	std::string name;
};

class Monsters {
public:
	auto begin() const noexcept { return monsters; }
	auto end() const noexcept { return monsters + total; }

	Monsters(size_t max) :max(max), monsters(new Monster*[max]) {}

	~Monsters()
	{
		for (auto& m : *this)
			delete m;

		delete[] monsters;
	}

	bool add(const Monster* m) noexcept
	{
		if (total < max) {
			monsters[total++] = const_cast<Monster*>(m);
			return true;
		}

		return false;
	}

	bool remove(const Monster* m) noexcept
	{
		for (auto& mptr : *this)
			if (mptr == m) {
				mptr = monsters[--total];
				delete m;
				return true;
			}

		return false;
	}

private:
	Monster** monsters {nullptr};
	size_t max {0};
	size_t total {0};
};

std::ostream& operator<<(std::ostream& os, const Monsters& mon)
{
	for (const auto& m : mon)
		os << m->getName() << std::endl;

	return os;
}

int main()
{
	constexpr size_t size = 5;

	try {
		Monsters monsters(size);

		const auto monster1 = new Monster("Sally");
		const auto monster2 = new Monster("Rich");

		std::cout << "Added " << (monsters.add(monster1) ? "OK" : "failed") << std::endl;
		std::cout << "Added " << (monsters.add(monster2) ? "OK" : "failed") << std::endl;
		std::cout << monsters << std::endl;

		std::cout << "Removed " << (monsters.remove(monster1) ? "OK" : "failed") << std::endl;
		std::cout << monsters << std::endl;

		std::cout << "Added " << (monsters.add(new Monster("Monster")) ? "OK" : "failed") << std::endl;
		std::cout << monsters << std::endl;
	}
	catch (...) {
		std::cout << "Error!\n";
	}
}

displaying:

Added OK
Added OK
Sally
Rich

Removed OK
Rich

Added OK
Rich
Monster

[dhayden]

Can't the index of a pointer be used?

It can, but why would you want to? The optimizer will almost certainly make equivalent code and the index notation is much clearer, at least to me.

[jlb]

I have a question about your remove function.

Why are you deleting "m", the parameter? The function doesn't own the memory for m, so it can be dangerous to delete that memory.

Do you know that you can pass a statically allocated monster pointer to this function? What happens when you try to delete a variable that has not been allocated with new?

Monster monster3{"Bad Boy"};
monsters.add(&monster3);
monsters.remove(&monster3);

The above should compile, but should also cause problems with your code.

[seeplus]

Yes - I know. The code was only an example of how it might be done - not best practice. main() used new to allocate the memory and you could do:

monsters.add(new Monster ("monster"));

In this case if you don't delete m you have a memory leak.

This is why previous posts have stated not to use pointers!

I don't like this code - it's way too flakey! Arrays of raw pointers are an accident waiting to happen IMO.

[jlb]

main() used new to allocate the memory

Which is, IMO, probably one of the poorest practices in the whole program.

I agree about the flakey, especially since it is possible to do the program without the pointers (raw or smart), even if you "must" use a dynamic array in the Monsters class.

[seeplus]

I agree that using new to allocate memory in main() is poor. That was how @alix did it in post #1 so I just followed through. For anyone reading these posts, this is not how you do it.