Конструктор/Деструктор - когда вызывать?

[EXE]

Люди добрые помогите! Ситуация следующая:
Имеется клас A.

class A
{
   private:
   ...
   ...
   ...
   public:
        ...
        ...
        ...
        A(int);
        ~A();
};

//конструктор
void A::A(int param)
{
   ...
   ...
   ...
}

//деструктор
void A::~A()
{
   ...
   ...
   ...
}

Перед main объявляю экземпляр класса:
A cl(10);

В книжке по C++ я прочитал, что конструктор вызывается автоматически при объявлении переменной имеющей тип класса.
Если конструктор не был реализован в объявлении класс, то компилятор соберёт свой дефолтовый конструктор. Это вроде бы ясно.
Деструктор вызывается автоматически в следующих случаях:
1. Когда переменная-класс покидает область видимости в которой она объявлена;
2. Когда вызывается delete с указателем на класс в качестве параметра.

Из вышесказанного следует, что деструктор вообще вызывать не нужно!!! Т.е. компилятор позаботится об этом сам!
Но как быть, если до конца области видимости ещё далеко, а экземпляр класса мне уже не нужен и я хочу освободить
занимаемуею объектом память вызвав деструктор (delete &cl)?
Я делал так:
delete(&cl);
И вот так:
cl.~A();

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

Буду благодарен если Вы объясните мне что я делаю не так? Я повторю вопрос...

Но как быть, если до конца области видимости ещё далеко, а экземпляр класса мне уже не нужен и я хочу освободить
занимаемуею объектом память вызвав деструктор (delete &cl)?

[SlavaI]

Тебя спасет или использование стандартного распределителя памяти
A* a= new A(...);
.......
delete a;

Или создание собственного распределителя - void* operator new(size_t s, ...) и парного ему void operator delete(size_t s); Но это тема сложная и большая, как говорится "Неисчерпаема как атом"(В. И. Ульянов). Используй стандартный.

Вызывать самостоятельно деструктор для стековых объектов(как это сделал ты) запрещено. И никогда не вызывай delete для стековых объектов! Он вызывается для объектов с динамически распределенной памятью и является парным к new.

[EXE]

Понял - спасибо!!!
А вот так можно?

A* a = (A*)malloc( sizeof(  A(10) ) );
...
...
...
free(a);
...
...
...

[SlavaI]

А вот так можно?

A* a = (A*)malloc( sizeof( A(10) ) );
...
...
...
free(a);

НЕТ!Ты путаешь С и C++, а также стековые, статические и динамические объекты. sizeof( A(10) )- это вобще не откомпилируется. А кто конструктор вызовет?

Вот так еще можно поробовать.
void* pa = malloc( sizeof( A(10) ) );
А* a=new(pa) A(10);
...
...
...
a.~A();
free(pa);

[EXE]

SlavaI - Большое СПАСИБО - буду читать дальше )))

[Migmile]

void* pa = malloc( sizeof( A(10) ) );
А* a=new(pa) A(10);
...
...
...
a.~A();
free(pa);

А вот это уже через-чур
Все равно new вызывает под собой malloc по умолчанию (по крайней мере в VC)

[SlavaI]

А вот это уже через-чур  
Все равно new вызывает под собой malloc по умолчанию (по крайней мере в VC)

Читай стандарт. А то ты тоже не понимаешь смысла new, воспринимая его только как malloc. Ничего оператор void* operator new(size_t sz, void* pl) не вызывает он просто возвращает переданный ему указатель на память а компилятор вызывает конструктор, инициализируя этот кусок памяти. Это надо только для инициализации уже выделенной области памяти.
 вот как он объявлен в VC

Код:

inline void *__cdecl operator new(size_t, void *_P)
        {return (_P); }

Вот тебе програмка, компильни ее

Код:

#include <new.h>
#include <iostream.h>
#include <stdlib.h>

class A
{
public:
	int a;
	A(int i){a=i;};
	~A()|";
};

int _tmain(int argc, _TCHAR* argv[])
{
   void* pa = malloc(sizeof(A)); 
   A* a=new(pa) A(10); 

   cout<<a->a<<endl;

  a->~A(); 
  free(pa);
  return 0;
}

Еще раз повторю- не путайте С и C++.

[Migmile]

SlavaI, это я прекрасно понимаю, просто сначала выделять память alloc-ом, а затем размещать на ней объект не часто необходимо!
А "обычный" new выглядит примерно так:
void * operator new( size_t cb )
{
        void *res = _nh_malloc( cb, 1 );
        RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));
        return res;
}
(VC7 CRT)

[SlavaI]

SlavaI, это я прекрасно понимаю, просто сначала выделять память alloc-ом, а затем размещать на ней объект не часто необходимо!
А "обычный" new выглядит примерно так:
void * operator new( size_t cb )
{
void *res = _nh_malloc( cb, 1 );
RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));
return res;
}

Если ты это понимаешь, то зачем написал свое сообшение? Человек спросил- можно ли так, я ему ответил, что можно, но надо как-то вызвать конструктор, а компилятор вызовет конструктор только для new, но не malloc. Тот new не вызывает malloc.

[Джон]

Migmile, не сбивай людей с толку. Вопрос задан в "С м С++", а не "С++ для ОС".
Слава и отвечает по стандарту.

[Migmile]

Ладно, ладно - утоптали!
Просто чем проще ответ - тем он понятнее

[Fatal Error]

А почему все забывают о списке инициализации членов :?: Писать корректнее надо  так

Код:

A(int i)  :  a(i) {}; 

Плюс еще вы выполняется быстрее.

Напрямую вызывать деструктор можно и для стековой переменной - должно работать, у меня проблем не было.

[SlavaI]

Писать корректнее надо так Код:
A(int i)  :  a(i) {};

Кто тебе сказал, что это корректнее, можно писать и так и как я, никакой ошибки или неточности нет. В моем случае сначала вызовется конструктор по умолчанию, а потом B& operator=(const B&), но оптимизирующие компиляторы для встроенных типов не делают разницы между твоей и моей записью.

Напрямую вызывать деструктор можно и для стековой переменной - должно работать, у меня проблем не было.

Ну вот только не надо- я пробовал! Ты сказал абсолютно неверную вещь. Нельзя, и не спорь. Этот деструктор второй раз вызовут при уходе из области видимости, это жестко зашито в код компилятором. То что программа не упала ничего не значит. Деструктор не освобождает память, выделенную под объект класса, тем более стековую память. Поэтому повторный вызов не дал никакого эффекта, а вот попробуй в деструкторе освобождать память, выделенную при помощи new в конструкторе для члена класса. А потом вызови деструктор для стековой переменной. Для чистоты измени указатель в деструкторе. Получишь по рукам! Система посмеется над таким способом.

Говоришь пробовал. Попробуй это-

class D
{
   int* pi;
public:
   D(){ pi = (int*)new int[10]; };
   ~D(){ delete[] pi; pi=(int*)0x1000 ; };
};

int _tmain(int argc, _TCHAR* argv[])
{
   D d;
   d.~D();
}

[Fatal Error]

SlavaI <<[/b] А если не встроенный тип, все-таки мне кажется, что так писать более красиво и читаемо... имхо.

А если делать так, то проблем не будет:

Код:

class D 
{
int* pi; 
public: 
D(){ pi = (int*)new int[10]; }; 
~D()| delete[] pi; pi = NULL; }; 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
D d; 
d.~D(); 
}

Вообще можно в функции дополнительный блок делать и там писать нужную переменную и при выходе из блока она удалиться сама (если стёковая):

Код:

int BIG_f() 
{
 {
  D d;
  //.............. 
 }
 // тут d уже нету :(
 //.............
}

[SlavaI]

А если делать так, то проблем не будет:
Код:
class D
{
int* pi;
public:
D(){ pi = (int*)new int[10]; };
~D(){ delete[] pi; pi = NULL; };
};

