Можно ли несколько раз делитить область памяти?

@Svinina · Регистрация: 28.11.2010

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

Собственно, чреват ли ошибками код:

C++

int *a;
 
a = new int[2];
a[0] = 1;
a[1] = 2;
 
delete [] a;
delete [] a;

@Svinina · 19.11.2011, 19:45 **[ТС]**

Собственно, попробовал запустить этот код, компилятор (Qt'шный) не стал ругаться, программа отработала корректно.
Так где собака то зарыта?

Jupiter · 19.11.2011, 19:51

Svinina, нигде, код абсолютно корректный

@Svinina · 19.11.2011, 19:53 **[ТС]**

Ну Берс в самом начале написал, что такой код чреват ошибками.
Вот и интересуюсь, какими=)

@taras atavin · 19.11.2011, 19:54

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

Нет никакой гарантии, что NULL - это ноль.

Есть гарантия, что NULL - это невалидный спецадрес, обозначающий, что указатель ни куда не указывает. И усматривают здесь изготовители не компиляторов, всё зависит от начального адреса памяти. На IBM совместимых это должен быть ноль, не зависимо от компиляторов и даже от языков, а сигнальные камни любят память с ноля начинать, а если так сделано, то NULL не имеет права быть нолём, опять таки даже в том случае, если кроскомпилятор прошивок таких коммутаторов выпустит мелкософт.

@~~Bers~~ · 19.11.2011, 19:57

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

Ну Берс в самом начале написал, что такой код чреват ошибками.
Вот и интересуюсь, какими=)

Первый раз delete освобождает память. С этого момента, этот кусок памяти становится "свободным". И система в любой миг может отдать его ещё кому нибудь.

Второй раз delete пытается освободить уже чужую память. И если эта память принадлежит уже кому то там - может произойти порча данных (хотя скорее всего система этот косяк пофиксит, и заломает накосячевший процесс)

Добавлено через 55 секунд
taras atavin, да я уже вразумел)

NULL всегда не_валидный адрес, но не всегда является нулём)

@taras atavin · 19.11.2011, 19:58

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

в Си NULL это ноль приведенный к void* в C++ NULL это ноль

Не ноль, а невалидный номер байта. На IBM совместимых гарантировано невалидный номер байта - это ноль, но если сдеать c, или c++ кроскомпилятор для сиганального камня, то там может быть и другое значение NULL.

@~~Bers~~ · 19.11.2011, 20:00

Сообщение от taras atavin

Не ноль, а невалидный номер байта.

Именно ноль, и если я правильно понял, именно из-за этого и был принят nullptr
(что бы различать int равный нулю и void* равный нулю)

@taras atavin · 19.11.2011, 20:01

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

Говорят: пиши тогда уж просто ноль. Так будит безопаснее.

Опаснее. И именно потому, что NULL - это не всегда ноль.

Jupiter · 19.11.2011, 20:25

Не по теме:

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

Второй раз delete пытается освободить уже чужую память. И если эта память принадлежит уже кому то там - может произойти порча данных (хотя скорее всего система этот косяк пофиксит, и заломает накосячевший процесс)

таки Bers прав:), признаю свою ошибку в 22 посту

@taras atavin · 19.11.2011, 20:40

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

Гарантированно оно, если delete []a; a=0;
Не?
А если дефайн - никаких гарантий нет.

Наоборот. Если NULL!=0, то по

C++

1 2	a=0; delete [a];

очень даже произойдёт. А если дефайном, то вопрос только в правильности дефайна, ну так не пользуйся не правильным и при любом значении NULL ничего не произойдёт. Кстати, я никогда не полагаюсь на проверку внутри delete, а всегда пишу явно

C++

if (p)
{
 delete [] p;
}

@~~Bers~~ · 19.11.2011, 20:41

Я такую запись не понимаю:

Сообщение от taras atavin

delete [a];

@taras atavin · 19.11.2011, 21:04

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

