[C++] Problem z dedovanjem šablon (template inhieritance)

++++++++++ linked.h +++++++++

#ifndef _LINKED1_H
#define _LINKED1_H

#include <cstring>

/* one-way linked list */

// BASIC NODE CLASS

template <class T>
class Node
{
protected:
	Node<T> * next;
	T * data;	
	long count;
	
public:	
	Node ();
	Node ( Node<T> * nxt );
	Node ( Node<T> * nxt, T * dat );
	Node ( Node<T> & src );
	Node ( T * dat );
	~Node ();
	
	virtual void Append ( T * d );
	virtual void Add ( T * d ); // sorted - class T must have working < and == operators |this will sort in ascending order; counting the same instances
};

// HEAD NODE CLASS

template <class T>
class HeadNode : public Node<T>
{
public:
	HeadNode ();
	~HeadNode ();

	void Add ( T * d );
};

// TAIL NODE CLASS

template <class T>
class TailNode : public Node<T>
{
public:
	TailNode ();
	void Append ( T * d );
};

// BODY NODE CLASS

template <class T>
class BodyNode : public Node<T>
{
public:
	
};

#endif

++++++++++ linked.cpp +++++++++++

#include "linked1.h"

/* one-way linked list */

// LINKED LIST CLASS


// BASIC NODE CLASS

template <class T>
Node<T>::Node ()
{
	next = NULL;
	data = NULL;
	count = 0;
}

template <class T>
Node<T>::Node ( Node<T> * nxt )
{
	data = NULL;
	next = nxt;
	count = 0;
}

template <class T>
Node<T>::Node ( Node <T> * nxt, T * dat )
{
	data = new T;
	memcpy ( data, dat, sizeof (T) );
	next = nxt;
	count = 1;
}

template <class T>
Node<T>::Node ( Node<T> & src )
{
	next = src.next;
	data = new T;
	memcpy ( data, src.data, sizeof (T) );
	count = 1;
}

template <class T>
Node<T>::Node ( T * dat )
{
	next = NULL;
	data = new T;
	memcpy ( data, dat, sizeof (T) );
	count = 1;
}

template <class T>
Node<T>::~Node ()
{
	next = NULL;
	if (data!=NULL)
		delete data;
}


template <class T>
void Node<T>::Append ( T * d )
{
	Node<T> * temp = next;
	next = new Node<T> ( temp, d );
}

template <class T>
void Node<T>::Add ( T * d )
{
	if ( next->count == -1 )
		Append ( d );
	
	else if ( data == d )
		count++;
		
	else if ( (data < d) && (d < next->data) )
		Append ( d );
		
	else
		next->Add ( d );
		
	return;
}

	
// HEAD NODE CLASS

template <class T>
HeadNode<T>::HeadNode ()
{
	next = new TailNode<T>;
}

template <class T>
HeadNode<T>::~HeadNode()
{
	delete next;
}

template <class T>
void HeadNode<T>::Add ( T * d )
{
	if ( next->count == -1 )
		Append ( d );
		
	else if ( d < next->data )
		Append ( d );
		
	else
		next->Add ( d );
		
	return;
}


// TAIL NODE CLASS	

template <class T>
TailNode<T>::TailNode ()
{
	count = -1;
}

template <class T>
void TailNode<T>::Append ( T * d )
{
	return;
}

// BODY NODE CLASS

Napaka ki jo zadeva vrže:

 C:\dev\aps1\Naloga1\linked1.cpp In constructor `HeadNode<T>::HeadNode()': 
94 C:\dev\aps1\Naloga1\linked1.cpp `next' undeclared (first use this function) 
  (Each undeclared identifier is reported only once for each function it appears in.) 
 C:\dev\aps1\Naloga1\linked1.cpp In destructor `HeadNode<T>::~HeadNode()': 
100 C:\dev\aps1\Naloga1\linked1.cpp `next' undeclared (first use this function) 

...
itd.


