Question

我第一次尝试模块化编程时遇到了问题....

我想知道是否有人可以就如何解决问题的解决方案提出可能的方向

这是我的代码，再次来自Laszlo的计算几何书。我唯一不同的就是把它分成小块和单元头文件

守则

header.h

#ifndef NULL
#define NULL 0
#endif
#ifndef A_H
#define A_H

// -----Definition of Node Class ----------------------------------

class Node{

    protected:
        Node *_prev;
        Node * _next;
        static int cindex;


    public:
        int index;
        Node(void);
        virtual ~Node(void);
        Node *next(void); // accessor
        Node *prev(void); //accessor
        Node *insert(Node*);
        Node*remove(void);
        void splice (Node*);

    };

// ------ end of definition of Node --------------------
//======================================================
//----------Start of Definition of ListNode class ------

template < class T > class List;


template<class T> class ListNode: public Node {

    public:
        T _val;
        ListNode(T val);
        friend class List<T>;


    };

// ------ End of Definition of ListNode class --------------------
//====================================================++
//----------Start of Definition of List class ------

template<class T> class List {

    private:
        ListNode<T> *header;
        ListNode<T> *win;
        int _length;
    public:
        List(void);
        ~List(void);
        T insert(T);
        T append(T);
        T prepend(T);
        List * append(List*);
        T remove(void);
        void val(T);
        T val(void);
        T next(void);
        T prev(void);
        T first(void);
        T last(void);
        int length(void);
        bool isFirst(void);
        bool isLast(void);
        bool isHead(void);
    };









#endif

node.cpp

    #include "header.h"

    int Node::cindex=0;

    Node::Node(void) :
      _next(this), _prev(this)
      {index=cindex++;}

      Node::~Node(void) {}
      Node* Node:: next(void)
      {
        return _next;  

       } 


     Node* Node::prev(void)
      {
        return _prev;  

       } 

     Node *Node::insert(Node*b){

         b->_next=_next;
         _next->_prev=b;
         b->_prev=this;
         _next=b;
         return b;

         }

    Node*Node::remove(void)
    {

    _prev->_next=_next;
    _next->_prev=_prev;
    _next->_prev=this;
    return this;    
    }

LstNode.cpp

#include "header.h"

template <class T> List <T> :: List(void): _length(0)  //constructor for list
{
    header =new ListNode<T>(NULL); //mind you this uses the LIstNode class 
    win=header;

}

template<class T>  List <T>::~ List(void) // weird destructor
{
while (length()>0) {

    first();remove();
    }   
    delete header;

}

template <class T> T List <T> ::insert(T val)
{

win->insert( new ListNode <T> (val));
++_length;
return val;
}

template <class T> T List <T>::prepend(T val)
{   
    header->insert(new ListNode <T> (val));
    ++_length;
    return val;
}   

template <class T> T List <T>::append(T val)
{   
    header->prev()->insert(new ListNode <T> (val));
    ++_length;
    return val;
}

template<class T> List <T>* List <T>::append(List<T>*l)
{
        ListNode<T> *a =(ListNode<T>*)header->prev();
        a->splice(l->header);
        _length+=_length;
        l->header-remove();
        l->_length=0;
        l->win=header;
        return this;

}

template <class T> void List<T>::val(T v)
{
if (win!=header)
        win->_val=v;

}

template <class T> T List<T>::val(void)
{
return win->_val;   
}

template <class T> T List <T>:: next(void)
{
    win=(ListNode <T>*)win->next();
    return win->_val;

}

template <class T> T List <T>:: prev(void)
{
    win=(ListNode <T>*)win->prev();
    return win->_val;

}

template <class T> T List<T>::first(void)
{
win=(ListNode <T>*)header->next();
return win->_val;   

}

template <class T> T List<T>::last(void)
{
win=(ListNode <T>*)header->prev();
return win->_val;   

}

template <class T> int List <T>::length(void)
{
return _length; 
}

template< class T> bool List <T> ::isFirst(void)
{
    return (win==header->next()) &&(_length>0);
}

template< class T> bool List <T> ::isLast(void)
{
    return (win==header->prev()) &&(_length>0);
}

template <class T> bool List <T>::isHead(void)
{
    return (win == header);
}

experiment.cpp

#include <iostream>
#include "header.h"


int main()
{

List <int> dunder;
dunder.insert(9);
return 0;
}

问题我首先使用通用命令g++ -o file.cpp（单独）将所有这些文件转换为目标文件，然后我执行了此操作g++ output.o output2.o .. 这是我得到的错误：

experiment.o: In function `main':
experiment.cpp:(.text+0x11): undefined reference to `List<int>::List()'
experiment.cpp:(.text+0x22): undefined reference to `List<int>::insert(int)'
experiment.cpp:(.text+0x33): undefined reference to `List<int>::~List()'
experiment.cpp:(.text+0x46): undefined reference to `List<int>::~List()'
collect2: error: ld returned 1 exit status

Answer 1

您需要定义模板类，并将其定义在同一文件中。截至目前，模板类标题和定义不可分离。

首次尝试适当的模块化编程的问题

1 个答案: