Deep copy and Shadow copy

@Leeto · Регистрация: 23.12.2011

Студворк — интернет-сервис помощи студентам

Этот проект компилируется нормально. И функциональность всех элементов на первый взгляд нормальная.
ПРОБЛЕМА: Надо сделать нормально = оператор и копи конструктор.
Вообщем где или кто и как то я услышал (не важно ) что есть такое понятие как shadow copy and deep copy. Типа вроде как если имплиминтировать как я сделал, то

C++
1
2
// from Array. cpp
m_size = source.m_size;                             // shallow copy - this is not dynamic alloc

Это получается shallow copy и вроде как если я меняю объект с которого копировали то и скопированный объект тоже изменется в этой дате. Я не знаю на сколько это правда или нет. Сдалал пробник попробовал переназначить размер массива и компелятор меня на пропустил...
Вообщем, моя проблема в том, что я сомневаю правильно ли я сдалал копирование m_size даты. Пожалуйста, помогите мне разобраться.

У меня возникла идея вот такой имплиментации насколько она корректна не знаю, оцените пожалуйста
Было

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Array& Array::operator = (const Array& source)
        {
            
 
            std::cout << " In the Array Assignment operator\n";
 
            if (this == &source)
                {
                std::cout << "Same Array \n"; 
                return *this;
                }
 
            delete [] m_data;
            std::cout << "Deleted m_data array\n";
 
            m_size = source.m_size;                             // shallow copy - this is not dynamic alloc
 
            if (source.m_data)                                  // if not zeros then there is a ref.
            {
                std::cout <<"im here\n"; 
 
                m_data = new Point[source.m_size];              // create a new pointee.
 
                for (int i = 0; i < source.m_size; i++)
                    m_data[i]    =    source.m_data[i];         //copy the points from/to array
            }
            else
                m_data = 0;  //NULL
 
            return *this;
        }

Стало

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Array& Array::operator = (const Array& source)
        {
            
 
            std::cout << " In the Array Assignment operator\n";
 
            if (this == &source)
                {
                std::cout << "Same Array \n"; 
                return *this;
                }
 
            delete [] m_data;
            std::cout << "Deleted m_data array\n";
 
                                            // shallow copy - this is not dynamic alloc
 
            if (m_size)                             // if not zeros then there is a ref.
            {
                std::cout <<"im here\n"; 
 
                m_data = new Point[m_size];             // create a new pointee.
 
                for (int i = 0; i < m_size; i++)
                    m_data[i]    =    source.m_data[i];         //copy the points from/to array
            }
            else
                m_data = 0;  //NULL
 
            return *this;
        }

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//array.hpp // A header file for the Array class to your current project.
#ifndef Array_HPP
#define Array_HPP
 
#include "Point.hpp"
#include <iostream>
 
 
class Array
{
private:    
 
    Point* m_data;                  // A data member for a dynamic C array of Point objects (Point* m_data).
    int m_size;                     // A data member for the size of the array.
 
 
public: 
 
    //----------- Declaration of Constructors -----------//
    Array::Array();                         // Default constructor
    Array::Array(const int new_size);       // Constructor with size argument.
    Array::Array(const Array& ar);          // Copy constructor
    Array::~Array();                        // Destructor
 
 
    //----------- Declaration of Accessors member functions -----------//
    int Array::Size() const;                                // Get the data of m_size 
    Point& GetElement(int index) const;                     // Return a Element(Point* m_data) by given index of a Array object
    
 
    //----------- Declaration of Modificator(s) member functions -----------//
    void   SetElement(const Point& pt, int index);          // Set Element to a Array object
 
 
    //----------- Declaration of Operators Overloading the class's members -----------//
    Array& operator =  (const Array& source);               // Overloading Assignment operator.
    Point& operator [] (int index);                         // Return a reference to needed m_data. Using for writing 
//  const Point& operator [] (int index) const ;            // Return a reference to needed m_data. Using for reading
 
 
    //----------- Declaration of Global (friend) Ostream << Operator  -----------//
    friend std::ostream& operator << (std::ostream& os, const Array& ar);           // Overloading << operator
 
}   /*!!!*/; /*!!!*/
#endif // Array_HPP

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#ifndef Point_HPP // anti multiply including gates
#define Point_HPP
 
