C++中浅拷贝相关问题

Question

我试图了解 C++ 类的基础知识以及将一个类复制到另一个类的不同形式，我创建了一个使用表作为堆栈的简单类，并创建了用于堆叠/取消堆叠整数的简单函数 桩Int.h：

class pile_entier{
    public:
        int* p;
        int n;
        int counter;
    
    public:
        //Constructeurs & Déstructeurs
        pile_entier(int n);
        pile_entier();
        ~pile_entier();
        //Les Méthodes
        void empile(int p);
        int depile();
        int pleine();
        int vide();
    
};

pileInt.cpp：

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

pile_entier::pile_entier(int l){
    n=l;
    p=new int [n];
    counter=0;
}
pile_entier::pile_entier(){
    n=20;
    p=new int [n];  
    counter=0;
}
pile_entier::~pile_entier(){
    delete[] p;
}
int pile_entier::pleine(){
    return counter ==n;
}
int pile_entier::vide(){
    return counter==0;
}
void pile_entier::empile(int i){
    if(pleine()){
        std::cerr << "La pile est pleine !" << std::endl;
        return;
    }
    p[counter++]=i;
}
int pile_entier::depile(){
    if(vide()){
        std::cerr << "La pile est vide !" << std::endl;
        return 1;
    }
    return p[--counter];
}

主.cpp：

#include <iostream>
#include "pileInt.h"
int main(void){
    pile_entier a(10);
    a.empile(1);
    a.empile(2);
    pile_entier b = a;

    std::cout << b.depile() <<std::endl;
    std::cout << a.depile() <<std::endl;
    return 0;
}

注意：当我用法语学习时，有些术语是法语的： depile 意味着 unsatck 编译平均堆栈 堆意味着堆

因为我做了一个浅拷贝，所以两者应该共享同一个表，因此从对象 b 中取出 2 应该会影响 a ，如果取消堆叠应该给出 1 因为 2 已经被 b.depile() 取出，但在我的终端中它显示 2 2 而不是 2 1. 我不明白为什么？

Answer 1

pile_entier b = a;

您现在有两个对象，

b

和

a

。每个人都有自己的

p

，自己的

n

，还有自己的

counter

。

修改对象之一的

p

、

n

或

counter

，对另一个对象没有任何影响。它们是两个独立的对象。

std::cout << b.depile() <<std::endl;

这会修改

b

的

counter

。

std::cout << a.depile() <<std::endl;

这将修改

a

的

counter

。根本没有修改过，还是原来的样子。为什么不呢？这是一个完全不同的物体。

此外，两个对象都有相同的

p

指针。在

main()

结束时，两个对象都被销毁，并且类的析构函数将尝试两次

delete

同一个指针。这将导致未定义的行为。

您感到困惑的原因是您期望 C++ 中的对象像 Java 或 C# 中那样工作。您描述了这些对象如何在 Java 或 C# 中工作（

a

和

b

实际上都是同一个对象），但 C++ 不是 Java 或 C#，并且 C++ 中的对象以根本不同的方式工作。