No class template named 'x' in 'y'

[pasquale199876]

When i try to compile code with TDM-GCC 4.9.2 64 bit realease i get:
[Error] no class template named 'Linear_list_ord' in 'class Linear_list<std::basic_string<char>, List_node<std::basic_string<char> >*>' at line 65 of Linked_list_ord.h

Here is Linked_list_ord.h

#ifndef _LINKED_LIST_ORD_H
#define _LINKED_LIST_ORD_H

#include "Linear_list_ord.h"

template<class T>
class Linked_list_ord;

template< class T >
class List_node{
	friend class Linked_list_ord<T>;
 private:
	T _value;
	List_node<T> * _pPrev;
	List_node<T> * _pNext;
};




template< class T >
class Linked_list_ord : public Linear_list_ord<T, List_node<T>*>{
 public:
	typedef typename Linear_list_ord<T, List_node<T>*>::value_type value_type;
	typedef typename Linear_list_ord<T, List_node<T>*>::position position;

	// costruttori
	Linked_list_ord();
	Linked_list_ord(int);
	// costruttore per copia
	Linked_list_ord(const Linked_list_ord<T>& );
	//distruttore
	~Linked_list_ord();

	// operatori
	void create();
	bool empty() const;
	value_type read(position) const;
	void write(const value_type &, position);
	position begin() const;
	position last() const;
	bool end(position) const;
	position next(position) const;
	position previous(position) const;
	void erase(position);
	void insert (const value_type &);
	void fondi(const Linked_list_ord<T> &);
	bool isPalindroma();
	
	
	int size() const {
		return _length;
	}

	// sovraccarico di operatori
	Linked_list_ord<T>& operator=(const Linked_list_ord<T>&); // the assignment operator
	bool operator==(const Linked_list_ord<T> &) const; // tests two list for equality

 private:
	List_node<T> * _pHead;
	int & _length = Linear_list<T,List_node<T>*>::template Linear_list_ord<T, List_node<T>*>::_length;
};

template< class T >
Linked_list_ord<T>::Linked_list_ord() {
	_pHead = new List_node<T>;
	_pHead->_pNext = _pHead;
	_pHead->_pPrev = _pHead;
	_length = 0;
}


template< class T >
Linked_list_ord< T >::Linked_list_ord(const Linked_list_ord<T>& L) {
  _length = L.size();

	_pHead = new List_node<T>;
	_pHead->_pNext = _pHead;
	_pHead->_pPrev = _pHead;

	if (!L.empty()){
		position p = L.last();
		for (int i=0; i <= L._length; i++){
			insert(L.read(p), begin());
			p = L.previous(p);
		}
	}
}


template< class T >
Linked_list_ord< T >::~Linked_list_ord(){
	while(!empty())
		erase(begin());
	delete _pHead;
}

template< class T >
void Linked_list_ord< T >::create(){
	if (empty())
			_length = 0;
}

template< class T >
bool Linked_list_ord< T >::empty() const {
	return(_pHead == _pHead->_pNext);
}

template< class T >
typename Linked_list_ord< T >::position
Linked_list_ord< T >::begin() const {
	return (_pHead->_pNext);
}

template< class T >
typename Linked_list_ord< T >::position
Linked_list_ord< T >::last() const {
	return (_pHead->_pPrev);
}


template< class T >
typename Linked_list_ord< T >::position
Linked_list_ord< T >::next(position p) const {
	return(p->_pNext);
}

template< class T >
typename Linked_list_ord< T >::position Linked_list_ord< T >::previous(position p) const {
	if (p != _pHead)
		return(p->_pPrev);
}

template< class T >
bool Linked_list_ord< T >::end(position p) const {
	return(p == _pHead);
}

template< class T >
typename Linked_list_ord< T >::value_type
Linked_list_ord< T >::read(position p) const {
	if (!end(p))
		return(p->_value);
}

template< class T >
void Linked_list_ord< T >::write(const value_type &a, position p) {
	if (!end(p))
    p->_value = a;
}

template< class T >
void Linked_list_ord<T>::insert(const value_type &a){
	position p = begin();
	position t = new List_node<value_type>;
	t->_value = a;
	
	while(a<read(p) && (!end(p)))
		p=next(p);
	t->_pNext = p;
	t->_pPrev = p->_pPrev;
	p->_pPrev->_pNext = t;
	p->_pPrev = t;

	_length++;
}

template< class T >
void Linked_list_ord< T >::erase(position p){
	if (!empty() && !end(p)){
		p->_pPrev->_pNext = p->_pNext;
		p->_pNext->_pPrev = p->_pPrev;
		delete p;
	}
}


template<class T>
Linked_list_ord<T>& Linked_list_ord<T>::operator=(const Linked_list_ord<T>& L){
	if (this != &L){
		_length = L.size();

		_pHead = new List_node<T>;
		_pHead->_pNext = _pHead;
		_pHead->_pPrev = _pHead;

        cout << L.empty();
        cout << L.size();
		if (!L.empty()){
            position p = L.last();
			for (int i=0; i < L.size(); i++){
				cout << i, L.read(p);
				insert(L.read(p), begin());
				p = L.previous(p);
			}
		}
	}
	return *this;
}

template<class T>
bool Linked_list_ord<T>::operator==(const Linked_list_ord<T> &L) const{
	if (L.size() != _length)
		return false;
	position p, pL;
	p = begin();
	pL = L.begin();
	while (!end(p)){
		if (p->_value != pL->_value)
			return false;
		p = p->_pNext;
		pL = pL->_pNext;
	}
	return true;
}

