✔ CPP Problem: Verkettet Liste mittels Templates!

[joeboe]

Hallo Liebe Leute,

Ich befinde mich grade in der Klausurvorbereitung für Objektorientierte Anwendungen und habe die Klasse: Liste erstellt.

Die Klasse funktioniert bis auf ein kleinen Fehler im Algorithmus einwandfrei, darum gehts aber nicht.

Ich will die Klasse nun mittels Templates so ändern das beliebige Datentypen gespeichert werden können.

€: Code gefixt!

#include <iostream>
using namespace std;

template <typename T>
struct Knoten {
	T value;
	Knoten<T> *next;

	Knoten(T v = 0) {
		next = 0;
		value = v;
	}
};


template <typename T>
class Liste {
private:

	Knoten<T> *first;
	int size;

public:
	Liste();
	~Liste();

	void insert(T v);
	bool find(T v);
};

template <typename T>
Liste<T>::Liste() {
	size = 0;
	first = new Knoten<T>();
}

template <typename T>
Liste<T>::~Liste() {
	while (first != 0 ) {
		Knoten<T> *k = first->next;
		delete first;
		first = k;
	}
}


template <typename T>
void Liste<T>::insert(T v) {

	if(!find(v)) {

	Knoten<T> *k = new Knoten<T>();
	k->value = v;
	k->next = first;
	first = k;

	}

	else cout << "Knoten enthalten";

}

template <typename T>
bool Liste<T>::find(T v) {

	Knoten<T> *k = first;

	if (k->value == v) return true;

	else while(k->next != 0)
	{
		if (k->value == v) { 
			
			k->next = first;
			first = k;
			return true;
		}
		k = k->next;
	}
	return false;

}

int main(void) { 

	Liste<int> obj;

	obj.insert(20);

	return 0;
};

Compiler meckert und sagt: C2955 Liste' use of class template requieres template argument list. Vielen Dank für Hilfe, Gruß Joeboe!

 

[joeboe]

hab das Problem schon gefixt.

vor jeder Methodendefinition muss auch

template <typename T> stehen.

 

[devDevil]

Liste<int> obj;

dann geht's

#include <iostream>
using namespace std;

template<typename T>
class List; 

template <typename _ValueType>
struct Node
{
    friend class List<_ValueType>;
    typedef _ValueType value_t;

    Node(value_t const& value = value_t(), node<_ValueType>* ptr_next = NULL)
        : m_value(value), m_next(ptr_next)
    {}
    
private:
    value_t m_value;
    node<_ValueType>* m_next;
};
 
 
template <typename T>
class List
{
    Node<T>* m_data;
    std::size_t m_size;
 
public:
    List()
        : m_size(0), m_data(NULL)
    {}
    ~List();
 
    const bool empty() const { return m_size == 0; }
    void insert(T const& value);
    const bool find(T const& value) const;
};
 
Liste<T>::~Liste() 
{
    while (m_data != NULL)
    {
        Node<T>* ptr_tmp(m_data->m_next);
        delete m_data;
        m_data = ptr_tmp;
    }
}
 
 
void Liste<T>::insert(T const& value) 
{
    if (empty()) 
    {
        m_data = new Node<T>(value);
        ++m_size;
         return;
    }
    
    if (find(value)) return;
    
    m_data->m_next = new Node<T>(value);
    m_data = m_data->m_next; 
    ++m_size;
}
 
const bool Liste<T>::find(T const& value)
{
    for (Node<T>* ptr_it(m_data); ptr_it != NULL; ptr_it = ptr_it->m_next)
        if (ptr_it->m_value == value) return true;
    return false; 
}
 
int main() 
{
    Liste<int> obj;
    obj.insert(20);
}

...