C++ member access from a derived class of a templated type

Question

Long story short, what I want here is to declare a templated type in a base class and be able to access that type A<T> such that the base class B contains it and the derived class C is able to access it as C::A<T>. I did try declaring an int inside of class B and that can be accessed from the derived C class as C::int, here's the error!

||In constructor ‘D::D()’:|
|74|error: no match for ‘operator=’ (operand types are ‘A<C*>’ and ‘A<B*>’)|
|4|note: candidate: A<C*>& A<C*>::operator=(const A<C*>&)|
|4|note:   no known conversion for argument 1 from ‘A<B*>’ to ‘const A<C*>&’|

And this is the code that does compile ( comment A<B*> i; and uncomment A<C*> i; to get the error).

#include <iostream>
//class with a template parameter
template <class a>
class A
{
    private:

        int somevalue;

    public:

    A(){}
    ~A(){}
    void print()
    {
        std::cout<<somevalue<<std::endl;
    }
};

//1. could forward declare
class C;
class B
{
    protected:

        A<B*> i;
        //2. and then use
        //A<C*> i;

    public:

        B(){}
        ~B(){}
        A<B*> get()
        {
            return i;
        }

        /*
        //3. use this return instead
        A<C*> get()
        {
            return i;
        }
        */
};
//specialization of B that uses B's methods variables
class C : public B
{
    protected:

    public:

        C(){}
        virtual ~C(){}
        void method()
        {
            B::i.print();
        }
};
//class D that inherits the specialization of C
class D : public C
{
    private:

        A<B*> i;//works
        //4. but I want the inherited type to work like
        //A<C*> i;// so that the type C* is interpreted as B*

    public:

    D()
    {
        this->i = C::i;
    }
    ~D(){}
};
///////////////////////////////////////////////////////////////////////
int main()
{
    D* d = new D();

    delete d;

    return 0;
}

Answer 1

But okay what if we tried this std::list<template parameter> LIST and then plug that in? That's the problem A<T> is std::list.

As far as I understand your issue now you seem to have a std::list<Base *> (renamed B to Base for clarity) and want to fill an std::list<Concrete*> (renamed C to Concrete, it's derived from Base) with it.

For that you need to iterate over the Base* pointers, checking for each whether it can be downcast to a Concrete* and if so adding it to the std::list<Concrete*>. You need to think about what to do if the downcast fails, too.

For all of this to work your Base needs to be a polymorphic base class, that is it must contain a virtual member function (don't forget to make the destructor virtual). Also note that this sounds like a catastrophe waiting to happen in terms of managing ownership of those pointers.

template<typename Base, typename Concrete>
std::list<Concrete*> downcast_list (std::list<Base*> const & bases) {
 std::list<Concrete*> result;
  for (auto const base_ptr : bases) {
    Concrete * concrete_ptr = dynamic_cast<Concrete*>(base_ptr);
    if (concrete_ptr != nullptr) {
      result.push_back(concrete_ptr);
    } else {
      // Error or ignore?
    }
  }
  return result;
}

Note: a more idiomatic version of this would use iterators.

Answer 2

I found the pattern to my problem, it's actually really simple and it serves as the base for encapsulating a class type a (which is a template parameter to be passed around, try looking at my question as a reference to class a). The pattern is shown below, it's generally what I wanted. I found it on this webpage Using Inheritance Between Templates chapter 7.5 from the book entitled OBJECT-ORIENTED SOFTWARE DESIGN and CONSTRUCTION with C++ by Dennis Kafura. I'll copy it below the edited code for the sake of future reference in case anyone else needs it.

template <class a> 
class B 
{
    private:      

    public:

        B();     
        ~B();
};

template <class a> 
class C : public B<a>
{
   public:
    C();
    ~C();
};

This is the code it was adapted from.

template <class QueueItem> class Queue 
{
   private:

      QueueItem buffer[100];
      int head, tail, count;

    public:
                Queue();
      void      Insert(QueueItem item);
      QueueItem Remove();
               ~Queue();
};

template <class QueueItem> class InspectableQueue : public Queue<QueueItem>
{
   public:
               InspectableQueue();
     QueueItem Inspect();  // return without removing the first element
              ~InspectableQueue();
};

Answer 3

Try changing this:

#include <iostream>
//class with a template parameter
template <class a>
class A {
private:    
    int somevalue;    
public:    
    A(){}
    ~A(){}
    void print() {
        std::cout<<somevalue<<std::endl;
    }
};

---

//1. could forward declare
class C;
class B {
protected:    
    A<B*> i;
    //2. and then use
    //A<C*> i;    
public:    
    B(){}
    ~B(){}
    A<B*> get() {
        return i;
    }

    /*/3. use this return instead
    A<C*> get() {
       return i;
    } */
};

---

//specialization of B that uses B's methods variables
class C : public B {
protected:
public:    
    C(){}
    virtual ~C(){}
    void method() {
        B::i.print();
    }
};    

---

//class D that inherits the specialization of C
class D : public C {
private:   
    A<B*> i;//works
    //4. but I want the inherited type to work like
    //A<C*> i;// so that the type C* is interpreted as B*
public:    
    D() {
        this->i = C::i;
    }
    ~D(){}
};

---

   int main() {
    D* d = new D();    
    delete d;    
    return 0;
}

To Something Like This:

#include <iostream>

//class with a template parameter
template <typename T>
class Foo {
private:    
    T value_;    
public:    
    Foo(){} // Default
    Foo( T value ) : value_(value) {}
    ~Foo(){}
    void print() {
        std::cout<< value_ << std::endl;
    }
};

---

class Derived;
class Base {
protected:
    Foo<Base*> foo_;
    Base(){} // Default;
    virtual ~Base(){}

    // Overload This Function
    template<typename T = Base>
    /*virtual*/ Foo<T*> get();

    /*virtual*/ Foo<Base*> get() { return this->foo_; }
    /*virtual*/ Foo<Derived*> get();
};

---

class Derived : Base {
public:
    Derived() {}
    virtual ~Derived() {}

    void func() {
        Base::foo_.print();
    }
    void Foo<Derived*> get() override { return this->foo_; } 
 };

And this is as about as far as I could get trying to answering your question...

• There are objects that you are not using in your code
• There are methods that aren't being called.
• It is kind of hard to understand the direction/indirection of what you mean to do with the inheritance tree.
• You are inheriting from a base class without a virtual destructor
• And probably a few other things that I can not think of off the top of my head right now.

I'd be more than willing to try and help you out; but this is as far as I can go with what you currently are showing.

EDIT -- I made changes to the base & derived classes and removed the virtual keyword to the overloaded function template declarations - definitions belonging to those classes.