#include <string>
#include <iostream>
#include <sstream>
 
 
class Point
{   
    private:        //  declaration of private data members 
    double x;       // X coordinate
    double y;       // Y coordinate
 
    public:         // public declaration of data members (in given example haven't ) and member functions 
 
 
        //----------- Declaration of Constructors -----------//
    Point();                                        // Default constructor
    Point(double newX , double newY);               // Constructor 
    Point (const Point& ObjectOfClassPoint);        //COPY constructor
    
 
    //----------- Declaration of Global Ostream << Operator  -----------//
    friend std::ostream& operator << (std::ostream& out, Point const& ObjPoint); 
    friend std::ostream& operator << (std::ostream& out, Point const *objPoint);
    
}   /*!!!*/; /*!!!*/
#endif // Point_HPP

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
//Array.cpp
#include "Array.hpp"
                                        
    //----------- Implementation of Constructors -----------//
    Array::Array() :  m_size(10), m_data(new Point[m_size])                                    
            {
                std::cout << "Array Default Constructor was called " ;
            }
 
    Array::Array(const int new_size) :m_size(new_size), m_data(new Point[m_size])       //specified by the size input argument
                                    
            {   
 
                std::cout << "Array Constructor was called "; 
            }
 
    Array::Array(const Array& ObjArray) 
{
    std::cout << "Array copy Constructor "; 
 
    m_size    =    ObjArray.m_size;     // shallow copy - this is not dynamic alloc
 
    if (ObjArray.m_data)                // if not zeros then there is a ref. - Deep copy needed
    {
        std::cout <<"im on Copy Constructor was called ";
 
        m_data = new Point[ObjArray.m_size];
 
        for (int i = 0; i < ObjArray.m_size; i++)
            m_data[i]    =    ObjArray.m_data[i];
    }
    else
        m_data = 0;                     //NULL
}
    Array::~Array()                                 
        {
            
 
            std::cout << "Array Destructor was called" ;
            delete [] m_data;
        }
    //----------- Declaration and  of Modificators member functions -----------//
    void Array::SetElement(const Point& ObjPoint, int index)
        {   
    
            if (index <= m_size) // When the index is out of bounds, ignore the “set”. 
            {
                m_data[index] = ObjPoint;
                std::cout << "Set Element " << ObjPoint  << std::endl;
            }
            else 
                std::cout << "The Element with index [ "<< index << " ] and\ndata ( " << m_data <<  " ) wasn't setted. "
             << " Ignore the set" <<  std::endl;
        }
    //----------- Implementation of Accessor(s) member functions -----------//
    Point& Array::GetElement(int index) const
        {   
 
            std::cout << "GetElement "; 
            if (index > m_size || index < 0)
            {
                return m_data[0];
            }
 
            return m_data[index];
        }
    int Array::Size() const // Get size
    { 
        return m_size;
    }
    //----------- Implementation of Operators Overloading the class's member -----------//
    Array& Array::operator = (const Array& source)
        {
            
 
            std::cout << " In the Array Assignment operator\n";
 
            if (this == &source)
                {
                std::cout << "Same Array \n"; 
                return *this;
                }
 
            delete [] m_data;
            std::cout << "Deleted m_data array\n";
 
            m_size = source.m_size;                             // shallow copy - this is not dynamic alloc
 
            if (source.m_data)                                  // if not zeros then there is a ref.
            {
                std::cout <<"im here\n"; 
 
                m_data = new Point[source.m_size];              // create a new pointee.
 
                for (int i = 0; i < source.m_size; i++)
                    m_data[i]    =    source.m_data[i];         //copy the points from/to array
            }
            else
                m_data = 0;  //NULL
 
            return *this;
        }
    //----------- Implementation of GLOBAL(friend) Ostream << Operator  -----------//
