Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.50/18: Рейтинг темы: голосов - 18, средняя оценка - 4.50
3 / 3 / 0
Регистрация: 28.11.2018
Сообщений: 238
1

Какая разница между delete и delete[]

27.06.2019, 14:43. Показов 3230. Ответов 12
Метки нет (Все метки)

Нашел информацию на разных сайтах и всё равно остались вопросы.
Я понимаю, что delete используется для удаления одиночных объектов и вызывает только один деструктор(например), а delete[] для большого кол-ва элементов и вызывает ВСЕ деструкторы этих элементов.

Но я вот реализую класс смарт_поинтеров самостоятельно, чтобы лучше разобраться и непонятен один момент: просто как различить когда мне передали указатель на массив, а когда передали указатель на один объект(без передачи доп. параметров)?

То, что уже есть:
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
template<class T>
class ptr {
private:
    T *p;
public:
    ptr() {
        p = NULL;
    }
    ptr(const ptr &pt) = delete;
    ptr(T *pt) {
        cout << "Copy-constructor \n";
        p = pt;
    }
    ptr& operator=(T *pt) {
        cout << "Operator equal = \n";
 
    }
    ~ptr() {
        delete[] p;
        p = NULL;
    }
};
 
int main() {
    ptr<char> a = new char;
    
    return 0;
}
__________________
Помощь в написании контрольных, курсовых и дипломных работ здесь
0
Лучшие ответы (1)
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
27.06.2019, 14:43
Ответы с готовыми решениями:

В чем разница между delete и delete[]?
а можете еще по подробней рассказать про delete, точнее даже delete, чем именно отличается delete...

Используя delete по указателю, возвращенному new [] или delete [] указателем, возвращаемым new
Помогите ответить на вопрос, не могу понять суть вопроса (правильно ли понимаю, что будет если...

Чем отличается delete[] от delete?
чем отличается? delete mas от delete mas

Почему в конструкторе перемещения присваивается NULL, а не применяется оператор delete? В чем разница?
// move constructor MyString(MyString&amp;&amp; MoveSource) { cout &lt;&lt; &quot;Move constructor&quot; &lt;&lt; endl;...

12
Mental handicap
1245 / 623 / 171
Регистрация: 24.11.2015
Сообщений: 2,429
27.06.2019, 14:48 2
Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
C++
1
new char
Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
C++
1
delete[] p
Это UB.
Цитата из стандарта
In the first alternative (delete object), the value of the operand of delete shall be a pointer to a non-array object or a pointer to a sub-object representing a base class of such an object. If not, the behavior is undefined.

In the second alternative (delete array), the value of the operand of delete shall be the pointer value which resulted from a previous array new-expression. If not, the behavior is undefined.
Если на пальцах то, delete используется для удаления одного объекта, а delete[] используется для удаления массива объектов. Вы вызываете delete[] при выделении new[], в противном случае вы вызываете просто delete.
1
15251 / 8218 / 1993
Регистрация: 30.01.2014
Сообщений: 13,999
27.06.2019, 15:01 3
Лучший ответ Сообщение было отмечено MJ_PRUTYG как решение

Решение

MJ_PRUTYG, сделайте специализацию вашего шаблона для массивов и в ней используйте delete[]

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template<class T>
class ptr<T[]> {
private:
    T *p;
 
///..........
    void reset(T *pt = nullptr)
    {
        delete[] p;
        p = pt;
    }
};
 
int main() {
    ptr<char[]> a( new char[10] );
    
    return 0;
}
1
3 / 3 / 0
Регистрация: 28.11.2018
Сообщений: 238
27.06.2019, 15:14  [ТС] 4
DrOffset, ааа, ага, я понял, то что нужно - спасибо!
0
884 / 340 / 78
Регистрация: 17.05.2015
Сообщений: 1,096
27.06.2019, 15:14 5
Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
как различить когда мне передали указатель на массив, а когда передали указатель на один объект(без передачи доп. параметров)?
Никак ))
1
3 / 3 / 0
Регистрация: 28.11.2018
Сообщений: 238
27.06.2019, 15:16  [ТС] 6
DrOffset, подождите, а что означает запись class ptr<T[]>{...}, что это за <T[]>??? Никогда такого не встречал
И, кстати при такой записи компилятор ошибку выдает...
0
15251 / 8218 / 1993
Регистрация: 30.01.2014
Сообщений: 13,999
27.06.2019, 15:23 7
Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
что это за <T[]>??? Никогда такого не встречал
Специализация для массива неизвестного размера с элементами типа T.

Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
И, кстати при такой записи компилятор ошибку выдает...
Значит вы что-то не так делаете

Вы основной-то шаблон оставили, надеюсь? Что вы будете специализировать, если основной шаблон убрали?
0
330 / 145 / 56
Регистрация: 17.10.2015
Сообщений: 580
27.06.2019, 15:24 8
Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
что это за <T[]>???
MJ_PRUTYG, Это массив элементов какого-то типа!!!
0
15251 / 8218 / 1993
Регистрация: 30.01.2014
Сообщений: 13,999
27.06.2019, 15:29 9
MJ_PRUTYG, не смотреть, если нужно (а нужно обязательно) разобраться самостоятельно.
Кликните здесь для просмотра всего текста
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
#include <iostream>
 
template<class T>
class ptr {
private:
    T * p;
public:
    using ptr_type = T;
    
    ptr() : p(nullptr) {
    }
    ptr(const ptr &pt) = delete;
    
    ptr(ptr_type *pt) : p(pt)  {
    }
    ptr & operator=(ptr_type *pt) {
        reset(pt);
        return*this;
    }
    void reset(ptr_type *pt = nullptr) {
        std::cout << "delete" << std::endl;
        delete p;
        p = pt;
    }
    ~ptr() {
        reset();
    }
};
 
template<class T>
class ptr<T[]> {
private:
    T * p;
public:
    using ptr_type = T;
    
    ptr() : p(nullptr) {
    }
    ptr(const ptr &pt) = delete;
    
    ptr(ptr_type *pt) : p(pt)  {
    }
    ptr & operator=(ptr_type *pt) {
        reset(pt);
        return*this;
    }
    void reset(ptr_type *pt = nullptr) {
        std::cout << "delete[]" << std::endl; 
        delete[] p;
        p = pt;
    }
    ~ptr() {
        reset();
    }
};
 
 
int main() {
    ptr<char> a( new char );
    ptr<char[]> b( new char[10] );
 
}
https://rextester.com/LHAB84513

Дальше можно задаться вопросом как сделать так, чтобы не дублировать одинаковые функции в двух специализациях.
Домашнее задание вам.

0
3 / 3 / 0
Регистрация: 28.11.2018
Сообщений: 238
27.06.2019, 15:34  [ТС] 10
DrOffset, понял, буду разбираться Спасибо большое!
0
Продавец времени
6032 / 3310 / 766
Регистрация: 12.03.2015
Сообщений: 15,803
27.06.2019, 15:34 11
C++
1
delete [] x; // освобождение памяти из-под динамического массива
0
3 / 3 / 0
Регистрация: 28.11.2018
Сообщений: 238
27.06.2019, 15:50  [ТС] 12
DrOffset, некоторые моменты вашего кода, для меня - гениальны! Например с тем же деструктором и обращением к функции reset - это так легко, так просто и так элементарно, но я бы не додумался
Короче, разобрался со всем кодом(спасибо за него еще раз), кроме одного момента: почему я не могу "выкинуть" class ptr{...} и оставить class ptr<T[]>{...} - выдает ошибку, но почему???? Пытался искать в гугле, ничего не нашел, да и не знаю даже, как сформулировать вопрос...
0
15251 / 8218 / 1993
Регистрация: 30.01.2014
Сообщений: 13,999
27.06.2019, 16:23 13
Цитата Сообщение от MJ_PRUTYG Посмотреть сообщение
очему я не могу "выкинуть" class ptr{...} и оставить class ptr<T[]>{...} - выдает ошибку, но почему????
Потому что, чтобы что-то специализировать, нужно сначала иметь общую версию.
А специализация без общей версии - это не специализация, т.к. нет того что специализируется.

Добавлено через 20 минут
MJ_PRUTYG, без дублирования кода и с возможностью расширения на другие варианты освобождения памяти (например память из пула).
Сначала сам придумать решение пробуйте, не подсматривайте (а то так не интересно будет). Мой вариант не единственный.
Кликните здесь для просмотра всего текста
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
#include <iostream>
 
// Базовый шаблон принимает тип указателя и стратегию освобождения памяти - Deleter
template <typename T, typename Deleter>
class ptr_base
{
public:
    using ptr_type = T;
    
    ptr_base(ptr_type *pt = nullptr) : p(pt) { 
    }
    void reset(ptr_type *pt = nullptr) {
        Deleter()(p);
        p = pt;
    }
    ptr_base & operator=(ptr_type *pt) {
        reset(pt);
        return*this;
    }
    ~ptr_base() {
        reset();
    }
    T * operator->() {
        return p;
    }
    const T * operator->() const {
        return p;
    }    
    T * get() {
        return p;
    }
    const T * get() const {
        return p;
    }
    T & operator*() {
        return *p;
    }
    const T & operator*() const {
        return *p;
    }        
    
    ptr_base(const ptr_base &pt) = delete;
    ptr_base & operator=(const ptr_base &pt) = delete;
    
private:
    T * p;
};
//=============================
struct DefaultDelete // Стратегия освобождения "по-умолчанию"
{
    template <typename T>
    void operator()(T * p) noexcept { 
       delete p;   
    }
};
struct ArrayDelete // Стратегия освобождения массива
{
    template <typename T>
    void operator()(T * p) noexcept { 
       delete[] p; 
    }
};
 
// Общий случай
template <class T>
class ptr : public ptr_base<T, DefaultDelete> {
    
    using base = ptr_base<T, DefaultDelete>;
public:
    using base::base;
};
 
// Частный случай для массивов
template <class T>
class ptr<T[]> : public ptr_base<T, ArrayDelete> {
    
    using base = ptr_base<T, ArrayDelete>;
public:
    using base::base;
    
    // Эти два метода характерны только для массива
    T & operator[](std::size_t idx) {
        return base::get()[idx];
    }
    const T & operator[](std::size_t idx) const {
        return base::get()[idx];
    }        
};
//=============================
 
int main() {
    ptr<char> a( new char );
    
    *a = 'x';
    
    std::cout << *a << std::endl;
    
    ptr<char[]> b( new char[10] );
    
    b[0] = 'a';
    b[1] = 'b';
    b[2] = 'c';
    b[3] = '\0';
    
    std::cout << b.get();
}
https://rextester.com/PXIJ21063
1
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
27.06.2019, 16:23

Delete или delete []
Здравствуйте. Написал программу которая создает динамический массив, заполняемый нулями и выводит...

delete[] *pointer vs. delete pointer и утечка памяти
Здравствуйте! Есть класс &quot;умного&quot; указателя counted_ptr, который удаляет хранящийся в нём T*...

"delete [] a, b;" эквивалентно "delete [] a; delete [] b;"?
Я правильно понимаю, что &quot;delete a, b;&quot; эквивалентно &quot;delete a; delete b;&quot; ?

Какая Разница между сортировками?
Какая разница между сортировками, если в итоге все виды сортируют одинаково. Т е. Результат...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
13
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2021, vBulletin Solutions, Inc.