---
Zadeva: v starševskem razredu Node je kot protected deklariranih nekaj spremenljivk. Podedovani razredi bi morali imeti te spremenljivke vsebovane kot protected (ker gre za public dedovanje) - vsaj tako sem jaz razmišljal. Ko sem z zadeve vrgel template ven še vedno ni delovalo, dokler nisem spremenljivk deklariral public. Druga rešitev tukaj je da naredim public metode ki dostopajo do spremenljivk, kar tudi ni ravno različna od trenutne. Na videz enostaven problem ... zadevo pa vseeno hočem imeti približno v tem smislu. (lahko bi naredil v cju, javi, whatevah; samo hočem tako, kot bi tudi tu moralo delovat).

Hvala za pomoč.

ps. zaprite topic, ki sem ga zaj***l, se opravičujem

Nejc

pogosto?
templati rabijo implementacijo v header-ju...

#ifndef _LINKED1_H
#define _LINKED1_H

#include <cstring>

/* one-way linked list */

// BASIC NODE CLASS

template <class T>
class Node
{
protected:
	Node<T> * next;
	T * data;	
	long count;
	
public:	
	Node () {
		 next = NULL; 
		 data = NULL; 
		 count = 0; };
	Node ( Node<T> * nxt ) {
		 data = NULL;
		 next = nxt;
		 count = 0; };
	Node ( Node<T> * nxt, T * dat ) {
		 data = new T;
		 memcpy ( data, dat, sizeof (T) );
		 next = nxt;
		 count = 1; };
	Node ( Node<T> & src ) {
		 next = src.next;
		 data = new T;
		 memcpy ( data, src.data, sizeof (T) );
		 count = 1; };
	Node ( T * dat ) {
		 next = NULL;
		 data = new T;
		 memcpy ( data, dat, sizeof (T) );
		 count = 1; };
	~Node () {
		  next = NULL;
		  if (data!=NULL)
		  	 delete data; };
	
	virtual void Append ( T * d ) {
			Node<T> * temp = next;
			next = new Node<T> ( temp, d ); };
	virtual void Add ( T * d ) { // sorted - class T must have working < and == operators |this will sort in ascending order; counting the same instances
			if ( next->count == -1 )
   			   Append ( d );
	   	  	else if ( data == d )
				 count++;
			else if ( (data < d) && (d < next->data) )
				 Append ( d );	
			else
				next->Add ( d );
			return; };
};

// HEAD NODE CLASS

template <class T>
class HeadNode : public Node<T>
{
public:
	HeadNode () {
	    next = new TailNode<T>; };
	~HeadNode () {
		delete next; };

	void Add ( T * d ) {
	    if ( next->count == -1 )
 		   Append ( d );		
		else if ( d < next->data )
			 Append ( d );	
		else
			next->Add ( d );
		return; };
};

// TAIL NODE CLASS

template <class T>
class TailNode : public Node<T>
{
public:
	TailNode () {
		count = -1; };
	void Append ( T * d ) {
		return; };
};

// BODY NODE CLASS

template <class T>
class BodyNode : public Node<T>
{
public:
	
};

#endif

Enako; "next undeclared" itd.

Zanimivo, da tole g++ 3.3.5 pozre, 4.0.2 pa ne:

template <class T>
class A {
        protected:
                int x;

        public:
                A()
                {
                }
};

template <class T>
class B: public A<T> {
        public:
                B()
                {
                        x = 1;
                }
};

Takole sem potem 4.0.2 prisilil v sodelovanje. Ocitno se en obskuren del c++-sa. Bi bilo zanimivo, ce bi kdo to se na vc++ 2003/2005 in icc-ju probal!

template <class T>
class A {
        protected:
                int x;

        public:
                A()
                {
                }
};

template <class T>
class B: public A<T> {
        public:
                B()
                {
                        A<T>::x = 1;
                }
};

sem probal na vc7, pa je precej manj tezaski...

ne, sej dovoli, samo na enakem levelu mora bit (public->public, protected->protected) kar je rahlo cudno...

Intel C++ Compiler.