std::ostream& operator << (std::ostream& os, const Array& ObjArray)
{
    os << "\nArray Size = " << ObjArray.m_size << std::endl;
 
        for (int i = 0; i < ObjArray.m_size; i++)
            os << "Array [" << i << "]= "<< ObjArray.m_data[i] << "\n";
 
    return os;
}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "Point.hpp"
 
 
            //----------- Implementation of Constructors -----------//
 
    Point::Point() : x(0) , y(0)                                                        // Default constructor (implemented using colon syntax )
        { 
        //  std::cout << "hi my default constructor\n\n\t";
        }                           
 
    Point::Point(double newX , double newY) : x(newX)  , y(newY)                        // Constructor 
        { 
            //std::cout << "hi my constructor\n\n\t"; 
        }               
    Point::Point (const Point& ObjectOfClassPoint)                                      // Copy constructor
        {
            //std::cout << "this is COPY constructor\n\n\t ";
            x = ObjectOfClassPoint.x;
            y = ObjectOfClassPoint.y;
        }
    
    //----------- Implementation of GLOBAL Ostream << Operator  -----------//
 
    std::ostream& operator << (std::ostream& out, Point const& ObjPoint)
{
    return out << "[" << ObjPoint.x << "," << ObjPoint.y << "]" ; 
}
        std::ostream& operator << (std::ostream& out, Point const *objPoint)
{ 
    return out << "[" << objPoint->x << "," << objPoint->y << "]" ; 
}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
//main.cpp
 
#include <iostream>
#include "Point.hpp"
#include "Array.hpp"
 
 
 
int main()
 
    {
 
    
 
 
    int i = 0;                                              
    int size_of_array = 5;                                      
    Point** MyArrayOfPointers;
    MyArrayOfPointers = new Point*[size_of_array];                      //Creating an array of Point pointers with 3 elements on the heap.
    
    int some_data_for_x[5] = {1830 , 1901 , 1914, 1900 , 1895} ; 
    int some_data_for_y[5] = {1903 , 1947 , 1211, 1969 , 1789} ; 
 
   
    for (i = 0 ; i <size_of_array; i++ )                                // Create for each element in the array a point on the heap.
        {
            MyArrayOfPointers[i] = new Point(some_data_for_x[i],                
                                                some_data_for_y[i]);                                                                                        
        }
   
    std::cout << "\n\t Setting elements of MemoryManagerArray \n";
 
    Array* MemoryManagerArray = new Array(size_of_array); 
    MemoryManagerArray->SetElement(*MyArrayOfPointers[0],0);                // Setting elements of MemoryManagerArray
    MemoryManagerArray->SetElement(*MyArrayOfPointers[1],1);
    MemoryManagerArray->SetElement(*MyArrayOfPointers[2],2);
    MemoryManagerArray->SetElement(*MyArrayOfPointers[3],3);
    MemoryManagerArray->SetElement(*MyArrayOfPointers[4],4);                // The set will be ignored, because out of bounds
 
 
 
  
     std::cout << "\n\t ---TEST OF Assignment operator--- \n";
 
    *MemoryManagerArray = *MemoryManagerArray;                                          // assignment operator test
 
    std::cout   << "\n\t Printing elements of MemoryManagerArray \n";
    std::cout   << MemoryManagerArray->GetElement(0) << "\n"                            // Printing elements of MemoryManagerArray
                << MemoryManagerArray->GetElement(1) << "\n"
                << MemoryManagerArray->GetElement(2) << "\n"
                << MemoryManagerArray->GetElement(3) << "\n"
                << MemoryManagerArray->GetElement(4) << "\n"        ;   
 
 
    Array* AssignmentOperatorTESTArray = new Array(size_of_array); 
 
    *AssignmentOperatorTESTArray = *MemoryManagerArray;                                 // assignment operator test
 
    std::cout   << "\n\t Printing elements of AssignmentOperatorTESTArray \n";
    std::cout   << AssignmentOperatorTESTArray->GetElement(0) << "\n"                   // Printing elements of MemoryManagerArray
                << AssignmentOperatorTESTArray->GetElement(1) << "\n"
                << AssignmentOperatorTESTArray->GetElement(2) << "\n"
                << AssignmentOperatorTESTArray->GetElement(3) << "\n"
                << AssignmentOperatorTESTArray->GetElement(4) << "\n";  
   
    std::cout << "\n\t ---TEST OF Copy Constructor operator--- \n";
 
    Array CopyConstructorTESTArray(*MemoryManagerArray  )   ;                 // Copy constructor test
    
 
    std::cout   << "\n\t Printing elements of CopyConstructorTESTArray \n";
    std::cout   << CopyConstructorTESTArray.GetElement(0) << "\n"                       // Printing elements of MemoryManagerArray
                << CopyConstructorTESTArray.GetElement(1) << "\n"
                << CopyConstructorTESTArray.GetElement(2) << "\n"
                << CopyConstructorTESTArray.GetElement(3) << "\n"
                << CopyConstructorTESTArray.GetElement(4) << "\n";  
    
    size_of_array = 17; 
    Array* MemoryManagerArray = new Array(size_of_array); 
 
    
     std::cout  << "\n\t Shadow copy test  \n";
 
    std::cout << CopyConstructorTESTArray.GetElement(16) << "\n";
    
    std::cout << std::endl; 
    return 0;
 
}

