collect2：错误：ld返回1退出状态make：*** [makefile：2：main]错误1 Download

LinkedList.h

#define LINKEDLIST_H
#include "iterator.h"

namespace fhdo_pk2{
template <typename T= char*>//T = char*Klassen-Template mit Defaultargumenten
class LinkedList{ 

private:
  struct element
  {
     T key;
    element *next;
    element( T key, element *next);
    //vom zak kopiert
    element(T key) : key{key}, next{nullptr}{ }
    //vom zak kopiert
  };
  element *start;
  element *end;

  //Innere Klasse : ListIterator dek und imp(inline)
  class ListIterator : public Iterator<T>{
  private:
    element* head;

  public:
    ListIterator(element* head) : head{head} {}

    inline bool hasNext() override{
      return head;
    }

    inline  T next() override{
       T tmp = head->key;
      head = head->next;
      return tmp;
    }
  };

public:
  LinkedList();
  LinkedList(const LinkedList &org);
  ~LinkedList();

  int append( T key);
  int insert( T key, int pos);
  int remove(int pos);
   T get(int pos);
  int index_of( T key);
   T first();
   T last();
  void visit_all(void (*work)( T t));

  Iterator<T>* iterator();
};
} // namespace fhdo_pk2
#endif

Iterator.h

#define ITERATOR_H
namespace fhdo_pk2{
 template <typename T> class Iterator{
  public:
    virtual ~Iterator(){}
    virtual bool hasNext()=0;
    virtual T next()=0;
  };
}
#endif

linkedList.cpp

#include "linkedList.h"
#include "iterator.h"
#include <iostream>

using namespace fhdo_pk2;

template <typename T> LinkedList<T>::LinkedList() : start{nullptr},end{nullptr}{}

template <typename T> LinkedList<T>::LinkedList(const LinkedList &org) : LinkedList{} {
  element *it = org.start;
  while(it!=nullptr){
    this->append(it->key);
    it=it->next;
  }
}

template <typename T> LinkedList<T>::element::element ( T key, element *next) : key(key) , next(next){}

template <typename T> LinkedList<T>::~LinkedList(){
  while(remove(0));
}


template<typename T> Iterator<T> *LinkedList<T>::iterator(){
  Iterator<T> *it= new ListIterator(start);
  return it;
}


template <typename T> int LinkedList<T>::append( T key){

  element *tmp = new element (key,nullptr);

  if(tmp == nullptr){
    std::cout<<"Fehler bei Erzeugung von elemnet funktion Append"<<std::endl;
    return 0;
  }

  //sonderfall list leer

  if(start == nullptr){
    start = (end=tmp);
  }
  else{
    end->next = tmp;
    end = end->next;
  }

  return 1;
}

template<typename T> int LinkedList<T>::insert( T key, int pos){

  //sonderfall list leer
  if(start == nullptr){
    return append(key);
  }

  element *one = new element(key,nullptr);
  if(one == nullptr){
    std::cout<<"Fehler bei Erzeugung von elemnet funktion insert"<<std::endl;
    return 0;
  }
  //sonderfall am anfang einfuegen
  if(pos==0){
    one->next = start;
    start = one;
    return 1;
  }

  //fuege an der Stelle it->next ein
  element *prv = nullptr;
  element *it = start;
  while(pos-->0 && it!=nullptr ){
    prv = it;
    it=it->next;
  }

  //pos ist gorßer als die elemente anzahl
  if(it==nullptr){
    it=one;
    end=it;    
    prv->next=it;
    return 1;
  }

  prv->next = one;
  one->next = it;

  if(it==nullptr)
    end=it;

  return 1;
}

template<typename T> int LinkedList<T>::remove(int p){
  //sonderfall pos negativ
  if(p<0){
    std::cout<<"Fehler bei Loeschen pos<0 funktion remove"<<std::endl;
    return 0;
  }

  //sonderfall list leer
  if(start == nullptr){
    std::cout<<"Fehler bei Loeschen list ist leer funktion remove"<<std::endl;
    return 0;
  }

  element *it = start;
  //sonderfall am anfang loeschen
  if(p==0){
    start = it->next;
    delete it;
    return 1;
  }

  //loesch it
  element *prv=nullptr;
  while((p--)>0 && it->next!=nullptr ){
    prv = it;
    it = it->next;
  }
  if(it->next == nullptr){
    if(prv!=nullptr){
      prv->next = nullptr;
    }else{
      start=it->next;   
    }
    end = prv;
    delete it;
    return 1;
  }

  prv->next = it->next;
  delete it;

  return 1;
}

template<typename T> T LinkedList<T>::get(int p){

  //sonderfall pos negativ
  if(p<0){
    std::cout<<"Fehler bei Loeschen pos<0 funktion *get"<<std::endl;
    return nullptr;
  }

  //sonderfall list leer
  if(start == nullptr){
    std::cout<<"Fehler bei Loeschen list ist leer funktion *get"<<std::endl;
    return nullptr;
  }

  //it
  element *it = start;
  while(p>0 && it!=nullptr){
    it=it->next;
    p--;
  }
  return it->key;
}

template<typename T> int LinkedList<T>::index_of( T key){

  //sonderfall list leer
  if(start == nullptr){
    std::cout<<"Fehler bei index finden list ist leer funktion index_of"<<std::endl;
    return -1;
  }
  int pos = 0;
  element *it = start;
  while(it!=nullptr){
    if(it->key == key)
      return pos;
    it = it->next;
    pos++;
  }

  return -1;
}

template<typename T>  T LinkedList<T>::first(){

  //sonderfall list leer
  if(start == nullptr){
    std::cout<<"Fehler beim finden list ist leer funktion first"<<std::endl;
    return nullptr;
  }

  return start->key;
}

template<typename T>  T LinkedList<T>::last(){

  //sonderfall list leer
  if(start == nullptr){
    std::cout<<"Fehler beim finden list ist leer funktion last"<<std::endl;
    return nullptr;
  }

  return end->key;
}

template<typename T> void LinkedList<T>::visit_all(void (*work)( T t)){
  element *it=start;
  while(it!=nullptr){
    work(it->key);
    it=it->next;
  }
}

main.cpp

#include <iostream>
#include "linkedList.h"
#include "iterator.h"
template<typename T>
void ausgabe( T text){
  cout << text << endl;
}
// Test der LinkedList-Klasse

int main(){
using namespace std;
using namespace fhdo_pk2;
  LinkedList<char*> liste;

  liste.append("Element 1");
  liste.insert("Element 2", 2);

  cout << "it" << endl;
 Iterator<char*> *it=liste.iterator();
 while(it->hasNext()){
    ausgabe(it->next());
    //zeiger braucht auch das -> um eine func aufzurufen
  }
  cout << "it" << endl;
  LinkedList<char*> liste2 = liste;
  cout << "Liste:" << endl;
  liste.visit_all(ausgabe);
  liste.remove(2);
  cout << "Liste:" << endl;
  liste.visit_all(ausgabe);
  cout << "Liste2:" << endl;
  liste2.visit_all(ausgabe);
  return 0;
}

makefile

main: linkedList.o main.cpp linkedList.h iterator.h
    g++ main.cpp -o main linkedList.o -std=c++11
linkedList.o: linkedList.cpp iterator.h
    g++ -c linkedList.cpp -std=c++11
clean:
    rm main *.o

photo one

photo two

0 个答案: