具有模板基类的C ++ std :: shared_pointer

Question

I am trying to pass a derived class as a std::shared_pointer to a function whose parameter is the base class, which has a template.

Here is a full example:

template <class T>
class Base {
 public:
  std::string typeName()
  {
    int status;
    char *realName = abi::__cxa_demangle(typeid(T).name(), 0, 0, &status);
    std::string ret(realName);

    free(realName);

    return ret;
  }
};

class Derived : public Base<float> {};

The function I would like to call is the 'doSomething' with the shared pointer.

template <class V>
void doSomethingNotShared(Base<V> *test)
{
  std::cout << "Not shared type: " << test->typeName() << std::endl;
};

template <class V>
void doSomething(std::shared_ptr<Base<V>> test)
{
  std::cout << "Shared type: " << test->typeName() << std::endl;
};

And here is the main function to show how I'd like to use it and pointing out the compilation error.

int main()
{

  std::shared_ptr<Derived> testval1 = std::shared_ptr<Derived> (new Derived());
  doSomething(testval1); // <- Compilation error

  Derived *testval2 = new Derived();
  doSomethingNotShared(testval2);

  std::shared_ptr<Base<float>> testCast = std::dynamic_pointer_cast<Base<float>>(testval1); // Would rather not have to do this if there is another way ...
  doSomething(testCast); // <- No error runs fine
}

Is there any way to make this work with doSomething(testval1); ? I am hoping to not have to use dynamic_pointer_cast (or any other type of casting mechanism) and just use Derived.

The main error is: std::shared_ptr<Derived> is not derived from std::shared_ptr<Base<V> >

I could create a "AnyBase" class that removes the template parameter, but then that would remove some of the type safety that I have in place in my actual application, which is a must.

One thing I'm considering is create a mapping between the new class AnyBase and std::shared_ptr<AnyBase> , then use the function doSomethingNotShared for handling the type safety, and using the lookup mapping to get the shared_ptr. (see below)

std::map<AnyBase *, std::shared_ptr<AnyBase>> 

edit:

Example for checking type safety from my application:

template <class V, class W, class X>
void addRuleEdge(Bookkeeper<V> *bookkeeper, std::shared_ptr<IRule<V, W>> rule, ITask<W, X> *consumer)

In this case I want to have matching types between the Bookkeeper for V in the first template type of IRule and matching types for the second template parameter of IRule ( W ) with the first template type for ITask . This is used as an API call for users to ensure when adding an edge the types line up correctly at compile-time.

Answer 1

A simple solution is to change doSomething to handle a broader set of arguments.

template <class V>
void doSomething(std::shared_ptr<V> test)
{
    std::cout << "Shared type: " << test->typeName() << std::endl;
};

Edit: Using your latest example, I've written an example for how you can achieve what you want with a broader overload and std::enable_if or static_assert . I've supplied empty classes to allow the example to compile.

#include <memory>

template<class V>
class Bookkeeper {};

template<class V, class W>
class IRule {};

// Some rule class derived from IRule compatible with Bookkeepr
class RealRule : public IRule<int, float> {};

template<class W, class X>
class ITask {};

// Some task class derived from ITask, compatible with RealRule
class RealTask : public ITask<float, double> {};

// Some task class derived from ITask, not compatible with RealRule
class BadTask : public ITask<int, double> {};

template <class V, class Rule, class W, class X>
typename std::enable_if<std::is_base_of<IRule<V, W>, Rule>::value, void>::type
addRuleEdge(Bookkeeper<V> *bookkeeper, std::shared_ptr<Rule> rule, ITask<W, X> *consumer)
{
    // Do work
}

int main()
{
    Bookkeeper<int> my_book_keeper;
    auto my_rule = std::make_shared<RealRule>();
    RealTask my_task;

    // Compiles
    addRuleEdge(&my_book_keeper, my_rule, &my_task);

    BadTask bad_task;

    // Won't compile (no matching overload)
    addRuleEdge(&my_book_keeper, my_rule, &bad_task);
}

You can also choose to use static_assert if you simply want to be notified when the wrong types are used.

template <class V, class Rule, class W, class X>
void addRuleEdge(Bookkeeper<V> *bookkeeper, std::shared_ptr<Rule> rule, ITask<W, X> *consumer)
{
    static_assert(std::is_base_of<IRule<V, W>, Rule>::value, "Type mismatch!");
    // Do work
}

int main()
{
    Bookkeeper<int> my_book_keeper;
    auto my_rule = std::make_shared<RealRule>();
    RealTask my_task;

    // Compiles
    addRuleEdge(&my_book_keeper, my_rule, &my_task);

    BadTask bad_task;

    // Won't compile (error "Type mismatch!")
    addRuleEdge(&my_book_keeper, my_rule, &bad_task);
}

Answer 2

This looks like achievable with just a little bit of additional work.

First, begin by adding a type to the base class that aliases its template parameter:

template <class T>
class Base {
 public:

      typedef T type;

    // The rest of your base class is as it is before.
};

Now, tweak doSomething() slightly, to take an opaque shared pointer, and then figure out the base class it came from, then re-cast it:

template <class opaque_ptr>
void doSomething(std::shared_ptr<opaque_ptr> param)
{
   typedef typename opaque_ptr::type base_type;

   auto test = std::static_pointer_cast<Base<base_type>>(param);

   // Now your test is a std::shared_ptr<Base<T>>, proceed as before.

If you insist on passing std::shared_ptr<Base<V>> around, you have to type-convert it. std::shared_ptr<Derived> and std::shared_ptr<Base<V>> are not related to each other; one is not a derived class of the other one, so you cannot avoid recasting.

Answer 3

A shared_ptr<Base<V>> is a type that can be converted-from a shared_ptr<Derived> but they are otherwise unrelated.

template<template<class...>class Z>
struct is_derived_from_template_of_helper {
  template<class...Ts>
  constexpr std::true_type operator()(Z<Ts...>*) const { return {}; }
  constexpr std::false_type operator()(...) const { return {}; }
};
template<template<class...>class Z, class T>
using is_derived_from_template_of_t =
  decltype(
    is_derived_from_template_of_helper<Z>{}(
      std::declval<std::decay_t<T>*>()
    )
  );

now we can do this:

template <class X,
  class=std::enable_if_t<
    is_derived_from_template_instance_of_t<Base, X>{}
  >
>
void doSomething(std::shared_ptr<X> test)
{
  std::cout << "Shared type: " << test->typeName() << std::endl;
}

live example .

If you want to get types out ,

template<template<class...>class Z>
struct derived_from_template_args_tags_helper {
  template<class...Ts>
  constexpr std::tuple<tag_t<Ts>...> operator()(Z<Ts...>*) const { return {}; }
};
template<template<class...>class Z, class T, std::size_t I>
using derived_from_template_arg = typename std::tuple_element<I, decltype(derived_from_template_args_tags_helper<Z>{}(std::declval<std::decay_t<T>*>()))>::type::type;

template <class X,
  class=typename std::enable_if<
    std::is_same<
      derived_from_template_arg<Base, X, 0>, float
    >{}
  >::type
>
void doSomething(std::shared_ptr<X> test)
{
  std::cout << "Shared float type: " << test->typeName() << std::endl;
}

but this gets exceedingly and increasingly complex.