c ++动态返回类型

Question

I'm not sure if this is a thing (to be honest I want to say that it is not), but I was wondering if there is a way to write a c++ function so that it can choose which type of object to return.

For example, I have a base class ( A ) that has 3 child classes ( Aa , Ab , Ac ). In a factory( F ) class I have a std::map<UINT, A*> that holds a number of the child classes based on a UINT id . My goal is to write a function that can build and return the correct object when I pass in an id value.

I'll probably end up returning pointers and cloning the data that they point to, but I was just curious as to whether or not the aforementioned was actually possible.

Thanks!

Answer 1

C++ being statically typed, the return type of a function must be known at compile time. From here arises the question:

1. do I know the expected return type statically on each call site of F (== it only depends on constant expression values)
2. or does it depend on some runtime variable.

For case #1, a function template for F would be a good approach.
But in your case, it seems you are facing #2 (because you want to return a type depending on ID that we can assume is not a constant expression).

Because of the static typing, if you are to write a function (assuming you do not overload it, because it seems your input parameters are always the same), it will have a single and well-defined return type. Basically, you do not have a syntax to say that your factory F will return either an Aa Ab or Ac (and that is a very good thing, with regard to static typing and all the compiler verifications it enables ; )

C++ solution: Type erasure

With that being said, you have a few approaches to type erasure , that will allow you to return an instance of a variant type hidden behind a common single type.

• The obvious one is the pointer-to-derived to pointer-to-base conversion. It is particularly usefull if you plan to use the returned object mainly through its A interface (ie, you will call the virtual functions defined on A ).

   A* F(ID aId) 

  This A* could point to any type deriving from A . From here, you could call every function defined on A public interface on the returned pointer. Of course, if you wanted to call an operation that is only available on a subclass, you would need to know what is the exact type on call site,and then cast the pointer to a pointer-to-derived before being able to call the operation.

• A possible alternative, if you'd rather avoid dynamic memory, could be boost::variant . At the cost of having to explicitly list all the possible types the function could return.

   boost::variant<Aa, Ab, Ac> F(ID aId); 

  You can take a look at the tutorial for a quick introduction to the syntax and features.

Answer 2

Sure, something like this:

class MyMapClass
{
public:
    template< class ExactType > ExactType * getValue(UINT key)
    {
        return dynamic_cast<ExactType*>(_myMap.at(key));
    }

    BaseType * at(UINT key)
    {
        return _myMap.at(key);
    }

private:
    std::map<UINT, BaseType*> _myMap;
}

However, since you are storing the pointers to base types, you can as well return them as is, and rely on the caller to make a specific cast, if that goes well with your application's architecture.

Unfortunately, you can not do it fully automatically. Sooner or later you will have to determine the exact class that hides behind the base class pointer, and make a cast. With the template solution it is done "sooner":

MyDerivedType * value = myMapClassInstance.getValue<MyDerivedType>(1);

If you prefer to return the base pointer, it is done "later":

BaseType * value = myMapClassInstance.at(1);
MyDerivedType * exactValue = dynamic_cast<MyDerivedType*>(value);