I defined a class ListNode, with few extra definitions added: ListNode_str.h

Question

Re-write this code as a template class, and re-name this file to ListNode.h

#pragma once

#include<iostream>

#include<string>

using std::string;

class ListNode

{

string value; // node's value

ListNode* prev; // link to the previous ListNode

ListNode* succ; // link to the successive ListNode

public:

ListNode(const string& v, ListNode* p = nullptr, ListNode* s = nullptr) :

value{ value }, prev{ p }, succ{ s }

{}

string get() const; // returns value

void set(string str); // sets value to v

ListNode* getPrev() const ; // returns the link to the previous ListNode

ListNode* getSucc() const; // returns the link to the successive ListNode

void setPrev(ListNode* node); // sets the link to the previous ListNode

void setSucc(ListNode* node); // sets the link to the successive ListNode

};

string ListNode::get() const // returns value

{

return value;

}

void ListNode::set(string v) // sets value to v

{

value = v;

}

ListNode* ListNode::getPrev() const

{ // returns the link to the previous ListNode

return prev;

}

ListNode* ListNode::getSucc() const

{ // returns the link to the successive ListNode

return succ;

}

void ListNode::setPrev(ListNode* node)

{ // sets the link to the previous ListNode

prev = node;

}

void ListNode::setSucc(ListNode* node)

{ // sets the link to the successive ListNode

succ = node;

}

Answer 1

Here's a quick idea of creating a template class based on the ListNode implementation.

The main routine first instantiates a set of ListNode elements to hold integer values. It then instantiates a set to hold "double" values.

___________

#include <stdio.h>

#pragma once

#include<iostream>

#include<string>

template <class T> class ListNode

{

T value; // node's value

ListNode<T>* prev; // link to the previous ListNode

ListNode<T>* succ; // link to the successive ListNode

public:

ListNode<T> (const T& v, ListNode<T>* p = nullptr, ListNode<T>* s = nullptr) :

value{ value }, prev{ p }, succ{ s }

{

value = v;

prev = p;

succ = s;

}

T get() const; // returns value

void set (T str); // sets value to v

ListNode<T>* getPrev() const ; // returns the link to the previous ListNode

ListNode<T>* getSucc() const; // returns the link to the successive ListNode

void setPrev(ListNode<T>* node); // sets the link to the previous ListNode

void setSucc(ListNode<T>* node); // sets the link to the successive ListNode

};

template <class T>

T ListNode<T>::get() const // returns value

{

return value;

}

template <class T>

void ListNode<T>::set(T v) // sets value to v

{

value = v;

}

template <class T>

ListNode<T>* ListNode<T>::getPrev() const

{ // returns the link to the previous ListNode

return prev;

}

template <class T>

ListNode<T>* ListNode<T>::getSucc() const

{ // returns the link to the successive ListNode

return succ;

}

template <class T>

void ListNode<T>::setPrev(ListNode<T>* node)

{ // sets the link to the previous ListNode

prev = node;

}

template <class T>

void ListNode<T>::setSucc(ListNode<T>* node)

{ // sets the link to the successive ListNode

succ = node;

}

int main()

{

// create three test nodes and link them so that lnprec <-> ln1 <-> lnsucc

//

ListNode<int> *lnprev = new ListNode<int>(17, nullptr);

ListNode<int> *ln1 = new ListNode<int>(42, lnprev);

lnprev->setSucc(ln1);

ListNode<int> *lnsucc = new ListNode<int>(55, ln1, nullptr);

ln1->setSucc(lnsucc);

printf("%d %d %d\n", lnprev->get(), lnprev->getSucc()->get(), lnprev->getSucc()->getSucc()->get());

ListNode<double> *lnprevd = new ListNode<double>(3.14, nullptr);

ListNode<double> *ln1d = new ListNode<double>(2.78, lnprevd);

lnprevd->setSucc(ln1d);

ListNode<double> *lnsuccd = new ListNode<double>(1.62, ln1d, nullptr);

ln1d->setSucc(lnsuccd);

printf("%f %f %f\n", lnsuccd->get(), lnsuccd->getPrev()->get(), lnsuccd->getPrev()->getPrev()->get());

return 0;

}