Fonction virtuelle avec différents types de retour

Question

J'écris une classe d'interface pour différents types de messages de protocole. Je ne peux pas réécrire le code de protocole de base afin de donner à chaque protocole une interface commune Je crée une classe de base avec une interface commune avec des classes wrapper pour chaque protocole spécifique.

Ainsi, chaque classe d'emballage aura une interface commune puis dans mon code pour gérer les messages de protocole que je peux utiliser le polymorphisme-à-dire

message* msg = new protocol_a_msg(a_msg); 

Ensuite, je peux utiliser les fonctions avec le message * paramètre à traiter etc, qui est génial. Cependant, j'ai finalement besoin d'obtenir le message de protocole sous-jacent. donc je voulais écrire une fonction virtuelle qui obtient le message sous-jacent. c'est-à-dire dans la classe de message de base:

<type> get_msg() = 0; 

Mais le problème peut varier. Est-ce que cela signifie que je ne peux pas avoir de fonction virtuelle parce que le type de retour varie?

Si je ne peux pas faire cela, je devrais utiliser le type de wrapper de protocole spécifique et utiliser une fonction spécifique. Ce qui fonctionnerait mais je me demande quel est le meilleur moyen.

Voici mon code à ce jour:

#include <iostream> 

class message { 
public: 
    enum msg_type { PROTOCOLTYPE, BINARYTYPE, UNKNOWNTYPE }; 
    message(msg_type type = PROTOCOLTYPE) : type_(type) {} 
    void set_type(msg_type type) { type_ = type; } 
    msg_type get_type() const { return type_; } 
    msg_type type_; 
    virtual ~message() {} 

// Can I make this a generic get underlying data virtual function? 
// virtual underlying_msg get_msg() const { return <underlying_msg>; } 

    //may also need a set_msg(msg) - or can initialise protocol msg in ctor 
}; 


//this is existing protocol code which I cannot change 
class protocol_a { 
public: 
    enum a_type { SMALL, MEDIUM, LARGE }; 
    protocol_a(a_type a) : atype_(a) { } 

    const char* get_data() { 
     static const char* const names[] = { "SMALL", "MEDIUM", "LARGE" }; 
     return names[atype_]; 
    } 

protected: 
    a_type atype_; 
}; 

class protocol_a_msg : public message { 
public: 
    protocol_a_msg(protocol_a * a) : proto_(a) {} 

    protocol_a* get_msg() const { return proto_; } 

    protocol_a* proto_; 
}; 


int main() { 
    protocol_a a_msg(protocol_a::SMALL); 
    protocol_a_msg* pa_msg = new protocol_a_msg(&a_msg); 

    //retrieve underlying protocol_a msg 
    protocol_a* a = pa_msg->get_msg(); 

    const char* s = a->get_data(); 

    std::cout << "protocol_a data=" << s << std::endl; 

    delete [] pa_msg; 

    return 0; 
} 

Answer 1

Vous pouvez le faire:

class A {}; 
class B : A {}; 
class C : A {}; 

class IFoo 
{ 
public: 
    virtual A * func() = 0; 
}; 

class BFoo 
{ 
public: 
    virtual B * func(); 
}; 

class CFoo 
{ 
public: 
    virtual C * func(); 
};