C++ 分段错误：11错误

我正在尝试用虚拟节点（centinels）实现一个出列。当我试图编译时，我得到一个分段错误11。这是我的代码：（非常感谢！！）

节点h：

template <class Element>
class Node {
public:
    Node(const Node& orig);
    Node(Element e);
    const Element& getElement();
    Node<Element>* getNext() const; 
    void setNext(Node<Element> *next);
    Node<Element>* getPrevious() const;
    void setPrevious(Node<Element> *prev);
    ~Node();
private:
    Node <Element>* next;
    Node <Element>* prev;
    Element element; 


};

template <class Element>
Node<Element>::Node(Element e){
    this->element = e;
    this->next = nullptr; 
    this->prev= nullptr;
}
template <class Element>
Node<Element>::~Node(){

}
template <class Element>
const Element& Node<Element>::getElement(){
    return this->element; 
}
template <class Element>
Node<Element>* Node<Element>::getNext() const{
    return this->next;
}
template <class Element>
Node<Element>* Node<Element>::getPrevious() const{
    return this->prev;
}
template <class Element>
void Node<Element>::setNext(Node<Element>* next){
    this->next = next; 
}
template <class Element>
void Node<Element>::setPrevious(Node<Element>* prev){
    this->prev = prev; 
}

模板
类节点{
公众：
节点（常数节点和原点）；
节点（元素e）；
常量元素&getElement（）；
节点*getNext（）常量；
void setNext（节点*next）；
节点*getPrevious（）常量；
void setPrevious（节点*prev）；
~Node（）；
私人：
节点*下一步；
节点*prev；
元素；
};
样板
节点：：节点（元素e）{
这个->元素=e；
本->下一步=nullptr；
此->上一个=空PTR；
}
样板
节点：：~Node（）{
}
样板
常量元素和节点：：getElement（）{
返回此->元素；
}
样板
Node*Node:：getNext（）常量{
返回此->下一步；
}
样板
Node*Node:：getPrevious（）常量{
返回此->上一步；
}
样板
void节点：：setNext（节点*next）{
这个->下一个=下一个；
}
样板
void节点：：setPrevious（节点*prev）{
此->上一个=上一个；
}

LinkedDeque.h：

#ifndef LINKEDDEQUE_H
#define LINKEDDEQUE_H

#include "Node.h"
#include <iostream>
using namespace std;

template <class Element>
class LinkedDeque {
public:
     LinkedDeque();
    ~LinkedDeque();
    LinkedDeque(const LinkedDeque<Element>& deque);
    bool isEmpty()const;
    void insertFront(const Element & element);
    void insertRear(const Element & element);
    void deleteFront();
    void deleteRear();
    void print();
    const Element& getFront()const;
    const Element& getRear()const;
private:
    int num_elements; 
    Node<Element> *_front; 
    Node<Element> *_rear; 
    Node<Element> *frontSentinel;
    Node<Element> *rearSentinel;
};

template <class Element>
LinkedDeque<Element>::LinkedDeque(){
    //creamos nodos vacios
    _front->setNext(frontSentinel);
    _rear->setPrevious(rearSentinel); //**************
    int num_elements = 0; 

    cout << "Holi" << endl;

}

//cal implementar el constructor copia
template <class Element>
LinkedDeque<Element>::LinkedDeque(const LinkedDeque<Element>& deque){

}

template <class Element>
LinkedDeque<Element>::~LinkedDeque() {
}

template <class Element>
bool LinkedDeque<Element>::isEmpty()const{
    return (this->frontSentinel->getNext()==nullptr);   
}

