почему возможно следущее?

простой пример...

int a[10];
int *сonst p = a; //константный указатель.
p++; // это не возможно;
p = new int; //тоже не возможно
delete p; //а вот тут компилятор (VC6) не ругается.

А почему нет? Ты ж сам указатель никак не меняешь?

Так же вполне можно писать и такое

const int * p = new const int(0);
delete p;

Правда VC такое не скомпилит.

Здравствуйте, SergeyBi, Вы писали:

SB>почему возможно следущее?

SB>простой пример...
SB>

SB>int a[10];
SB>int *сonst p = a; //константный указатель.
SB>p++; // это не возможно;
SB>p = new int; //тоже не возможно
SB>delete p; //а вот тут компилятор (VC6) не ругается.
SB>

А что тебя смущает? Ведь все равно ничто не помешает сделать так:

int* nonconstp = p;
delete nonconstp;

Так?

delete не изменяет значение указателя, а просто вызывает operator delete, который в свою очередь освобождаеть память. Если ты посмотришь, то увидишь, после выполнения delete значение указателя не изменяется.

Здравствуйте, SergeyBi, Вы писали:

SB>почему возможно следущее?

SB>простой пример...
SB>

SB>int a[10];
SB>int *сonst p = a; //константный указатель.
SB>p++; // это не возможно;
SB>p = new int; //тоже не возможно
SB>delete p; //а вот тут компилятор (VC6) не ругается.
SB>

А почему это не должно быть возможно? От операнда delete expression не требуется того, чтобы он был lvalue. Т.е. фактически можно сказать, что delete работает с копией исходного значения. При этом было ли исходное значение константным или нет — никакой роли не играет.

Например, можно сделать так

delete 0;

или можно сделать так

int* p = new int + 1;
delete p - 1;

АТ>или можно сделать так

АТ>

АТ>int* p = new int + 1;
АТ>delete (p - 1); //Скобки!
АТ>

Здравствуйте, Андрей Тарасевич, Вы писали:

[]

АТ>А почему это не должно быть возможно? От операнда delete expression не требуется того, чтобы он был lvalue. Т.е. фактически можно сказать, что delete работает с копией исходного значения. При этом было ли исходное значение константным или нет — никакой роли не играет.

А можно сказать, что statement delete принимает свой аргумент по значению, поэтому ему все равно, что l-value, что r-value?

Здравствуйте, MaximE, Вы писали:

M> А можно сказать, что statement delete принимает свой аргумент по
M> значению, поэтому ему все равно, что l-value, что r-value?

Это как раз и означает, что операндом delete является rvalue. В случае, если "на вход"
delete подается lvalue, производится соответствующее преобразование lvalue -> rvalue.

Павел, чисто дурацкий вопрос
Если функция принимает объект по значению (UDT), и я передаю ей l-value — тут есть преобразование lvalue to rvalue?

Здравствуйте, Lorenzo_LAMAS, Вы писали:

LL> Если функция принимает объект по значению (UDT), и я передаю ей
LL> l-value — тут есть преобразование lvalue to rvalue?

Да. Преобразование lvalue to rvalue — сложный способ назвать факт получения значения (rvalue) объекта (lvalue).

ПК>Да. Преобразование lvalue to rvalue — сложный способ назвать факт получения значения (rvalue) объекта (lvalue).

Да, но ведь сам-то параметр это же lvalue?

Здравствуйте, Lorenzo_LAMAS, Вы писали:

ПК>> Да. Преобразование lvalue to rvalue — сложный способ назвать факт
ПК>> получения значения (rvalue) объекта (lvalue).

LL> Да, но ведь сам-то параметр это же lvalue?

int* p = . . .;
delete p;

"Аргумент" delete (то, что мы "передаем") — lvalue. "Параметр" (то, что "получает" delete) — rvalue.
Т.е., мы передали дескриптор ячейки (имя переменной p) — lvalue; а delete нужно значение, которое
хранится в этой ячейке — rvalue. Вот и получается, что из заданной ячейки извлекается значение,
которое там хранится; стандарт это называет преобразованием lvalue to rvalue.

Подробнее: http://www.rsdn.ru/forum/Message.aspx?mid=141873&only=1

Автор: Павел Кузнецов
Дата: 28.11.02

class A
{
public:
    A(const A &);
//ctors etc
private:
    int i_;
//etc
};

void fun(A a)
{

}

int main()
{
   A b;
   fun(a);

   return 0;
}

Имеем передачу агрумента, аналогичную A a = b; или A a(b) — т.е. тогда что-то типа const A & copy_ctor_par = b. Как ко всей этой байде применить lvalue-rvalue?

Здравствуйте, Павел Кузнецов, Вы писали:

ПК> "Аргумент" delete (то, что мы "передаем") — lvalue. "Параметр" (то, что "получает" delete) — rvalue.

Точнее, параметр-то lvalue, но инициализируется это lvalue значением аргумента (rvalue).

Да, вроде как понятно

Правда, не гарантирую, что через месяц опять то же не стану спрашивать

Здравствуйте, Vamp, Вы писали:

АТ>>или можно сделать так

АТ>>

АТ>>int* p = new int + 1;
АТ>>delete (p - 1); //Скобки!
АТ>>

Да. Спасибо. Забыл.

Здравствуйте, Lorenzo_LAMAS, Вы писали:

LL>

LL> class A {
LL> public:
LL>     A(const A&);
LL> };

LL> void fun(A a) { }

LL> int main()
LL> {
LL>    A b;
LL>    fun(b);
LL> }
LL>

LL> Имеем передачу агрумента, аналогичную A a = b; или A a(b) — т.е. тогда что-то типа
LL> const A & copy_ctor_par = b. Как ко всей этой байде применить lvalue-rvalue?

Не вполне понял, что ты хотел спросить последним предложением, но, тем не менее...

Действительно, инициализация аргумента a осуществляется подобно следующему (copy-initialization):

A a = b;

Соответствующие правила инициализации описаны в 8.5/14. В данном случае инициализация осуществляется
посредством вызова конструктора копирования. Конструктор копирования имеет параметр const A&; соответственно
(назовем параметр конструктора копирования r):

const A& r = b;

Инициализация ссылок описана в 8.5.3/5. Т.к. const A является reference-compatible с A и выражение
инициализатора является lvalue, ссылка привязывается непосредственно к lvalue b. В процессе выполнения
конструктора A::A(const A&), скорее всего, потребуется доступ к членам класса для получения их значений,
что приведет к соответствующим преобразованиям lvalue-to-rvalue.

В результате, в функции f имеем параметр a (lvalue), полученный посредством copy-initialization
из аргумента b (lvalue).