Блог

(Во-первых, в качестве оговорки, это связано с назначением. Я не прошу никого выполнять мое задание за меня, просто чтобы попытаться помочь мне понять, как правильно реализовать шаблоны.)

Моя текущая настройка:

У меня есть класс A, который является базовым классом. Классы B, C и D — все дочерние элементы класса A.

Я пытаюсь создать связанный список, который в рамках одного списка может указывать на B, C или D.

В настоящее время у меня настроено что-то вроде этого:

 enum Types { TypeB, TypeC, TypeD }

struct Node
{
    void * pointerToElement;
    int type;
    Node * next;
};

struct Header
{
    int counter;
    Node * first;
};
  

Это действительно работает. Когда я просматриваю связанный список, чтобы распечатать все элементы, я использую оператор and if и int type , чтобы определить, какой это тип (на основе определенного перечисления), а затем использую static_cast для приведения указателя void к указателю класса B, C или D.

Теперь мне сказали, что вместо этого я должен использовать шаблоны, что вызывает сильную головную боль. Я мало что сделал с шаблонами, но мой опыт работы с ними не был таким уж приятным.

Мое понимание шаблонов заключается в том, что я мог бы использовать его для определения всего связанного списка с классом B, C или D, но было бы неправдоподобно, чтобы все B, C или D отображались в одном связанном списке?

Я попробовал следующее:

 enum Types { TypeB, TypeC, TypeD } // I realise that if templates work, I won't need this

template <class T>
struct Node
{
    T * pointerToElement;
    int type;
    Node<T> * next;    // Reason 1 I suspect I could only use one type
};

template <class T>
struct Header
{
    int counter;
    Node<T> * first;    // Reason 2 I suspect I could only use one type
};
  

Главный вопрос, который у меня есть, должны ли шаблоны быть способны это делать? При реализации этого в классе мне нужно было указать тип для заголовка, чего я не хотел делать, поэтому я также сделал этот класс шаблоном, и он продолжал следовать до конца моего кода, который не должен был быть шаблоном, и, наконец, добрался до main (), где мне пришлось бы определить либо класс B, C, либо D.

Комментарии и предложения приветствуются.

Спасибо.

Редактировать

Спасибо всем за комментарии, я, вероятно, узнал больше, попробовав это, чем из лекций.

То, что я сделал, в значительной степени отбросило шаблоны или, по крайней мере, то, как я пытался их использовать. Я использовал шаблоны (к сожалению, ради использования шаблонов), и это работает. Вот что я сейчас сделал (все разработано на основе всех полезных комментариев … спасибо!)

 template <class T>
struct Node
{
    T * pointerToElement;
    int type;   // I can get rid of this after I go through the code and remove all references to it, which I am doing now.
    Node<T> * next;    // Reason 1 I suspect I could only use one type
};

template <class T>
struct Header
{
    int counter;
    Node<T> * first;    // Reason 2 I suspect I could only use one type
};
  

все по-прежнему так, как было, но при объявлении заголовка я объявляю его как:

Заголовок * MyHeader;

(Я использую структуру классов, идентичную той, что приведена в решении ниже).

Итак, это указывает на базовый класс, тот, от которого происходят все остальные классы. Затем, из-за наследования, я могу хранить там классы B, C или D без каких-либо проблем, и при условии, что все функции, определенные в производных классах (B, C и D), определены в базовом классе, я могу вызывать его напрямую, без необходимости его приведения (например, у всех них есть своя функция print, и она вызывает правильную функцию, когда она определена в производном классе).

Я думаю, что идея, которую пытается донести присваивание, — это связанный список, который можно использовать с любым типом, я думаю, что произошло некоторое недопонимание (вероятно, в основном из-за меня), я думал, что шаблоны должны использоваться для определения разных типов классов в каждом узле, скорее их можно использовать для определения базового класса.

Вместо шаблонов вы должны использовать наследование. Шаблоны, как вы догадались, создают экземпляр для каждого типа T , а это не то, что вы хотите.

Ваш код должен быть примерно в этих строках:

 class A{...};
class B: public A{...};
class C: public A{...};
class D: public A{...};
struct Node{
    A *next;
}
  

вы можете назначить next указателям на A , B C или D . Не забудьте пометить функции-члены как virtual там, где это уместно.