не сказать, что хорошо знаю стандарт, но помойму, там идёт проверка на ноль, а не на NULL

На значение NULL без обращения упоминания имени данного макроса, так как проверять просто на ноль нельзя: если ноль - валидный адрес, то это может привести к невозможности выделить память.

Добавлено через 13 минут

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

Первый раз delete освобождает память. С этого момента, этот кусок памяти становится "свободным". И система в любой миг может отдать его ещё кому нибудь.
Второй раз delete пытается освободить уже чужую память. И если эта память принадлежит уже кому то там - может произойти порча данных

. Нет. Ни каких чужих данных там быть не может: в многозадачных осях все программы работают в виртуальных адресных пространствах, а освобожденная память из них изымается, то есть виртуальный адрес после освобождения становится столь же невалидным, как и NULL, кусок же памяти по тому же физическому адресу, который как раз может быть выдан кому то ещё, после такого выделения окажется в другом виртуальном адресном пространстве, так как они все локальны, глобальны только физические адреса, а в однозадачной системе просто больше никого нет, кому могла бы быть выдана память по тому же адресу. Опасно же второй раз удалять не подряд, если та же самая прога и тот же её екземпляр успеет получить кусок памяти, на который попадёт тот же адрес.

C++

... f1(...)
{
 static ... *p;
 ...
 p=new ...;
 ...
 delete [] *p;  // Эта строчка выполнилась дважды в разные вызовы f1, а между ними p попал в память выданную f2
}
... f2(...)
{
 static ... *p;
 ...
 p=new ...; 
 ...
 delete [] *p;
}

. И всё таки дважды делитить можно в единственном случае: если между делитами было ещё одно выделение памяти с того же начального адреса.

Добавлено через 4 минуты
То есть

C++

int *p;
p=new int [...];
...
delete [] p;
...
p=new int [...];
...
delete [] p;

можно.

@Svinina · 19.11.2011, 21:08 **[ТС]**

в многозадачных осях все программы работают в виртуальных адресных пространствах, а освобожденная память из них изымается, то есть виртуальный адрес после освобождения становится столь же невалидным, как и NULL

А вот тут можно поподробнее?
Правильно ли я понимаю, что один раз выделив память, а затем ее освободив, физически к этой области памяти процесс уже доступа получить никогда не сможет?

@taras atavin · 19.11.2011, 21:17

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

Именно ноль, и если я правильно понял, именно из-за этого и был принят nullptr

Нет. Имплементейшн дефайн - это как раз и есть не всегда ноль. А nullptr приняли, чтоб избавиться от макроса в неконтролируеммом заголовке. У меня где то был исходник для убунты, начинающийся с

C++

1	#define NULL 0

, дефайн этот я написал собственноручно, так вот, если такое начало будет в исходнике для сигнального камня, то получим полную фигню. Компилятор и так должен соответствовать архитектуре, не только по значению NULL, а дефайн может быть в любом "левом" заголовке и даже прямо в исходнике, автор которого архитектуру мог не только не учитывать, а ещё и делать для другой архитектуры. Константа же, известная самому компилятору, а не препроцессору, не будет зависеть от таких самодельных дефайнов, а только от компилятора.

Добавлено через 4 минуты

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

delete [a];

Я тоже эту очепятку не понимаю. Должно быть

C++

1	delete [] a;

@~~Bers~~ · 19.11.2011, 21:18

taras atavin,

C++

void Foo(int a) {...}
void Foo( void* ptr) {...}
 
...
 
Foo(0); //угадай, какая из функций будит запущена?
           //если угадаешь правильно, поймёшь, зачем нужен nullptr_t

@taras atavin · 19.11.2011, 21:26

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

А вот тут можно поподробнее?
Правильно ли я понимаю, что один раз выделив память, а затем ее освободив, физически к этой области памяти процесс уже доступа получить никогда не сможет?

