C++ Sobrecarga de una función basada en shared_ptr Clase derivada

Question

Hay muchas preguntas SO que son similares a esto, pero no pude encontrar exactamente lo que estaba buscando. Lo siento si esto es un duplicado.

tengo una clase Parent y dos clases derivadas que heredan de ella:

class Son : public Parent { ... }; 
class Daughter : public Parent { ... }; 

entonces declarar dos shared_ptr a la clase base, y crear instancias de ellos con una shared_ptr a cada una de las clases derivadas:

shared_ptr<Parent> son = shared_ptr<Son>(new Son()); 
shared_ptr<Parent> daughter = shared_ptr<Daughter>(new Daughter()); 

Por último, me gustaría tener una clase que procese shared_ptr<Parent> en función de a cuál de las clases derivadas apunte. Puede funcionar utilizo sobrecarga para lograr este efecto es la pregunta: ¿

class Director { 
public: 
    void process(shared_ptr<Son> son); 
    void process(shared_ptr<Daughter> daughter); 
    ... 
}; 

así que me gustaría ser capaz de escribir el siguiente código:

shared_ptr<Parent> son = shared_ptr<Son>(new Son()); 
shared_ptr<Parent> daughter = shared_ptr<Daughter>(new Daughter()); 
Director director; 
director.process(son); 
director.process(daughter); 

En este momento estoy teniendo que hacer (que me gustaría evitar):

director.process_son(boost::shared_polymorphic_downcast<Son>(son)); 
director.process_daughter(boost::shared_polymorphic_downcast<Daughter>(daughter)); 

Answer 1

no es posible sobrecargar así, se necesitaría una sentencia switch para lograr algo similar con el envío en un método de Director.

tal vez debería mover el método process() a la clase Parent (y anularlo en Son y Daughter), de esa manera se puede utilizar de resolución normal función virtual para llamar la correcta.

Answer 2

No estoy seguro de si hay alguna manera mejor, así que suelo utilizar el patrón de visitante http://en.wikipedia.org/wiki/Visitor_pattern o trucos de envío dobles similares sobre dicha necesidad.

Es probable que sus objetos no conozcan el shared_ptr para ellos mismos, pero generalmente la referencia simple funciona bastante bien.

Answer 3

Idealmente, el Parent proporcionaría una interfaz suficiente para Director rica para procesar cada niño correctamente, sin la necesidad de saber qué niño es.

class Director { 
public: 
    void process(shared_ptr<Parent> obj); 
}; 

Si esto por alguna razón no se puede lograr, hay muchas opciones de diseño. Como se señaló anteriormente, puede hacer que el proceso se vincule con la clase secundaria. Si eso no se adapta a sus necesidades, puede, por ejemplo, aislar el proceso del director:

class ProcessSon: public Process, private Son { 
public: 
    void SpecificProc1(shared_ptr<Parent> obj) { 
    // Make this part of the process based on class Son 
    } 

    void SpecificProc2(shared_ptr<Parent> obj) { 
    // Make this part of the process based on class Son 
    } 
    ... 
}; 

Haz una similar para Daughter y enviar el apropiado Process junto con el puntero a la clase con el método process de Director.