Trung tâm cá nhân
cuốn sách gpt4 ai đã làm

Tự do nhân đôi hoặc tham nhũng (ra) C++

In lại Tác giả: Walker 123 Thời gian cập nhật: 28-11-2023 00:23:15 29 4
mua khóa gpt4 Nike

Tôi biết rằng lỗi kép hoặc lỗi tham nhũng thường là vi phạm của 3 lỗi lớn, nhưng trong trường hợp này tôi không thể tìm thấy vi phạm xảy ra ở đâu. Tôi có một hàm tạo bản sao, hàm hủy và toán tử gán cho bất kỳ thứ gì liên quan đến con trỏ.

Trong .h của tôi, đây là cách triển khai lớp của tôi:

lớpBST
{
công cộng:
    cấu trúc SequenceMap{
        std::string chuỗi;
        chuỗi std::vector;

        //void setValue(std::string theString, std::string anotherString);
        SequenceMap& operator=(const bản đồ SequenceMap);

        void setValue(std::string theString, std::string anotherString);

        SequenceMap(); // hàm tạo không có bản sao vì không có con trỏ
        ~Bản đồ tuần tự();
    };
    cấu trúc mã nhị phân{
        Mục SequenceMap;
        Mã nhị phân *trái;
        Mã nhị phân *phải;
        BinaryNode(SequenceMap i); // hàm tạo

        toán tử bool nội tuyến> (std::string t);
        toán tử bool nội tuyến< (std::string t);

        BinaryNode& operator=(const nút BinaryNode);
        ~Nút nhị phân();
        BinaryNode(const BinaryNode &otherNode);
    };
    Mã nhị phân *gốc;
    int Insert(SequenceMap &x, BinaryNode *&t, bool &ifdup);

    BST();
    ~BST();
    void BSTClear(BST::BinaryNode *t);
    BST(const BST &otherTree);

    BST& toán tử=(const cây BST);
};

Tôi đã triển khai hàm tạo, hàm hủy và toán tử gán trong .cpp của mình:

BST::SequenceMap& BST::SequenceMap::operator=(const BST::Bản đồ SequenceMap) 
{
    chuỗi = map.astring;
    trình tự = map.sequences;
    trả lại *cái này;
}

bool nội tuyến BST::BinaryNode::operator<(std::string t){//không so sánh}
bool nội tuyến BST::BinaryNode::operator>(std::string t){//không so sánh}

BST::BinaryNode& BST::BinaryNode::operator=(const BST::nút BinaryNode) 
{
    mục = nút.item;
    if(node.left != nullptr)
        trái = BST mới::BinaryNode(node.left->item);
    khác
        trái = nullptr;
    if(node.right != nullptr)
        right = BST mới::BinaryNode(node.right->item);
    khác
        đúng = nullptr;

    trả lại *cái này;
}
BST& BST::operator=(const BST tree){root = new BinaryNode(tree.root);}

BST::BinaryNode::BinaryNode(const BST::BinaryNode &otherNode){
    item = otherNode.item;  
    if(otherNode.left != nullptr)
        left = new BST::BinaryNode(otherNode.left->item);
    khác
        trái = nullptr;
    if(otherNode.right != nullptr)
        right = new BST::BinaryNode(otherNode.right->item);
    khác
        đúng = nullptr;
}

BST::BinaryNode::BinaryNode(SequenceMap i){ item = i; left = nullptr; phải = nullptr }
BST::BinaryNode::~BinaryNode(){ xóa &item; left = nullptr; right = nullptr }

BST::BST(){root = nullptr;}
BST::BST(const BST &otherTree){root = new BinaryNode(otherTree.root->item);}
BST::~BST(){BSTClear(root);}

BST::SequenceMap::SequenceMap(){astring = "";}
BST::SequenceMap::~SequenceMap(){ xóa &astring; xóa &sequences;}

void BST::BSTClear(BST::BinaryNode*t){
    if(t->left != nullptr)
        BSTClear(t->left);
    if(t->right != nullptr)
        BSTClear(t->right);      
    xóa t;
}

tôi sử dụng cout Để kiểm tra lỗi xảy ra ở đâu, lỗi xảy ra khi tôi thực hiện việc này trên dòng được chỉ định trong main.cpp của mình:

while(getline(trình tự,trình tự) && getline(enzym,enzim))
{
    BST::Bản đồ SequenceMap = BST::SequenceMap;
    bản đồ->setValue(trình tự, enzyme);

    SequenceTree->insert(map, SequenceTree->root, dup); // TRÊN DÒNG NÀY
}

Chèn hàm vào .cpp của tôi:

int BST::insert(BST::SequenceMap &x, BST::BinaryNode *&t, bool &ifdup )
{
    nếu(t == nullptr)
    {
        //std::cout<<"2"<
        t = new BST::BinaryNode(x); //TRÊN DÒNG NÀY  
        //std::cout<<"1"<<>
    }
    //làm nhiều việc hơn
 }

Tôi không chắc liệu đây có được coi là MSCV hay không, nhưng ít nhất tôi cần tái tạo lại lỗi của mình. Dấu vết ngăn xếp

câu trả lời hay nhất

xem xét của bạn Nút nhị phân toán tử gán.

BST::BinaryNode& BST::BinaryNode::operator=(const BST::nút BinaryNode) 
{
    mục = nút.item;
    if(node.left != nullptr)
        left = node.left;
    khác
        trái = nullptr;
    if(node.right != nullptr)
        đúng = nút.right;
    khác
        đúng = nullptr;

    trả lại *cái này;
}

cuối cùng bạn sẽ nhận được Nút nhị phân Hai trường hợp của bên trái Và Phải Con trỏ trỏ đến điều tương tự. Khi hàm hủy của cả hai phiên bản được gọi, cả hai đều giải phóng con trỏ và gây ra sự tự do gấp đôi.

Những gì bạn cần làm thực sự là tạo một bản sao mới giá trị phụ thuộc vào bên trái Và Phải Con trỏ trỏ tới, thay vì con trỏ , hoặc có một loại con trỏ được tính tham chiếu nào đó.

Cũng lưu ý: nếu giá trị ban đầu là nullptr

, bài kiểm tra if của bạn sẽ không thêm bất kỳ giá trị nào vì bạn chỉ gán nullptr

Về C++ - C++ miễn phí gấp đôi hoặc bị hỏng (ngoài), chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/26417088/

29 4 0
Đề xuất bài viết: css - Cách điều khiển hiển thị hộp văn bản
Đề xuất bài viết: html - Chỉ số trên thay đổi chiều cao của dòng
Đề xuất bài viết: html - Làm cách nào để hiển thị hình nền trong td thay vì văn bản?
Đề xuất bài viết: Các phần tử HTML không được xếp chồng chính xác trong khung 'Bootstrap' của Twitter
Walker 123
Hồ sơ

Tôi là một lập trình viên xuất sắc, rất giỏi!

Nhận phiếu giảm giá taxi Didi miễn phí
Phiếu giảm giá taxi Didi
Các bài viết phổ biến trên toàn bộ trang web
Chứng chỉ ICP Bắc Kinh số 000000
Hợp tác quảng cáo: 1813099741@qq.com 6ren.com
Xem sitemap của VNExpress