Почему "никогда"? К этой памяти можно обратиться, если:
1. Освобождённый адрес находится на странице, содержащей другой, валидный локальный адрес. В этом случае освобожденный адрес тоже должен стать невалидным, но система не в состоянии этого гарантировать. Но память на одной странице не может быть выдана разным процессам, так что чужую память ты таким образом не освободишь и к ней не обратишься.
2. Если память была повторно выделена процессу.

Добавлено через 2 минуты

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

void Foo(int a) {...}
void Foo( void* ptr) {...}
...
Foo(0); //угадай, какая из функций будит запущена?
* * * * * *//если угадаешь правильно, поймёшь, зачем нужен nullptr_t

C++

#define NULL 0xFFFF
void Foo(int a) {...}
void Foo( void* ptr) {...}
...
Foo(0); //А здесь? Если NULL дефайнить числом, то и здесь проблема та же, дело не в ноле.

Это ещё одна цель введения nullptr.

@~~Bers~~ · 19.11.2011, 21:29

Сообщение от taras atavin

Foo(0); //А здесь?

Константа не_ноль интерпритируется как инт по умолчанию. Естественно первый вариант

@taras atavin · 19.11.2011, 21:47

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

Естественно первый вариант

Первый и должен, так как аргумент - число. Но и NULL - тоже число, то есть foo(NULL) вызовет первый вариант, а программист имеет ввиду второй. Если аргумент - переменная указательного типа, то вызовется второй вариант, как и должно быть. Целей может быть много, но в данном случае на самом деле всё таки одна - избавиться от макроса. Почему надо от него избавиться - это уже другой вопрос и проблема со многими аспектами. Возможность ошибочного дефайна - один из них. Второй - вызов перегруженной функции с невалидным указателем, если есть версия c интом. Чтоб не писать

C++

1 2	int *p=NULL; foo(p);

. Кстати, а как будет здесь:

C++

#define NULL (void*)0xFFFF
void foo(int x);
void foo(void *p);
void foo(int *p);
...
foo(0);
foo(NULL);

и здесь:

C++

void foo(int x);
void foo(void *p);
void foo(int *p);
...
foo(0);
foo(nullptr);

? Валидные указаетели все имеют типы, так как являются переменными. Указатель-переменная с невалидным значением тоже имеет тип. А как быть с nullptr? Ведь программист может под этой константой подразумевать невалидный указатель на что угодно, причём ещё и не всегда одно и тоже в разных местах программы.

@~~Bers~~ · 19.11.2011, 21:48

Сообщение от taras atavin

А как быть с nullptr?

эта волшебная константа типа nullptr_t

@taras atavin · 19.11.2011, 21:51

Кстати, студия 2008 не знает ни nullptr, ни NULL_PTR, ни null_ptr, ни NULLPTR.

@Svinina 5 / 5 / 0 Регистрация: 28.11.2010 Сообщений: 81
	19.11.2011, 19:53 [ТС]	23
	Ну Берс в самом начале написал, что такой код чреват ошибками. Вот и интересуюсь, какими=) 1

@~~Bers~~ Заблокирован
	19.11.2011, 20:00	27
	Сообщение от taras atavin Не ноль, а невалидный номер байта. Именно ноль, и если я правильно понял, именно из-за этого и был принят nullptr (что бы различать int равный нулю и void* равный нулю) 0

@~~Bers~~ Заблокирован
	19.11.2011, 20:41	31
	Я такую запись не понимаю: Сообщение от taras atavin delete [a]; 0

@Svinina 5 / 5 / 0 Регистрация: 28.11.2010 Сообщений: 81
	19.11.2011, 21:08 [ТС]	33
	в многозадачных осях все программы работают в виртуальных адресных пространствах, а освобожденная память из них изымается, то есть виртуальный адрес после освобождения становится столь же невалидным, как и NULL А вот тут можно поподробнее? Правильно ли я понимаю, что один раз выделив память, а затем ее освободив, физически к этой области памяти процесс уже доступа получить никогда не сможет? 0