template <class Element>
void LinkedDeque<Element>::insertFront(const Element & element){
    Node<Element> *new_node = new Node<Element> (element); 
    if(isEmpty()){
        rearSentinel->setPrevious(new_node);
        frontSentinel->setNext(new_node); 
    }else{
        Node<Element> *aux;
        aux = frontSentinel->getNext();
        frontSentinel->setNext(new_node);
        aux->setPrevious(frontSentinel->getNext());
        delete aux;
    }
    num_elements++;

}
template <class Element>
void LinkedDeque<Element>::insertRear(const Element & element){
    Node<Element> *new_node = new Node<Element> (element); 
    if(isEmpty()){
        rearSentinel->setPrevious(new_node);
        frontSentinel->setNext(new_node);
    }else{
        Node<Element> *aux;
        aux = rearSentinel->getPrevious();
        rearSentinel->setPrevious(new_node);
        aux->setNext(rearSentinel->getPrevious());
        delete aux;
    }
    num_elements++;
}
template <class Element>
void LinkedDeque<Element>::deleteFront(){
    if(!isEmpty()){
        if(num_elements == 1){
            delete frontSentinel->getNext();
            frontSentinel->setNext(rearSentinel);
            rearSentinel->setPrevious(frontSentinel);
        }else {
            Node<Element> *aux;
            aux = frontSentinel->getNext();
            aux->getNext()->setPrevious(frontSentinel);
            frontSentinel->setNext(aux->getNext());
            delete aux;
        }
        num_elements--;
    }
}
template <class Element>
void LinkedDeque<Element>::deleteRear(){
    if(!isEmpty()){
        if(num_elements == 1){
            delete rearSentinel->getPrevious();
            rearSentinel->setPrevious(nullptr);
            frontSentinel->getPrevious(nullptr);
        }else{
            Node<Element> *aux;
            aux = rearSentinel->getPrevious();
            aux->getPrevious()->setNext(rearSentinel);
            rearSentinel->setPrevious(aux->getPrevious());
            delete aux;
        }
        num_elements--;
    }
}
template <class Element>
void LinkedDeque<Element>::print(){
    if(!isEmpty()){
        Node<Element> *printController = frontSentinel->getNext();
        while( printController->getNext()!= nullptr){
            cout<< printController->getElement() << endl;
            printController = printController->getNext();
        }
    }
}

template <class Element>
const Element& LinkedDeque<Element>::getFront()const{
    return frontSentinel->getNext()->getElement();
}
template <class Element>
const Element& LinkedDeque<Element>::getRear()const{
    return rearSentinel->getPrevious()->getElement();
}

#endif /* LINKEDDEQUE_H */

\ifndef LINKEDDEQUE\u H
#定义LinkedQue_H
#包括“Node.h”
#包括
使用名称空间std；
样板
类LinkedQue{
公众：
LinkedDeque（）；
~LinkedDeque（）；
LinkedQue（const LinkedQue&deque）；
bool isEmpty（）常量；
void insertFront（常量元素和元素）；
空插件后部（常量元素和元素）；
void deleteFront（）；
void deleteRear（）；
作废打印（）；
常量元素&getFront（）常量；
常量元素&getRear（）常量；
私人：
int num_元素；
节点*_前面；
节点*_后方；
节点*前哨；
节点*后哨兵；
};
样板
LinkedQue:：LinkedQue（）{
//诺多斯瓦西奥斯奶油
_前->设置下一步（前哨兵）；
_后->设置前一个（后哨兵）//**************
int num_元素=0；
cout getNext（）==nullptr）；
}
样板
void linkedque:：insertFront（常量元素和元素）{
节点*新节点=新节点（元素）；
if（isEmpty（））{
rearSentinel->setPrevious（新建_节点）；
frontSentinel->setNext（新建_节点）；
}否则{
节点*aux；
aux=frontSentinel->getNext（）；
frontSentinel->setNext（新建_节点）；
aux->setPrevious（frontSentinel->getNext（））；
删除aux；
}
num_元素++；
}
样板
void LinkedQue:：insertRear（常量元素和元素）{
节点*新节点=新节点（元素）；
if（isEmpty（））{
rearSentinel->setPrevious（新建_节点）；
frontSentinel->setNext（新建_节点）；
}否则{
节点*aux；
aux=rearssentinel->getPrevious（）；
rearSentinel->setPrevious（新建_节点）；
辅助->设置下一步（后哨兵->获取上一步（）；
删除aux；
}
num_元素++；
}
样板
void linkedque:：deleteFront（）{
如果（！isEmpty（））{
if（num_元素==1）{
删除frontSentinel->getNext（）；
前哨兵->设置下一步（后哨兵）；
rearSentinel->setPrevious（frontSentinel）；
}否则{
节点*aux；
aux=frontSentinel->getNext（）；
aux->getNext（）->setPrevious（frontSentinel）；
frontSentinel->setNext（辅助->getNext（））；
删除aux；
}
num_元素--；
}
}
样板
void linkedque:：deleteRear（）{
如果（！isEmpty（））{
if（num_元素==1）{
删除rearSentinel->getPrevious（）；
rearSentinel->setPrevious（nullptr）；
frontSentinel->getPrevious（nullptr）；
}否则{
节点*aux；
aux=rearssentinel->getPrevious（）；
aux->getPrevious（）->setNext（后哨兵）；
rearSentinel->setPrevious（辅助->getPrevious（））；
删除aux；
}
num_元素--；
}
}
样板
void linkedque:：print（）{
如果（！isEmpty（））{
节点*printController=frontSentinel->getNext（）；
while（printController->getNext（）！=nullptr）{
coutgetElement（）获取下一步（）；
}
}
}
样板
常量元素&LinkedQue:：getFront（）常量{
返回frontSentinel->getNext（）->getElement（）；
}
样板
常量元素&LinkedQue:：getRear（）常量{
返回rearSentinel->getPrevious（）->getElement（）；
}
#endif/*LINKEDDEQUE_H*/

