Template classes - Declaring a 'List' variable

Posted on 2000-04-22
Last Modified: 2010-04-02
Given the header file code below, what would be the correct way to declare multiple Lists within main()?

I'm wondering if I should declare in the header file each 'List' type, something like 'OwnerList' would be used instead of the generic 'List' I now have:

      template <class ListData>
      class ListNode{

                  // ListNode constructors
                  ListNode(){prev = next = NULL;};
                  // overloaded constructor
                  ListNode(ListNode<ListData> *LN1,      // assign value to prev pointer
                               ListNode<ListData> *LN2,      // assign value to next pointer
                               ListData * LD)                  // assign value to data member
                              {prev = LN1; next = LN2; Data = LD;};

                  // ListNode destructor

                  // get next & previous ListNode pointers
                  ListNode<ListData> *GetNextListNode(){return next;};
                  ListNode<ListData> *GetPrevListNode(){return prev;};

                  // set next & previous ListNode pointers
                  void SetNextPtr(ListNode<ListData> * LN){next = LN;};
                  void SetPrevPtr(ListNode<ListData> * LN){prev = LN;};

                  // get ListNode data member
                  ListData * GetDataMember(ListNode<ListData> * LN){ return LN->Data;};

                  // set ListNode data member
                  void SetDataMember(ListData *LN){Data = LN;};


                  ListNode<ListData> *prev;
                  ListNode<ListData> *next;
                  ListData * Data;

      template <class ListData>
      class List{


                  ListNode<ListData> *AddListNode(const ListData &);
                  void DeleteList();
                  void DeleteListNode(ListNode<ListData> *);
                  ListNode<ListData> *GetFirstListNode(){return head;};
                  ListNode<ListData> *GetLastListNode(){return tail;};
                  List(){head = tail = NULL;}

                  ListNode<ListData> *head;
                  ListNode<ListData> *tail;

Question by:John500
  • 2

Expert Comment

ID: 2740783
I'm sure the answer to your question is more complex, but ...   Just write
List<int> myIntList;
List<float> myFloatList;
Replace ListData by anything you want. I didn't really understand your 2nd question, but on a quick glance at your templates it looks fine.


Author Comment

ID: 2740820

I did as you suggested and declared the following in main():

List<int> myIntList;
List<float> myFloatList;

Have any ideas why I would get this error in the function below:

error C2228: left of '.GetNextListNode' must have class/struct/union type

template <class ListData>
      void List<ListData>::DeleteList()
            // create a pointer to the ListNode head
            ListNode<ListData> *CurPtr = head;
            // ListNode pointer used to hold the value of CurPtr
            ListNode<ListData> *temp = NULL;

            while(CurPtr != NULL){
                  // store the pointer of CurPtr
                  temp = CurPtr;
                  // advance CurPtr to next ListNode
                  CurPtr = CurPtr.GetNextListNode();
                  // delete the memory block held by the ListNode
                  // delete current ListNode
            head = NULL;
            tail = NULL;

Accepted Solution

GlennDean earned 50 total points
ID: 2740896
Ah, CurPtr is a pointer so change the . to a ->


Featured Post

How to improve team productivity

Quip adds documents, spreadsheets, and tasklists to your Slack experience
- Elevate ideas to Quip docs
- Share Quip docs in Slack
- Get notified of changes to your docs
- Available on iOS/Android/Desktop/Web
- Online/Offline

Join & Write a Comment

When writing generic code, using template meta-programming techniques, it is sometimes useful to know if a type is convertible to another type. A good example of when this might be is if you are writing diagnostic instrumentation for code to generat…
What is C++ STL?: STL stands for Standard Template Library and is a part of standard C++ libraries. It contains many useful data structures (containers) and algorithms, which can spare you a lot of the time. Today we will look at the STL Vector. …
The goal of the video will be to teach the user the concept of local variables and scope. An example of a locally defined variable will be given as well as an explanation of what scope is in C++. The local variable and concept of scope will be relat…
The viewer will be introduced to the member functions push_back and pop_back of the vector class. The video will teach the difference between the two as well as how to use each one along with its functionality.

747 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

13 Experts available now in Live!

Get 1:1 Help Now