template <class T>
void Linked_list_ord<T>::fondi (const Linked_list_ord<T> &L) {
	Linked_list_ord<T>::position PL =L.begin();
	while(!L.end(PL)) {
		insert(L.read(PL));
		PL = L.next(PL);
	}
	
}

template <class T>
bool Linked_list_ord<T>::isPalindroma () {
	Linked_list_ord<T>::position PL =next(begin());
	while(!end(PL)) {
		if(read(previous(PL)!=read(PL))) return false;
	}
	return true;
	
}

#endif // _LINKED_LIST_H 

Here is Linear_list_ord.h

#ifndef _LINEARLISTORD_H
#define _LINEARLISTORD_H

#include "Linear_list.h"


template< class T, class P >
class Linear_list_ord : public Linear_list<T,P> {
public:
	typedef typename Linear_list<T,P>::value_type value_type;
	typedef typename Linear_list<T,P>::position position;
	virtual void insert (const value_type &) = 0;
};

#endif // _LISTALIN_H 

Linear_list.h

#ifndef _LISTALIN_H
#define _LISTALIN_H

#include <iostream>

using std::cout;
using std::endl;
using std::ostream;

// classe astratta listaLinare
template< class T, class P >
class Linear_list{
 public:
	typedef T value_type;   // the type of object, T, stored in the list
	typedef P position;
	
	// operators
	virtual void create() = 0;
	virtual bool empty() const = 0; // true if the list's size is 0
	virtual value_type read(position) const = 0;
	virtual void write(const value_type & x, position p) = 0; // write x at position p
	virtual position begin() const = 0;  // returns a position pointing to the beginning of the list
	virtual bool end(position) const = 0; // true with a position pointing to the end of the list
	virtual position next(position) const = 0; // returns the next position
	virtual position previous(position) const = 0; // return the previous position
	virtual void erase(position) = 0;

	// funzioni di servizio
	//friend ostream& operator<< <T,P>(ostream&, const Linear_list<T,P>&);

	/* Altre funzioni di servizio implementabili */
	/*
		virtual int size() const;  // returns the size of the list
		virtual void push_front(const value_type &); // insert a new element at the beginning
		virtual void push_back(const value_type &); // insert a new element at the end
		virtual void pop_front(); // removes the first element
		virtual void pop_back(); // removes the last element
		virtual void clear(); // erases all the elements
	*/
	
	 int lunghezza() {
		return _length;
			}

	position last() {
		position p = begin();
			int i=0;
		while(i<lunghezza()) {
			p = next(p);
			i++; 
			} 
	}
	 void inverti(){
		position l = begin();
		position r = last();
		value_type temp;
		int i=0;

		while(i<lunghezza()/2) {
			temp = read(l);
			write(read(r),l);
			write(temp,r);
			l=next(l);
			r=previous(r);
			i++;
			}
	}
	
		bool isPalindroma(){
		position l = begin();
		position r = last();
		bool palindroma = true;
		value_type temp;

		int i=0;
		while(i<lunghezza()/2 && palindroma) {
			palindroma = read(l)==read(r);
			l=next(l);
			r=previous(r);
			i++;
			}
		return palindroma;
	}
	 protected:
		int _length;
};
/* sovraccarica <<. Attenzione se il tipo restituito da read non è primitivo, allora
 * anche per questo tipo bisogna sovraccaricare l'operatore << 
 */
template< class T, class P >
ostream& operator<<(ostream& os, const Linear_list<T,P> &l){
	typename Linear_list<T,P>::position p;
	p = l.begin();
	os << "[";
	while (!l.end(p)){
		if (p != l.begin())
			os << ", " << l.read(p);
		else
			os << l.read(p);
		p = l.next(p);
	}
	os << "]" << endl;
	return os;
}

/*
template< class T, class P >
int Linear_list<T,P>::size() const{
   ....
}
*/

#endif // _LISTALIN_H  

And main.cpp

#include "Linked_list_ord.h"
#include <stdlib.h>
#include <iostream>
#include <string>

int main () {
	
	Linked_list_ord<std::string> bello ;
	
	bello.insert("hello");
	  
	return 0;
	}

[ne555]

//int & _length = Linear_list<T,List_node<T>*>::template Linear_list_ord<T, List_node<T>*>::_length;
int & _length = Linear_list_ord<T, List_node<T>*>::_length;

¿what's the idea? ¿why make the reference instead of accessing it directly (or using the interface)?

[pasquale199876]

I wanted to simplify the name

[Enoizat]

It seems this could do the trick:

template< class T, class P >
class Linear_list_ord : public Linear_list<T,P> {
public:
    . . .
protected:
    using Linear_list<T, P>::_length; // <-- added
};

template< class T >
class Linked_list_ord : public Linear_list_ord<T, List_node<T>*> {
public:
    . . .
private:
    List_node<T> * _pHead;
    // removed:
    int & _length = Linear_list<T,List_node<T>*>::template Linear_list_ord<T, List_node<T>*>::_length;
    using Linear_list_ord<T, List_node<T>*>::_length; // <-- added
};

Anyway you’d better comment out this instruction inside main():
bello.insert("hello");
since your insert() method causes the program to crash.

[pasquale199876]

Thnak you, it worked