@~~Bers~~ Заблокирован
	19.11.2011, 21:29	37
	Сообщение от taras atavin Foo(0); //А здесь? Константа не_ноль интерпритируется как инт по умолчанию. Естественно первый вариант 0

@Svinina 5 / 5 / 0 Регистрация: 28.11.2010 Сообщений: 81
	19.11.2011, 19:45 [ТС]	21
	Собственно, попробовал запустить этот код, компилятор (Qt'шный) не стал ругаться, программа отработала корректно. Так где собака то зарыта? 0

Jupiter Каратель 6609 / 4028 / 401 Регистрация: 26.03.2010 Сообщений: 9,273 Записей в блоге: 1
	19.11.2011, 19:51	22
	Svinina, нигде, код абсолютно корректный 0

@taras atavin 4226 / 1795 / 211 Регистрация: 24.11.2009 Сообщений: 27,562
	19.11.2011, 19:54	24
	Сообщение от Bers Нет никакой гарантии, что NULL - это ноль. Есть гарантия, что NULL - это невалидный спецадрес, обозначающий, что указатель ни куда не указывает. И усматривают здесь изготовители не компиляторов, всё зависит от начального адреса памяти. На IBM совместимых это должен быть ноль, не зависимо от компиляторов и даже от языков, а сигнальные камни любят память с ноля начинать, а если так сделано, то NULL не имеет права быть нолём, опять таки даже в том случае, если кроскомпилятор прошивок таких коммутаторов выпустит мелкософт. 0

@~~Bers~~ Заблокирован
	19.11.2011, 19:57	25
	Сообщение от Svinina Ну Берс в самом начале написал, что такой код чреват ошибками. Вот и интересуюсь, какими=) Первый раз delete освобождает память. С этого момента, этот кусок памяти становится "свободным". И система в любой миг может отдать его ещё кому нибудь. Второй раз delete пытается освободить уже чужую память. И если эта память принадлежит уже кому то там - может произойти порча данных (хотя скорее всего система этот косяк пофиксит, и заломает накосячевший процесс) Добавлено через 55 секунд taras atavin, да я уже вразумел) NULL всегда не_валидный адрес, но не всегда является нулём) 2

@taras atavin 4226 / 1795 / 211 Регистрация: 24.11.2009 Сообщений: 27,562
	19.11.2011, 19:58	26
	Сообщение от Jupiter в Си NULL это ноль приведенный к void* в C++ NULL это ноль Не ноль, а невалидный номер байта. На IBM совместимых гарантировано невалидный номер байта - это ноль, но если сдеать c, или c++ кроскомпилятор для сиганального камня, то там может быть и другое значение NULL. 0

@taras atavin 4226 / 1795 / 211 Регистрация: 24.11.2009 Сообщений: 27,562
	19.11.2011, 20:01	28
	Сообщение от Bers Говорят: пиши тогда уж просто ноль. Так будит безопаснее. Опаснее. И именно потому, что NULL - это не всегда ноль. 0

Jupiter
	19.11.2011, 20:25 #29
	Не по теме: Сообщение от Bers Второй раз delete пытается освободить уже чужую память. И если эта память принадлежит уже кому то там - может произойти порча данных (хотя скорее всего система этот косяк пофиксит, и заломает накосячевший процесс) таки Bers прав:), признаю свою ошибку в 22 посту 0

@~~Bers~~ Заблокирован
	19.11.2011, 21:48	39
	Сообщение от taras atavin А как быть с nullptr? эта волшебная константа типа nullptr_t 0

@taras atavin 4226 / 1795 / 211 Регистрация: 24.11.2009 Сообщений: 27,562
	19.11.2011, 21:51	40
	Кстати, студия 2008 не знает ни nullptr, ни NULL_PTR, ни null_ptr, ни NULLPTR. 0