@Schizorb · 28.07.2012, 12:47

В данном случае достаточно:

C++
1
m_size = source.m_size;

В m_size копируется значение source.m_size, это становятся две независящие друг от друга переменные, содержащие одинаковые значения, но при изменении одной не произойдёт изменений в другой.

Другое дело, если в классе есть указатели. Тогда поверхностное копирование приведет к тому, что в обоих объектах будут указатели, содержащие один и тот же адрес, то есть указывать они будут на одну и ту же область памяти. Значит здесь нужно копировать не значения указателей, а данные, на которые они указывают. То есть, именно то, что вы делаете для m_data. (Написать просто m_data = source.m_data было бы ошибкой)

@Nameless One · 28.07.2012, 12:50

Сообщение от Leeto

shadow copy

facepalm.cpp

Shallow copy

@HomeR_J_SimpsoN · 28.07.2012, 12:50

Слишком много буковок...
Не стоит выкладывать на форум ВСЕ свои исходники.

Но вроде бы у Вас все верно написано.
Вы идете по всему массиву и почленно присваиваете. Все ок.
И конечно же нужно проверить на существование массив и число элементов в нем...
Правда во втором случае Вы забываете обнулить m_size. Отсюда, наверное, и ошибка.

@Leeto · 28.07.2012, 12:58 **[ТС]**

По поводу этого проекта есть еще одна магическая для меня вещь которая заставляет меня беспокоится...

C++
1
delete [] m_data;

Вот это страчка :
Получается что я удалаю дату еще не присвоев ее к копии. Но факт в том что все работает
если я эту строчку ставлю в конце то копи конструктор возвращает мне (это можно через getelement увидеть ) дефонлтную точку ((0,0))

