I have a problem in polymorphism with list STL

[rishardcarranza]

Please help me with a problem to solutions the polymorphism in this case...

I have iterator of class Cliente and the class ClienteJuridico and ClienteNatural inherit of super class Cliente the method MostrarTipo().

Class Cliente

virtual void MostrarTipo(){
  cout << "Tipo no definido";
}

Class ClienteJuridico

void MostrarTipo(){
  cout << "Persona Natural";
}

Class ClienteNatural

void MostrarTipo(){
  cout << "Persona Juridica";
}

... however, in the main function I implement class list and use the follow iterator

 if(!lstClientes.empty()){
     list<Cliente>::iterator ptroCliente;
     ptroCliente = lstClientes.begin();
     system("cls"); // EN WINDOWS
     cout << "------------------------------------------------------------------------------\n";
     cout << "ID\t";cout << "NOMBRE\t\t";cout << "TIPO CLIENTE\n";
     cout << "------------------------------------------------------------------------------\n";
     while(ptroCliente != lstClientes.end()){
             cout << ptroCliente->geIdCliente();cout<< "\t";
             ptroCliente->MostrarNombre();cout<< " ";ptroCliente->MostrarApellido();
             cout<< "\t";
             ptroCliente->MostrarTipoCliente();
             cout << endl;
             ptroCliente++;
      }
}else{
      cout << endl << "No hay Clientes!" << endl;
}

But de result is "Tipo no definido..."

Please help me ! ...

[fcantoro]

As far as I know, in your case lstClientes must contain pointers, because std::list stores a copy of the object.
In your case, lstClientes contains objects of type Cliente, even if you push_back ClienteJuridico or ClienteNatural.
Changing lstClientes to list<Cliente*> will solve your problem.
Obviously, be careful of memory leaks.
Maybe you would use manager pointers: see http://www.cplusplus.com/reference/memory/

[S G H]

You can also try to make it a virtual member.
Remember to make the destructor virtual, too, if you choose this path.

[rishardcarranza]

Yes EssGeEich, i already tried to make the virtual method of super class Clientes.

virtual void MostrarTipo(){
  cout << "Tipo no definido";
}

But the problem is how to say fcantoro, lstCliente store a copy of the object. Then i probed the following code...

    Cliente *cte2,*cte3;
    cte2 = new ClientePersonaJuridica(1,"Asociados","","123456789");
    Fecha fn(8,2,1988);
    cte3 = new ClientePersonaNatural(1,"Ricardo","Carranza","123456",fn);
    cte2->MostrarTipoCliente();
    cout << endl;
    cte3->MostrarTipoCliente();

And the answer is correct...

Persona Juridica
Persona Natural

But when i using a iterator of class list lstClientes, the answer is ...

Tipo no definido

:-/

[booradley60]

Here's an example to serve the point fcantoro made:

#include <iostream>
#include <list>

class Cliente
{
public:
    virtual void MostrarTipo()
    {
        std::cout << "Tipo no definido";
    }
};

class ClienteJuridico : public Cliente
{
public:
    virtual void MostrarTipo()
    {
        std::cout << "Persona Juridica";
    }
};

class ClienteNatural : public Cliente
{
public:
    virtual void MostrarTipo()
    {
        std::cout << "Persona Natural";
    }
};

int main(int argc, char* argv[])
{
    std::list<Cliente> cList;
    cList.emplace_back(ClienteJuridico());
    cList.emplace_back(ClienteNatural());

    std::cout << "Using list of objects\n";
    for(std::list<Cliente>::iterator it = cList.begin();
                                     it != cList.end();
                                     ++it)
    {
        (*it).MostrarTipo();
        std::cout << std::endl;
    }


    std::list<Cliente*> cPtrList;
    cPtrList.emplace_back(new ClienteJuridico());
    cPtrList.emplace_back(new ClienteNatural());
    std::cout << "\nUsing list of pointers to objects\n";
    for(std::list<Cliente*>::iterator it = cPtrList.begin();
                                     it != cPtrList.end();
                                     ++it)
    {
        (*it)->MostrarTipo();
        std::cout << std::endl;
    }
    return 0;
}

[S G H]

You must make the base's class a virtual method.
About copying, you should store pointers instead of objects (if you are allowed to).
This is kind of what you should have:

class BaseClient {
public:
    virtual void Display() =0;
    virtual ~BaseClient() {} // Important!
    // If you split header/source, put the (empty) body in the source file.
};

class JurClient : public BaseClient {
public:
    virtual void Display() { std::cout << "Jur. Client"; }
};

class NatClient : public BaseClient {
public:
    virtual void Display() { std::cout << "Nat. Client"; }
};

And the rest of the code should be like this:

std::list<std::unique_ptr<BaseClient>> clients;
clients.push_back(std::unique_ptr<BaseClient>(new JurClient()));
clients.push_back(std::unique_ptr<BaseClient>(new NatClient()));

unsigned int ClientID = 0;
for(auto const& it : clients)
{
    std::cout << "Client nr. " << ++ClientID << " is a ";
    it->Display();
    std::cout << std::endl;
}

Some of the code uses C++11 features (such as std::unique_ptr and range-for.

If you really want to follow a different approach, store all the infos in a single class as follows:

enum ClientType {
    CT_NATURAL = 0, // = 0 is important
    CT_JURIDICA,

    CT_AMOUNT // must be the last one, tells us how many types are there
};
class Client {
    ClientType m_ClientType;
public:
    Client(ClientType t = CT_NATURAL) // If no ClientType is provided, use CT_NATURAL.
        : m_ClientType(t) {}
    void Display() const { // Note: Marked as const, since it doesn't modify Client itself.
        // static: initialized once
        // const: does not change
        static const std::string TypeToName[CT_AMOUNT] = {
            "Persona Natural",
            "Persona Juridica"
        };
        if(m_ClientType < 0 || m_ClientType >= CT_AMOUNT)
            std::cout << "Tipo no definido";
        else
            std::cout << TypeToName[m_ClientType];
    }
};

And use as follows:

std::list<Client> clients;
clients.push_back(Client(CT_NATURAL));
clients.push_back(Client(CT_JURIDICA));
clients.push_back(Client(ClientType(42))); // client type of id 42? it does not exist, and will print Tipo no definido.

unsigned int ClientID = 0;
for(auto const& it : clients)
{
    std::cout << "Client nr. " << ++ClientID << " is a ";
    it.Display();
    std::cout << std::endl;
}

[rishardcarranza]

Heeeeey !!! yes ! this is a solution, thaks booradley60 and fcantoro ! and parnerts ! Here's an image with the result:

https://www.dropbox.com/s/rfln4q9w3p547du/cplusplus_cliente.png?dl=0

Thanks for your time ! :-)