generic linked list

[bessaz]

Hi, guys!

I need to create a generic linked list (Polymorphic containers),with class no the structur, I found this answer on the site
http://www.cplusplus.com/forum/general/1643/

but me me do not want the boost class used, and in the third resolution which offers ' Jsmith ' I understood nothing! somebody could me helped

thx

Ps :excusing my English because it's my third étrangére language

[kbw]

Do you have a specific C++ question?

[bessaz]

how I must make to define my list ??

class Node{
	public:
	void* info;
	Node* next;
	Node(/*which type for this parameter*/ m, Node *p = NULL) {//how to define my constructor}
};


class List{
	Node *first;

	public:
	List(){ first = NULL; }
    void insert( /*which type for this parameter*/ d ) {/*what I must make?*/};
	void print(){/*??*/}
};

I want indications ! PLZ

[kevinchkin]

I am not sure what your question is, but as per not understanding solution 3 for the given URL, here is the explanation:

/*******************************
node_base() is a constructor and it      
is initializing the data member next.     
*******************************/ 
class node_base { 
    node_base* next;
  public:
    node_base(): next() {}  
};
/**********************************************
Generic Class node, which inherits node_base. Note         
that even though it is public inheritance, next will not be    
inherited as it is private member of node_base.                 
node( const T& d ) : data( d ), is a constructor and            
initializing member data to d.                                             
***********************************************/ 

template< typename T >             
class node : public node_base { 
    T data;    
  public:
    node( const T& d ) : data( d ) {}
};
/******************************************
  In the class declaration below, insert is a generic    
  function, i.e. any type of data type                           
******************************************/



class polymorphic_list {
    node_base* head;
  public:
    polymorphic_list() : head() {}

    template< typename T >
    void insert( const T& d ) {
       node_base* n = new node<T>( d );
       // ... etc ...
     }
};

So for ex. when you'll declare object of node something like

Node <int> obj; 

type of member data and d will be int.
and for polymorphic list class.

polymorphic_list obj2; 
obj2.insert<int>(2); 

Hope this helps !

[bessaz]

Ok, thank you Kevinchkin for explanation, I begin understanding ,
But one case of list already to create how I am going to make to link up the elements of my list:

void insert( const T& d ) {
       node_base* n = new node<T>( d );
head->next = n; // it's correct ?? 

And if I want to show the stocks of my list??

node_base* current ;

current = head ;

while (current->next != NULL)

return current->data ;

[kevinchkin]

If you want to add elements to your list then you'll have to do this way. (Assuming you are passing head as a reference to this function. This head's value will be copied in p. So the signature of p is node_base** p; )

while (p->next != NULL) { 

          p = p->next;   //Finding the end, so that we can add a new node  
} 

p->next  = new node<T>(d); 
p = p->next; 
p->data = // whatever data you want to specify
p->next = NULL; 

To show elements of your list

node_base* current; 
current = head; 
while (current != NULL) { 
cout<<current->data; 
current = current->next; 
} 

Hope this helps !

[bessaz]

thanks a lot kevinchekin :)

but in both methods insertToHead and insertToTail There is not a redandance? when I call the constructor and when I affect d in ptr-> data

class polymorphic_list {
    node_base* head, *tail;
  public:
    polymorphic_list() : head() {}

    template< typename T >
    void insertToHead( const T& d ) {
       node_base* ptr = new node<T>( d );// here There is not a redandance?
       ptr->data=d;// with this line
    if(isEmpty())
        head=ptr;
    else
    {
        ptr->next=head;
        head=ptr;
    }
	 }
void insertToTail(const T& d)
{
    if(isEmpty())
        insertToHead(d);
    else
    {
        node_base* ptr = new node<T>( d );
        ptr->data=d;
        tail->next=ptr;
        tail=tail->next;
    }
}
};

[firedraco]

It could be...but it depends on what the constructor is doing. If for some reason the constructor didn't initialize ptr->data, with d, then no it isn't. But as it stands, it probably is.

[bessaz]

thx :)

but, in your code kevinchkin :

node_base* current; 
current = head; 
while (current != NULL) { 
cout<<current->data; 
current = current->next; 
} 

data is not a member of class node_base !! --> i have the compilation error

& why the signature of p is node_base** p ?? because i have this error :

cannot convert 'node_base**' to 'node_base*' in assignment

 template< typename T >
    void insert( const T& d ) {
      
        node_base** ptr = new node<T>( d );
        //ptr->data=d;
        tail->next=ptr; // in this line
        tail=tail->next;
     }