Как так получается я удаляю дату раньше чем ее переношу в копию а у меня все работает ?

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// Это из Array.cpp см выше 
Array& Array::operator = (const Array& source)
        {
            
 
            std::cout << " In the Array Assignment operator\n";
 
            if (this == &source)
                {
                std::cout << "Same Array \n"; 
                return *this;
                }
 
            delete [] m_data;
            std::cout << "Deleted m_data array\n";
 
            m_size = source.m_size;                             // shallow copy - this is not dynamic alloc
 
            if (source.m_data)                                  // if not zeros then there is a ref.
            {
                std::cout <<"im here\n"; 
 
                m_data = new Point[source.m_size];              // create a new pointee.
 
                for (int i = 0; i < source.m_size; i++)
                    m_data[i]    =    source.m_data[i];         //copy the points from/to array
            }
            else
                m_data = 0;  //NULL
 
            return *this;
        }
    //----------- Implementation of GLOBAL(friend) Ostream << Operator  -----------//
std::ostream& operator << (std::ostream& os, const Array& ObjArray)
{
    os << "\nArray Size = " << ObjArray.m_size << std::endl;
 
        for (int i = 0; i < ObjArray.m_size; i++)
            os << "Array [" << i << "]= "<< ObjArray.m_data[i] << "\n";
 
    return os;
}

@OhMyGodSoLong · 28.07.2012, 13:02

Эм... В 15 строке удаляется m_data того Array, куда копируют, а не откуда. А в 24 создаётся заново место, куда будет скопированы данные из source. Что-то не так?

@Schizorb · 28.07.2012, 13:02

Ты удаляешь "дату" объекта, который стоит слева от оператора присваивания. При этом с source.m_data всё в порядке, она никуда не удалилась. Так что копирование из source идёт как надо.

@Leeto · 28.07.2012, 13:06 **[ТС]**

Сообщение от ~OhMyGodSoLong~

Эм... В 15 строке удаляется m_data того Array, куда копируют, а не откуда. А в 24 создаётся заново место, куда будет скопированы данные из source. Что-то не так?

Да не все нормально работает я только не мог понять почему нормально работает )

Новые блоги и статьи Все статьи Все блоги /
Символьное дифференцирование igorrr37 13.02.2026 / * Логарифм записывается как: (x-2)log(x^2+2) - означает логарифм (x^2+2) по основанию (x-2). Унарный минус обозначается как ! в-строка - входное арифметическое выражение в инфиксной(обычной). . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .	И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»
SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL3_image 8Observer8 10.02.2026 Содержание блога Библиотека SDL3_image содержит инструменты для расширенной работы с изображениями. Пошагово создадим проект для загрузки изображения формата PNG с альфа-каналом (с прозрачным. . .	Установка Qt-версии Lazarus IDE в Debian Trixie Xfce volvo 10.02.2026 В общем, достали меня глюки IDE Лазаруса, собранной с использованием набора виджетов Gtk2 (конкретно: если набирать текст в редакторе и вызвать подсказку через Ctrl+Space, то после закрытия окошка. . .

@HomeR_J_SimpsoN 60 / 60 / 8 Регистрация: 15.10.2010 Сообщений: 356
	28.07.2012, 12:50
	Слишком много буковок... Не стоит выкладывать на форум ВСЕ свои исходники. Но вроде бы у Вас все верно написано. Вы идете по всему массиву и почленно присваиваете. Все ок. И конечно же нужно проверить на существование массив и число элементов в нем... Правда во втором случае Вы забываете обнулить m_size. Отсюда, наверное, и ошибка. 1

@OhMyGodSoLong ~ Эврика! ~ 1258 / 1007 / 74 Регистрация: 24.07.2012 Сообщений: 2,002
	28.07.2012, 13:02
	Эм... В 15 строке удаляется m_data того Array, куда копируют, а не откуда. А в 24 создаётся заново место, куда будет скопированы данные из source. Что-то не так? 0

@Schizorb 512 / 464 / 81 Регистрация: 07.04.2012 Сообщений: 869 Записей в блоге: 1
	28.07.2012, 13:02
	Ты удаляешь "дату" объекта, который стоит слева от оператора присваивания. При этом с source.m_data всё в порядке, она никуда не удалилась. Так что копирование из source идёт как надо. 1