有人知道c++的访问权限冲突是什么情况吗

Question

pta上面的一元多项式相加题目，用链表实现遇到了一些问题

#include <iostream>

using namespace std;

struct Node {
    int pow;
    int cof;
    struct Node* next;
};

typedef struct Node* node;

node gettail(node list) {
    node tail = list;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    return tail;
}

void inserttail(node list, int pow, int cof) {
    node tail = gettail(list);
    node newtail = new struct Node;
    newtail->pow = pow;
    newtail->cof = cof;
    newtail->next = tail->next;
    tail->next = newtail;
}

node createlist() {
    node list = new struct Node;
    list->next = NULL;
    int pow, cof;
    while (1) {
        cin >> pow >> cof;
        if (pow == -1 && cof == -1) {
            break;
        }
        inserttail(list, pow, cof);
    }
    return list;
}

node delete_zerocof(node list) {
    node dummy = new struct Node;
    dummy->next = list;
    while (dummy->next != NULL) {
        if (dummy->next->cof == 0) {
            node deleted = dummy->next;
            dummy->next = deleted->next;
            free(deleted);
        }
        else {
            dummy = dummy->next;
        }
    }
    if (list == NULL) {
        node zero = new struct Node;
        zero->cof = 0;
        zero->pow = 0;
        zero->next = list;
        return zero;
    }
    else {
        return  list;
    }
}

node addcof(node list) {
    node p = list;
    while (p->next != NULL) {
        if (p->next->pow == p->pow) {
            node deleted = p->next;
            p->cof += deleted->cof;
            p->next = deleted->next;
            free(deleted);
        }
        else {
            p = p->next;
        }
    }
    node LIST=delete_zerocof(list);
    return LIST;
}

node merge(node list1, node list2) {
    node list = new struct Node;
    node dummy = list;
    node L1 = list1->next;
    node L2 = list2->next;
    while (L1 != NULL && L2 != NULL) {
        if (L1->pow > L2->pow) {
            list->next = L1;
            L1 = L1->next;
        }
        else {
            list->next = L2;
            L2 = L2->next;
        }
        list = list->next;
    }
    if (L1 != NULL) {
        list->next = L1;
    }
    else if (L2 != NULL) {
        list->next = L2;
    }
    return addcof(dummy->next);
}

void showpure(node list) {
    node p = list;
    while (p != NULL) {
        cout << p->cof << "x" << p->pow << " ";
        p = p->next;
    }
}

void show(node list) {
    bool isFirst = true;
    bool hasNonZero = false;
    if (list == NULL) {
        cout << 0;
    }
    while (list != NULL) {
        if (list->cof != 0) {
            hasNonZero = true;
            if (list->cof > 0 && !isFirst) {
                cout << "+";
            }
            if (list->pow == 0) {
                cout << list->cof;
            }
            else if (list->pow == 1) {
                if (list->cof == 1) {
                    cout << "x";
                }
                else if (list->cof == -1) {
                    cout << "-x";
                }
                else {
                    cout << list->cof << "x";
                }
            }
            else {
                if (list->cof == 1) {
                    cout << "x" << list->pow;
                }
                else if (list->cof == -1) {
                    cout << "-x" << list->pow;
                }
                else {
                    cout << list->cof << "x" << list->pow;
                }
            }
        }
        isFirst = false;
        list = list->next;
    }

    if (!hasNonZero) {
        cout << "0";
    }
}

int main()
{
    node list1 = createlist();
    node list2 = createlist();
    node list = merge(list1, list2);
    show(list);
    //showpure(list);

    return 0;
}

Answer 1

让 “紫雾凌寒” 来帮你回答,本回答结合 DeepSeek

如果还有问题，请评论或点击头像私信，如果有帮助到您, 请关注、采纳、点赞

1. 关键点分析：
   - 从给出的代码片段来看，目前只定义了Node结构体，但结构体成员in的类型不完整，这可能会影响后续链表操作的正确性。
   - 关于访问权限冲突，在链表操作中可能出现的情况有：
   • 试图访问未初始化的指针成员。
   • 对链表节点进行非法的内存访问，比如访问已经释放的节点。
   • 对节点成员的访问权限设置不当，例如在一些函数中试图访问私有成员却没有相应的权限。
2. 解决方案：
   - 首先完善Node结构体定义。假设Node结构体有系数coef和指数exp两个成员，并且有指向下一个节点的指针next：

struct Node {
    int coef;
    int exp;
    Node* next;
};

• 实现多项式相加的函数。以下是一个简单的示例：

Node* addPolynomials(Node* poly1, Node* poly2) {
    Node dummy(0, 0, nullptr);
    Node* tail = &dummy;
    while (poly1 && poly2) {
        if (poly1->exp > poly2->exp) {
            tail->next = poly1;
            poly1 = poly1->next;
        } else if (poly1->exp < poly2->exp) {
            tail->next = poly2;
            poly2 = poly2->next;
        } else {
            int newCoef = poly1->coef + poly2->coef;
            if (newCoef != 0) {
                poly1->coef = newCoef;
                tail->next = poly1;
                poly1 = poly1->next;
            } else {
                delete poly1;
                delete poly2;
            }
            poly1 = poly1->next;
            poly2 = poly2->next;
        }
        tail = tail->next;
    }
    tail->next = poly1? poly1 : poly2;
    return dummy.next;
}

• 在主函数中使用上述函数进行测试：

int main() {
    // 构建多项式1
    Node* poly1 = new Node{2, 3, nullptr};
    poly1->next = new Node{3, 2, nullptr};
    poly1->next->next = new Node{4, 1, nullptr};

    // 构建多项式2
    Node* poly2 = new Node{3, 3, nullptr};
    poly2->next = new Node{2, 2, nullptr};

    Node* result = addPolynomials(poly1, poly2);

    // 输出结果
    while (result) {
        cout << result->coef << "x^" << result->exp << " ";
        Node* temp = result;
        result = result->next;
        delete temp;
    }
    cout << endl;

    return 0;
}

1. 多种解决方案优缺点：
   - 优点：
   • 上述实现方式逻辑清晰，通过比较指数来合并同类项，代码简洁明了。
   • 缺点：
   • 在处理完节点后需要手动释放内存，容易出现内存泄漏问题，如果在释放节点后没有及时将指针置为nullptr，还可能导致野指针错误。
   • 可以考虑使用智能指针来管理节点内存，这样能避免手动释放内存带来的问题。例如将Node结构体中的指针成员改为智能指针类型：

struct Node {
    int coef;
    int exp;
    std::unique_ptr<Node> next;
};

• 使用智能指针的优点：
  • 自动管理内存，避免内存泄漏和悬空指针问题。
• 使用智能指针的缺点：
  • 引入了新的头文件<memory>，可能增加编译时的依赖。并且在一些编译器环境下可能会增加一定的运行时开销，不过在现代编译器优化下这种开销通常较小。
    4. 总结：
• 访问权限冲突在链表操作中主要源于对节点内存和成员访问的不当处理。通过正确定义结构体、合理编写操作函数以及注意内存管理（如使用智能指针），可以有效避免访问权限冲突等问题，实现正确的多项式相加功能。

以上代码在C++ 11及以上标准下编译运行，不同编译器可能会有一些细微差异。如果在实际运行中遇到问题，可以根据编译器的错误提示进一步排查。

希望以上解答对您有所帮助。如果您有任何疑问，欢迎在评论区提出。