Alternatives to abstract base class for storage - c++

Question

I'm wondering about the available alternatives to run-time polymorphism, specifically, an alternative to having a common base class between my classes in order to store and interact with instances of derived classes.
RTP has disadvantages of indirection through vtable look-up, and also forces the derived classes to be stored as pointers, and so generally they must be dynamically allocated. From what I've been told, this hinders inlining and compiler optimisations.
In short, I don't want this:
class Animal
{
public:
virtual void noise() const = 0;
};
class Dog : public Animal
{
public:
virtual void noise() override const {std::cout<<"Woof!\n";};
};
class Cat : public Animal
{
public:
virtual void noise() override const {std::cout<<"Meow!\n";};
};
//...
std::vector<Animal*> animals;
I want something like this:
class Dog
{
public:
void noise() const {std::cout<<"Woof!\n";};
};
class Cat
{
public:
void noise() const {std::cout<<"Meow!\n";};
};
//...
std::vector<*Things that have noise()*> animals;

Answer 1

In your example, I can not help you, but for classes with data members, here is an optimization.
Let's suppose we want to create a bullet-hell game.
In a naive approach, we need a class Bullet :
class Bullet {
public:
void draw(Renderer& r);
virtual void update_logic(float delta);
void run_physics();
protected:
float vx, vy; //velocity
private:
float x, y; //position
//...
};
So, the update_logic method would be called to set the velocity of the bullet, then run_physics will apply this velocity to the position.
Modifying logic needs polymorphism, so your collection becomes std::vector<Bullet*> (or std::vector<std::unique_ptr<Bullet> > in modern c++).
Then, in your main loop, first you update the logic, then the physics, then you draw your bullets.
Of course it is inefficient because of pointer dereference and vtables etc.
What you can do instead is :
class Bullet {
public:
void draw(Renderer& r);
void update_logic(float delta) { logic->update(delta); };
void run_physics();
void setVelocity(float, float);
void setLogic(BulletLogic*);
private:
float x, y, vx, vy;
BulletLogic* logic;
};
So now, you can use std::vector<Bullet>, and the indirection will occure only when updating logic, but neither while running phyics or drawing the bullet.