int _tmain(int argc, _TCHAR* argv[])
{
D d;
d.~D();
}

Ты хоть понимаешь почему тут проблем нет? Потому что delete при получении нулевого указателя ничего не делает.
Ты что действительно не понимаешь, что вызываешь деструктор два раза? И пытаешься доказать что самому вызывать деструктор для стековой переменной это правильно и очень хорошо.
А если класс управляет станком и конструктор передвигает резец на n миллиметров, а деструктор отодвигает обратно на n миллиметров, так вот у тебя отодвинется на 2*n миллиметров, представляешь что он у тебя выточит. Хорошо если станком, а не самолетом, а то закрылки вместо F градусов на 2*F отвернутся, такая радость пилоту будет, хорошо если самолет военный и есть система катапультации, но вот если и эта система также написана, жалко пилота.

Насладись еще раз этим шедевром

Код:

#include <iostream.h>

class D 
{
int* pi;
float& grad; 
public: 
D(float& g):grad(g){
            pi = (int*)new int[10]; 
            cout<< "turn flap"<<endl; 
            grad+=10;}

~D(){
      delete[] pi; 
      pi = NULL;
      cout<< "return flap"<<endl; 
      grad -= 10;
      if(grad<0)
	  {
		  cout<<"Bye-bye guy!"<<endl;
	  }}
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{
float grad=0;
D d(grad); 
d.~D(); 
}

[Sashok]

Fatal Error, возьми, да поставь в деструктор вывод на экран - четко увидишь, что у тебя происходит.

[ysv_]

Этот деструктор второй раз вызовут при уходе из области видимости, это жестко зашито в код компилятором.

Наверное при окончании жизни объекта. Все таки область видимости и время жизни разные понятия. (Например static объекты).

[Sashok]

Этот деструктор второй раз вызовут при уходе из области видимости, это жестко зашито в код компилятором.

Наверное при окончании жизни объекта. Все таки область видимости и время жизни разные понятия. (Например static объекты).

Безусловно!

[Гром]

ysv_, смотря где был произведен вызов конструктора...
Вернее даже не так - где был объявлен экземпляр объекта...
Если я внутри оъекта внутри одной из его функций объявлю класс, то как только я выйду за пределы ее, то именно это и произойдет.

[ysv_]

Гром, моя твоя не понимай.
Вызов деструктора всегда происходит при окончании жизни объекта. Просто для автоматических объектов уход из области видимости совпадает со времен окончания жизни.
А насчет твоего утверждения, как я его понял, вот код:

#include <iostream>

class A
{
  public:
  A() {std::cout<<"A\n";}
  ~A() {std::cout<<"~A\n";}