最后，main.cpp：

#include <cstdlib>
#include"Node.h"
#include"LinkedDeque.h"
using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {
    LinkedDeque<int> *deque= new LinkedDeque<int>;
    deque->insertFront(4);
    deque->insertFront(5);
    deque->insertRear(10);
    deque->deleteFront();
    deque->print();

}

#包括
#包括“Node.h”
#包括“LinkedDeque.h”
使用名称空间std；
/*
* 
*/
int main（int argc，字符**argv）{
LinkedQue*deque=新LinkedQue；
deque->insertFront（4）；
deque->insertFront（5）；
deque->insertRear（10）；
deque->deleteFront（）；
deque->print（）；
}

---

也许我不应该实现Node的析构函数，而去虚拟化它？或者指针声明有一些错误？

我猜您的LinkedQue构造函数模板正在访问无效的前后指针

template <class Element>
LinkedDeque<Element>::LinkedDeque(){
    //creamos nodos vacios
    _front->setNext(frontSentinel); //*_front has not been initialized and contains undefined values*
    _rear->setPrevious(rearSentinel); //**************
    int num_elements = 0; 

    cout << "Holi" << endl;

}

模板
LinkedQue:：LinkedQue（）{
//诺多斯瓦西奥斯奶油
_front->setNext（frontSentinel）；//*\u front尚未初始化，并且包含未定义的值*
_后->设置前一个（后哨兵）//**************
int num_元素=0；
cout您可以使用
new Node（NULL）；
构造哨兵，这样您的
linkedque
就有
Node
对象用作哨兵，而不是
nullptr
。从以下方法的这些更改开始：

template <class Element>
LinkedDeque<Element>::LinkedDeque(){
    //creamos nodos vacios
    frontSentinel = new Node<Element>(NULL);
    rearSentinel  = new Node<Element>(NULL);
    rearSentinel->setPrevious(frontSentinel);
    frontSentinel->setNext(rearSentinel);
    int num_elements = 0;

    cout << "Holi" << endl;
}
template <class Element>
bool LinkedDeque<Element>::isEmpty()const{
    return this->frontSentinel->getNext()->getElement()==NULL;
}

template <class Element>
void LinkedDeque<Element>::insertFront(const Element & element){

    Node<Element> *new_node = new Node<Element>(element); 
    new_node->setNext(frontSentinel->getNext());
    frontSentinel->getNext()->setPrevious(new_node);
    new_node->setPrevious(frontSentinel);
    frontSentinel->setNext(new_node);

    num_elements++;
}

template <class Element>
void LinkedDeque<Element>::insertRear(const Element & element){

    Node<Element> *new_node = new Node<Element> (element); 
    new_node->setPrevious(rearSentinel->getPrevious());
    rearSentinel->getPrevious()->setNext(new_node);
    new_node->setNext(rearSentinel);
    rearSentinel->setPrevious(new_node);

    num_elements++;
}

template <class Element>
void LinkedDeque<Element>::deleteFront(){

    Node<Element> *aux = frontSentinel->getNext();
    aux->getNext()->setPrevious(frontSentinel);
    frontSentinel->setNext(aux->getNext());
    delete aux;

    num_elements--;
}

template <class Element>
void LinkedDeque<Element>::deleteRear(){

    Node<Element> *aux = rearSentinel->getPrevious();
    aux->getPrevious()->setNext(rearSentinel);
    rearSentinel->setPrevious(aux->getPrevious());
    delete aux;

    num_elements--;
}

template <class Element>
void LinkedDeque<Element>::print(){
    Node<Element> *printController = frontSentinel->getNext();
    while (printController->getElement() != NULL) {
        cout << printController->getElement() << endl;
        printController = printController->getNext();
    }
}

模板
LinkedQue:：LinkedQue（）{
//诺多斯瓦西奥斯奶油
frontSentinel=新节点（空）；
rearSentinel=新节点（空）；
rearSentinel->setPrevious（frontSentinel）；
前哨兵->设置下一步（后哨兵）；
int num_元素=0；
cout getNext（）->getElement（）==NULL；
}
样板
void linkedque:：insertFront（常量元素和元素）{
节点*新节点=新节点（元素）；
新建节点->设置下一步（frontSentinel->获取下一步（））；
frontSentinel->getNext（）->setPrevious（新节点）；
新建节点->设置前一个（frontSentinel）；
frontSentinel->setNext（新建_节点）；
num_元素++；
}
样板
void LinkedQue:：insertRear（常量元素和元素）{
节点*新节点=新节点（元素）；