C++ 静态内存分配中的浅拷贝构造函数问题？

浅层复制：

当我们用一个对象初始化另一个对象时，编译器使用复制构造函数将一个对象的状态复制到另一个对象，方法是将前一个对象的数据成员值分配给新创建的对象。

浅拷贝问题

• 悬空指针（指向错误内存位置的指针）
• 更新该内存位置上的数据

在Copy constructor

中，两个对象

指向相同的

内存位置

，然后可能会出现上述两个问题。我已经研究过这两个问题发生在动态分配

内存时。如果不涉及
动态内存
，则其工作正常

问题：
我的问题是，静态内存是否在编译时分配给对象，而在运行时，通过执行某个事件，我从已经静态分配内存的对象初始化另一个对象。那么同样的问题会不会出现呢？如果不是，为什么和如何？两个对象所指向的内存位置相同。那么为什么悬挂指针的问题就不会出现了

我的问题是，静态内存是否在编译时分配给对象，而在运行时，通过执行某个事件，我从已经静态分配内存的对象初始化另一个对象。那么同样的问题会不会出现呢？如果不是，为什么和如何

您将拥有两个指针指向同一实例的对象，因此这两个对象都将修改同一对象。动态内存分配的问题是，它必须在某个点释放，因此如果一个对象释放它，那么第二个对象将释放已经释放的内存—这是未定义的行为。因此，对于静态对象的情况，“悬空指针”没有问题，因为您无法释放它的内存（并且不应该尝试），所以您将没有UB

在复制构造函数中，两个对象指向相同的内存位置，然后上述两个问题就会发生。我已经研究过这两个问题发生在动态分配内存时。如果不涉及动态内存，那么它可以正常工作

严格来说，这不是事实（尽管这是一个罕见的问题）：

#包括
使用名称空间std；
课例
{
公众：
示例（int*const in）：p{in}{
int value（）常量{return*p；}
int值（const int v）const{*p=v；返回*p；}
私人：
int*p；
};
静态int a=5；
静态示例第一{&a}；
//'first'现在有一个指向'a'的指针`
静态示例第二=第一；
//现在'first'和'second'持有指向同一静态内存的指针
int main（）
{
//输出`正确`
你能用样例代码演示你的问题吗？现在，请写100次“我不会为C++问题添加C标记”对象不指向任何地方，因为它不是指针。但是，您可能有一个指向对象的指针或引用，或者一个指针成员。在静态对象的情况下，两者都指向同一个实例，因此如果一个修改，第二个也将获得修改的值…？我说得对吗…？内存位置相同…？然后
悬空指针de>如果静态对象指向同一实例，问题也会发生…？？@ShahidIqbal否，您的指针将始终有效，指向静态内存的指针不能由
删除
使用，因此您的指针将始终有效。在动态内存情况下，您可以在一个对象的析构函数中释放内存，但另一个对象没有idea关于它，并且在某一点上也使用相同的指针释放—在这一点上是悬挂指针—它指向无效内存。另外：
静态内存在编译时分配给对象
—不是安静的，不是分配的，而是保留的。让我们来看看。
#include <iostream>

using namespace std;

class Example
{
public:
    Example(int * const in) : p{in} {}

    int value() const { return *p; }
    int value(const int v) const { *p = v; return *p; }

private:
    int * p;
};

static int a = 5;
static Example first{&a};
// `first` now holds a pointer to `a`
static Example second = first;
// Now `first` and `second` hold pointers to the same static memory

int main()
{
    // Outputs `true`
    cout << boolalpha << (first.value() == second.value()) << endl;

    first.value(7);

    // Because they point to the same memory, this will output `true`
    cout << boolalpha << (first.value() == second.value()) << endl;
}

#include <iostream>

using namespace std;

class Example
{
public:
    Example(int * const in) : p{in} {}

    int value() const { return *p; }
    int value(const int v) const { *p = v; return *p; }

private:
    int * p;
};

static int a = 5;
static Example first{&a};
// `first` now holds a pointer to `a`

int main()
{
    Example * second = new Example(first); // implicit copy constructor
    // Now `first` and `second` hold pointers to the same static memory,
    // though `second` is allocated dynamically

    // Outputs `true`
    cout << boolalpha << (first.value() == second->value()) << endl;

    first.value(7);

    // Because they point to the same memory, this will still output `true`
    cout << boolalpha << (first.value() == second->value()) << endl;
}