Container Object of Templated Class

Question

Below is the (very) stripped down code of a implementation.

The library code is as follows:

#pragma once
#include <iostream>
#include <map>
#include <string>

// Necessary as interface and due to QObject Macro.
class Base
{
  public:
    Base( const std::string& name ) : name_( name )
    {
    }

    virtual ~Base(){}

    const std::string& name()
    {
        return name_;
    }

  private:
    std::string name_;
};

template < typename Derived, typename ObjectType >
class TemplatedBase : public Base
{
  public:
    TemplatedBase( const std::string& name ) : Base( name )
    {
    }

    ObjectType object()
    {
        return object_;
    }

    ObjectType object_;
};

class DerivedA : public TemplatedBase< DerivedA, int >
{
  public:
    DerivedA( const std::string& name ) : TemplatedBase< DerivedA, int >( name )
    {
    }
};

class DerivedB : public TemplatedBase< DerivedB, float >
{
  public:
    DerivedB( const std::string& name ) : TemplatedBase< DerivedB, float >( name )
    {
    }
};

class Container
{
  public:
    template < typename T >
    void addToMap( T& map_object )
    {
        const std::string name = map_object.name();
        // ASSERT( map_.find( name ) == map_.end() );
        map_.emplace( std::make_pair( name, &map_object ) );
    }

    template < typename T >
    auto getObject( std::string name ) -> decltype( ( ( T* )nullptr )->object() )
    {
        auto search = map_.find( name );
        // How can this dynamic_cast be avoided? 
        T* ptr      = dynamic_cast< T* >( search->second );
        // ASSERT( ptr == nullptr );
        return ptr->object();
    }

    std::map< std::string, Base* > map_;
};

With an example usage of:

int main( int argc, char* argv[] )
{
    Container container;

    DerivedA a( "Name_A" );
    DerivedB b( "Name_B" );

    container.addToMap( a );
    container.addToMap( b );

    // How can I avoid to specify the type in the map as template?
    auto object_a = container.getObject< DerivedA >( "Name_A" );
    auto object_b = container.getObject< DerivedB >( "Name_B" );
}

Some explanation for the code:

• The Base Class is necessary because the Q_OBJECT Macro requires a non-template class as well as for the interface.
• The templated Base class has some sort of lazy copy implemented, as the objects stored are relativly large in the real application.
• The Container is made available for an arbitrary number of threads and the lazy copy of the TemplatedBase Class is handling the thread safety.
• The Container is used in a context that doesn't know (nor need to know) the Derived Classes themself.

While the code itself is working fine, I am looking for a different design that makes the dynamic_cast and the type specification during readout unnecessary.

I have tried several types of type erasure (boost::type_erasure, boost::variant) and different container types. However I always ran into the problem of different return types of the object() function.

Answer 1

You cannot avoid putting the type name here if you want to return a specific type other than Base:

    auto object_a = container.getObject< DerivedA >( "Name_A" );

There's no way for the compiler to know what to return at compilation time since the value won't be known until runtime.

As for your reinterpret cast, you're right to not like it. That needs to be a dynamic_cast or you must build some other way to tell what type your objects are at runtime into your system. Also, you probably meant static_cast not reinterpret cast. However, static_cast is also not correct if you don't absolutely know that every lookup will specify the correct corresponding type as a template parameter that matches the actual runtime type of the stored object.

Right now, if you make a bad call, your system will result in undefined behavior. Your code is "working fine" because you're not calling getObject with an incompatible templated type, but as soon as you do, your program is likely to not be working fine.

Answer 2

Let’s consider what exactly you’re doing here:

• You are casting
  • a pointer of a base class to a pointer of its derived child class,
  • in a non-virtual inheritance chain,
  • without casting away const-ness.
• You are not checking the result’s correctness.

Consequently, the correct cast to use here is static_cast.

However, this will break (= result in undefined behaviour) in cases where the user accidentally calls container.getObject with a mismatching type. Consequently, you should be checking the cast result’s correctness, as explained in xaxxon’s answer.

And no, there’s no way of avoiding to specify the target type in the cast. You must specify a static type to an object in order to work with it, since the result of ptr->object() isn’t type-erased. Even boost::variant requires users to specify static types whenever they actually want to access the stored object (e.g. in the signature of a visitor).