  void func()
  {
    static class B
    {
      public:
        B() {std::cout<<"B\n";}
        ~B() {std::cout<<"~B\n";}
    } b;
  }
};

int main()
{
  A a;
  a.func();
  return 1;
}

Вывод:
A
B
~A
~B

Т.е. А умирает при выходе из зоны видимости, а B - при завершении работы программы.

[Гром]

Ты не понял...

#include <iostream>
class A
{
public:
A() {std::cout<<"A\n";}
~A() {std::cout<<"~A\n";}
}

class B
{
public:
B() {std::cout<<"B\n";}
~B() {std::cout<<"~B\n";}
void func();

}



void B::func()
{
A a;
}


int main()
{
B b;
b.func();
return 1;
}

Я это имел ввиду - компайлера нет - сдох надо переставлять насколько я понимаю - проверб пожалуйста, вывод будет такой...

B
A
~A
~B

[Sashok]

Гром, так у тебя же оба объекта - auto, а у ysv_ объект a - auto, a объект b - static.

[SlavaI]

Наверное при окончании жизни объекта. Все таки область видимости и время жизни разные понятия. (Например static объекты).

Ну начались придирки. Ты видел статические стековые объекты? А мы говорили только о стековых объектах.

class A {};

void foo()
{
     static A a;// вовсе не означает что он в стеке.
}

[NetRaider]

Вызывать самостоятельно деструктор для стековых объектов(как это сделал ты) запрещено.

 

Напрямую вызывать деструктор можно и для стековой переменной - должно работать, у меня проблем не было.

 
Ну вот только не надо- я пробовал! Ты сказал абсолютно неверную вещь. Нельзя, и не спорь.

Такие категоричные ответы неплохо бы аргументировать.

После окончания времени жизни объектов(к этому приводит вызов деструктора первый раз) запрещено вызывать не только деструкторы:

12.4.14 Once a destructor is invoked for an object, the object no longer exists; the behavior is undefined if the
destructor is invoked for an object whose lifetime has ended ( 3.8 )
[Example: if the destructor for an automatic object is explicitly invoked, and the block is subsequently left in a manner that would ordinarily invoke implicit destruction of the object, the behavior is undefined.]

но и любые non-static функции-члены (3.8.6).

[SlavaI]

Такие категоричные ответы неплохо бы аргументировать.

А что, приведенная мной аргументация недостаточна, про двойной вызов деструктора? Обязательно привести выдержку из стандарта? Или ответ неправилен? Тут только два варианта- или можно или нет.

После окончания времени жизни объектов(к этому приводит вызов деструктора первый раз) запрещено вызывать не только деструкторы:

Как бы попроще сказать? -Чего вызывать? Нет объекта. От чего вызывать?
Все эти феньки с возможностью вызова второй раз деструктора и другие аномалии возможны только потому, что не затирается память, которую занимал объект и его структуры сохраняются, поэтому некоторые и умудряются что-то вызвать и даже получить какой-то результат. Так что это аномалии, не более того. И даже не стоит употреблять фразу "запрещено вызывать не только деструкторы", нечего вызывать на несуществующий объект.

[NetRaider]

А что, приведенная мной аргументация недостаточна, про двойной вызов деструктора? Обязательно привести выдержку из стандарта? Или ответ неправилен? Тут только два варианта- или можно или нет.

Недостаточна, поскольку основана на примерах, которые достаточно сложно придумать на все случаи. То есть ты говоришь что нельзя, подтверждаешь это конкретным примером, но некоторые придумав при что-то свое, вроде этого

Код:

class D 
{
int* pi; 
public: 
D(){ pi = (int*)new int[10]; }; 
~D(){ delete[] pi; pi = NULL; }; 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{
D d; 
d.~D(); 
}

уверенны что все "работает" правильно. Твоя аргументация не в силах объяснить что в этом случае имеется ошибка. Нельзя и все. По логике - да, объекта не существует, и все последующие вызовы деструкторов приводят к неопределенному поведению. Только стандарт не везде так же логичен как в этом случае. Поэтому я считаю ссылку на стандарт необходимой.

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

Где написано о том, что после вызова деструктора структуры сохраняются ? Эта особенность конкретных компиляторов, но не языка. Содержимое объекта после вызова деструктора неопределено. Все. Любые вызовы не статических функций от имени этого объекта приводят не к "аномалиям" а к неопределенному поведению, которое возникает в первую очередь от того, что не известно содержимое памяти объекта. На одном компиляторе содержимое может оставаться неизменным, на другом, например обнуляться. Но в рамках языка поведение в таких случаях является неопределенным.

[Fatal Error]

SlavaI  <<[/b] Спокойно, я понимаю в чем прикол и что деструктор дважды вызывается в данном случае. Но все-таки ручной вызов может быть полезным в некоторых случаях и вообще у меня привычка всем указателям после использование NULL присваивать.

[Xeysan]

Будет использоваться книга Бьерн Страуструп "Язык программирования С++, специальное издание".

Выдержки я набивать не буду, просто поставлю, какие главы смотреть.

2 Migmile

void * operator new( size_t cb )
{
void *res = _nh_malloc( cb, 1 );
RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));
return res;
}

Герб Саттер "Решение сложных задач на С++" ( C++ In-Depth ):

