How to use override (Polymorphism) in C++?

Apart from what @rnd commented, there is another C++ feature to take into account: hiding.

If you have a base class in which you declare several methods that may or may not be virtual:

class Base
{
public:
  void func()
  { std::cout << "Base::func()\n"; }

  void func(int)
  { std::cout << "Base::func(int)\n"; }
};

And later, by inheriting from it you override some of those methods:

class Derivada
{
public:
  void func()
  { std::cout << "Derivada::func()\n"; }
};

What effect does this have on the program? We see it with an example:

int main()
{
  Base b;
  b.func();  // Base::func()
  b.func(4); // Base::func(int)

  Derivada d;
  d.func();  // Derivada::func()
  d.func(4); // ERROR de compilación
}

The declaration of funcin the derived class will, by default, hide all overloads that may exist in its base class. There are mechanisms to import the functions that we need from the base class but by default they will be hidden.

Now, what happens if, like in the example, we haven't declared the base function as virtual?

int main()
{
  Derivada* d = new Derivada;
  Base* b = d; // Polimorfismo

  d->func(); // Derivada::func()
  b->func(); // Base::func()

  delete d;
}

As the function is not labeled as virtual, the compiler does not substitute one function for another, but depending on the context (in this case the type of pointer we are using) one function or another will be called.

However, if we declare the function as virtual, things change:

class Base
{
public:
  virtual void func()
  { std::cout << "Base::func()\n"; }
};

class Derivada
{
public:
  void func() override
  { std::cout << "Derivada::func()\n"; }
};

int main()
{
  Base b;
  Derivada d;

  Base* ptr = &b;
  ptr->func(); // Base::func()

  ptr = &d;
  ptr->func(); // Derivada::func()
}

Declaring the function of the parent class as virtualallows the compiler to drop the base function and replace it with the version provided by the derived class.

As an additional note, the modifier override(available as of the C++11 standard) forces the compiler to check that the function in question is going to override a function of the parent class (which must be virtual). If these conditions are not met, the compiler will display an error. That the compiler checks these things by itself is something that avoids many errors when programming:

class Base
{
public:
  void func()

  virtual void func2();

  virtual void func3(int);
};

class Derivada
{
public:
  // ERROR -> la función base no es virtual
  void func() override;

  // ERROR -> no existe fnuc2, debería ser func2
  void fnuc2() override; 

  // ERROR -> no existe un método virtual func3 sin parámetros
  // en la clase padre
  void func3() override;

  // OK
  void func3(int) override;
};

All the best.

No doubt eferion 's and rnd 's answers are valid; but both use dynamic memory for something that would not be necessary; also does not comply with the syntax that you express in your question:

s = l; // <---- Se supone que así anulo las funciones del objeto s
       //       y le asigno las funciones del objeto l

There is a way to get the syntax that you express in your question without the need to use inheritance (thus we write less) or pointers (thus we avoid using ->, which is more comfortable) or dynamic memory (thus the program is slightly faster) ¹ , it would be using pointers to functions; We will start by defining the types of the functions to use:

using lectura   = void(int &, int &, int &);
using operacion = void(int &, int &, int &);
using escritura = void(int &, int &, int &);

And then we define an object that uses these functions:

struct operador
{
    lectura *leer;
    operacion *calculo;
    escritura *escribir;
};

Having the appropriate functions, we can configure our operadoras we please:

void lee_suma(int &a, int &b, int &c) {
    std::cout << "\nSUMA\nIngresa numero a: ";
    std::cin >> a;
    std::cout << "\nIngresa numero b: ";
    std::cin >> b;
}

void suma(int &a, int &b, int &c) {
    c = a + b;
}

void muestra_suma(int &a, int &b, int &c) {
    std::cout << '\n' << a << " + " << b << " = " << c << '\n';
}

void lee_loop(int &a, int &b, int &c) {
    std::cout << "\nLOOP\nIngresa numero a: ";
    std::cin >> a;
    std::cout << "\nIngresa numero b: ";
    std::cin >> b;
}

void loop(int &a, int &b, int &c) {
    c = a * b;
}

void muestra_loop(int &a, int &b, int &c) {
    std::cout << '\n' << a << " * " << b << " = " << c << '\n';
}

We see it [in an example] :

int main()
{
    int a{}, b{}, c{};

    operador s{ lee_suma, suma, muestra_suma };
    operador l{ lee_loop, loop, muestra_loop };

    std::cout << "Voy a usar el operador s.\n";
    s.leer(a, b, c);
    s.calculo(a, b, c);
    s.escribir(a, b, c);

    // Anulación <---- 
    std::cout << "Ahora anulo s (suma) con l (loop).\n";
    s = l; // <---- Se supone que así anulo las funciones del objeto s
           //       y le asigno las funciones del objeto l
    s.leer(a, b, c);
    s.calculo(a, b, c);
    s.escribir(a, b, c);

    return{};
}

Since the signature of all operator functions is the same, a single type could have been used:

using opera = void(int &, int &, int &);

struct operador
{
    opera *leer;
    opera *calculo;
    opera *escribir;
};

Overriding or overriding could also be used like so:

s = { lee_loop, loop, muestra_loop }; // Así anulo las funciones del objeto s
                                      // y le asigno funciones de loop

¹ In general, any programming tool (such as inheritance and/or dynamic memory) should be used only when necessary, otherwise it could be considered overengineering . We can discuss whether inheritance and method overriding was the right tool in this case or not.

1- To be able to override a method, you must declare it as virtualin the parent class:

class suma{
    public:
        virtual void leer(int &a, int &b, int &c);
        virtual void calculo(int &a, int &b, int &c);
        virtual void escribir(int &a, int &b, int &c);
};

2- Declaring objects as objects, virtual methods do not work. You will need to use a pointer or a reference. Example:

suma *s = new suma();
loop *l = new loop();

// Anulación <----
cout << "Los punteros si permiten sobreescribir los metodos virtuales." << endl;

s = l; // Ahora si funciona por que es un puntero al objeto.

s->leer(a, b, c);
s->calculo(a, b, c);
s->escribir(a, b, c);

Don't forget to make deletethe objects created with new.

In assembler, of intel or of the processor that is, there is always an operation called "CALL".

That CALL is accompanied by a parameter, which can be a constant (a constant memory address written in "code stream" just after CALL), or "something variable" like. eg the value of a processor register.

In your example, since there are no virtual methods (and you do not want to work with virtual methods, as you say), the "s.read" line generates in assembler (and independent of the previous lines), a:

CALL "memory_cte_addr"

being the address you assign to the "sum.read" function.

However when virtual methods are used, something similar to this is generated:

CALL [EBX]

"go to the memory dir contained in the ebx register", which is a bit more inefficient, but very little else. But it allows dynamic "calls".

SUMMARY, without "virtual", it is impossible to make CALL beyond sum.read, since "read" is not "dynamic" (ie virtual).