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

Question

Shallow Copy : When we initalize one object with another then the compiler copies state of one object to the other using copy constructor by assigning data member values of previous object to newly created object.

Problem in Shallow Copy

• Dangling Pointer (Pointer pointing to incorrect memory location).
• Update data on that memory location.

In Copy constructor two objects points to the same memory location and then the above two problem can take place. I have studied that these two problem take place when memory is allocated dynamically . if not dynamic memory is involved then it works fine.

Question: My question is if static memory is allocated to an object at compile time, and at run time on by performing some event i initialize another object from that object who have already assigned memory statically. Then also same problem will come or not? if not why and how? The memory location is same to which both objects are pointing. Then why Dangling Pointer problem will not come.

Answer 1

My question is if static memory is allocated to an object at compile time, and at run time on by performing some event i initialize another object from that object who have already assigned memory statically. Then also same problem will come or not? if not why and how?

you will have two objects with pointers pointing to the same instance, so both will modify the same object. The problem with dynamic memory allocation is that it must be at some point released, so if one object releases it then the second will release already freed memory - which is Undefined Behaviour. So with static object case, there is no problem with "dangling pointer", because you cannot release its memory (and should not try), so you will not have UB.

Answer 2

In Copy constructor two objects points to the same memory location and then the above two problem can take place. I have studied that these two problem take place when memory is allocated dynamically. if not dynamic memory is involved then it works fine.

This isn't strictly true (though it would be a rare problem):

#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;
}

My question is if static memory is allocated to an object at compile time, and at run time on by performing some event i initialize another object from that object who have already assigned memory statically. Then also same problem will come or not? if not why and how?

You'll still have the same problem of

Update data on that memory location.

#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;
}