Достаточно важно различать кучу и свободную память, поскольку стандарт умышленно оставляет вопрос о взаимоотношении этих областей памяти открытым. Например, при освобождении памяти посредством ::operator delete последнее замечание в разделе 18.4.1.1 стандарта С++ гласит следующее.

Не определено, при каких условиях часть или вся освобожденная таким образом память будет выделена последующим вызовом operator new или любой из функций calloc, malloc, realloc, объявленным в <cstdlib>

Кроме того, не определено, должны ли операторы new/delete быть реализованы посредством malloc/free в конкретном компиляторе. Однако malloc/free не должны быть реализованы посредством new/delete в соотв. с разделами 20.4.6.3-4 стандарта.

Функция calloc(), malloc() и realloc не должны пытаться выделить память, используя вызов ::operator new.

Функция free() не должна пытаться освоб. память, используя вызов ::operator delete.

-------

Писать корректнее надо так Код:
A(int i) : a(i) {};

Кто тебе сказал, что это корректнее, можно писать и так и как я, никакой ошибки или неточности

нет. В моем случае сначала вызовется конструктор по умолчанию, а потом B& operator=(const B&),

но оптимизирующие компиляторы для встроенных типов не делают разницы между твоей и моей записью.

 
БС -> 10.4.6.1 и не надо вспоминать оптимиз. компиляторы...
-------

Все эти феньки с возможностью вызова второй раз деструктора и другие аномалии возможны только

потому, что не затирается память, которую занимал объект и его структуры сохраняются, поэтому

некоторые и умудряются что-то вызвать и даже получить какой-то результат. Так что это аномалии,

не более того. И даже не стоит употреблять фразу "запрещено вызывать не только деструкторы",

нечего вызывать на несуществующий объект.

Попробуй так
class A {
public:
void   f() { std::cout<<"Hello"; }
};
...
((A*)0)->f();

В msvc 7.0 вполне работает... ( нет обращ. к this )
-------
Насчет явного вызова деструктора:
БС -> 10.4.1 / 10.4.11

зы Литература серьезная, поэтому бейте меня стандартом

[NetRaider]

Попробуй так  
class A {
public:
void f() { std::cout<<"Hello"; }
};
...
((A*)0)->f();

В msvc 7.0 вполне работает...  ( нет обращ. к this )

Во-первых:

5.2.5
A postfix expression followed by a dot . or an arrow ­>,
optionally followed by the keyword template
(14.8.1), and then followed by an idexpression,
is a postfix expression. The postfix expression before the
dot or arrow is evaluated;

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

Что, в свою очередь, приводит к:

1.9 Program execution (intro.execution)
4 Certain other operations are described in this International Standard as undefined (for example, the effect of dereferencing the null pointer).

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

Тем не менее, следующий код не порождает неопределенного поведения:

Код:

#include <iostream>
#include <typeinfo>
 
struct A {
    void f() { std::cout<< "Hello\n"; } 
}; 


int main()
{
    std::cout << typeid(((A*)0)->f).name();
    return 0;
}

Так как в этом случае параметр 'typeid' не вычисляется(5.2.8/3).

[SlavaI]

Xeysan, вот твой код.

class A {
public:
void f() { std::cout<<"Hello"; }
};
...
((A*)0)->f();

Сразу скажу, что this там используется и в ф-цию передается- он просто NULL равен. Ты же не пытаешься получить доступ к нестатическим членам класса, поэтому и работает. А ф-ции всегда передается столько параметров, сколько надо.
 Не знаю к чему ты его привел, но отвечу - если ты так любишь цитаты приводить, что данный код приведен в книге B. Stroustrup "The design and evolution of C++" еще в 1994 году, там же он обозван "непереносимой конструкцией" и "бомбой замедленного действия" и объяснено почему(не только из-за разименования).

Литература серьезная, поэтому бейте меня стандартом

Так,NetRaider в тебя стандартом запустил уже. А я в тебя кидаю книжкой B. Stroustrup "The design and evolution of C++", но тебе повезло- она нетолстая.