личное самоустранение STL, когда экземпляр класса был destucrt? [Дубликат]

Это невозможно в Entity Framework. Вы либо включаете всю таблицу (с Include, как вы это делаете), либо вообще не включаете ее. Если вы хотите загрузить только определенные столбцы, вы можете сделать это, но посмотрите, как это ручной процесс:

Context
    .Select(i => new YourType
    {
        c = i.l,
        l = i.l,
        x = new X 
        {
            a = i.x.a // only the properties you want here
        }
        ...
    });

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

144
задан Unihedron 10 August 2014 в 16:33
поделиться

11 ответов

Деструктор A будет работать, когда закончится его время жизни. Если вы хотите освободить память и запустить деструктор, вы должны удалить ее, если она была выделена в куче. Если он был выделен в стеке, это происходит автоматически (т. Е. Когда оно выходит за пределы области видимости, см. Раздел RAII). Если это член класса (не указатель, а полный член), то это произойдет, когда содержащийся объект будет уничтожен.

class A
{
    char *someHeapMemory;
public:
    A() : someHeapMemory(new char[1000]) {}
    ~A() { delete[] someHeapMemory; }
};

class B
{
    A* APtr;
public:
    B() : APtr(new A()) {}
    ~B() { delete APtr; }
};

class C
{
    A Amember;
public:
    C() : Amember() {}
    ~C() {} // A is freed / destructed automatically.
};

int main()
{
    B* BPtr = new B();
    delete BPtr; // Calls ~B() which calls ~A() 
    C *CPtr = new C();
    delete CPtr;
    B b;
    C c;
} // b and c are freed/destructed automatically

В приведенном выше примере каждое удаление и удаление [ ] необходим. И никакое удаление не требуется (или действительно может быть использовано), где я его не использовал.

auto_ptr, unique_ptr и shared_ptr и т. Д. ... отлично подходят для такого управления жизненным циклом проще:

class A
{
    shared_array<char> someHeapMemory;
public:
    A() : someHeapMemory(new char[1000]) {}
    ~A() { } // someHeapMemory is delete[]d automatically
};

class B
{
    shared_ptr<A> APtr;
public:
    B() : APtr(new A()) {}
    ~B() {  } // APtr is deleted automatically
};

int main()
{
    shared_ptr<B> BPtr = new B();
} // BPtr is deleted automatically
163
ответ дан MatrixFrog 25 August 2018 в 11:17
поделиться
class B
{
public:
    B()
    {
       p = new int[1024];  
    }
    virtual ~B()
    {
        cout<<"B destructor"<<endl;
        //p will not be deleted EVER unless you do it manually.
    }
    int *p;
};


class D : public B
{
public:
    virtual ~D()
    {
        cout<<"D destructor"<<endl;
    }
};

Когда вы выполните:

B *pD = new D();
delete pD;

Деструктор будет вызываться, только если ваш базовый класс имеет ключевое слово virtual.

Тогда, если у вас не было виртуального деструктора, вызывается только ~ B (). Но поскольку у вас есть виртуальный деструктор, вызывается первая ~ D (), а затем ~ B ().

Никакие члены B или D, выделенные в куче, не будут освобождены, если вы их явно не удалите. И удаление их также вызовет их деструктор.

2
ответ дан Brian R. Bondy 25 August 2018 в 11:17
поделиться

Вы должны удалить A самостоятельно в деструкторе B.

4
ответ дан corné 25 August 2018 в 11:17
поделиться

no, он не будет вызывать деструктор для класса A, вы должны явно называть его (например, PoweRoy), удалить строку 'delete ptr;' в примере для сравнения ...

  #include <iostream>

  class A
  {
     public:
        A(){};
        ~A();
  };

  A::~A()
  {
     std::cout << "Destructor of A" << std::endl;
  }

  class B
  {
     public:
        B(){ptr = new A();};
        ~B();
     private:
        A* ptr;
  };

  B::~B()
  {
     delete ptr;
     std::cout << "Destructor of B" << std::endl;
  }

  int main()
  {
     B* b = new B();
     delete b;
     return 0;
  }
0
ответ дан Darius Kucinskas 25 August 2018 в 11:17
поделиться

У вас есть что-то вроде

class B
{
   A * a;
}
B * b = new B;
b->a = new A;

. Если вы затем вызываете delete b;, ничего не происходит с a, и у вас есть утечка памяти. Попытка запомнить delete b->a; не является хорошим решением, но есть пара других.

B::~B() {delete a;}

Это деструктор для B, который удалит a. (Если a равно 0, это удаление ничего не делает. Если a не является 0, но не указывает на память от нового, вы получаете повреждение кучи.)

auto_ptr<A> a;
...
b->a.reset(new A);

Таким образом, у вас нет как указатель, а скорее auto_ptr & lt;> (shared_ptr & lt;> будет делать также или другие интеллектуальные указатели), и он автоматически удаляется, когда b.

Любой из этих способов работает хорошо, и я Вы использовали оба.

0
ответ дан David Thornley 25 August 2018 в 11:17
поделиться

Мне было интересно, почему мой деструктор класса не был вызван. Причина в том, что я забыл включить определение этого класса (#include "class.h"). У меня было только объявление типа «класс А»; и компилятор был доволен этим, и позвольте мне называть «delete».

1
ответ дан Harri Luoma 25 August 2018 в 11:17
поделиться

Деструктор для объекта класса A будет вызываться только при вызове delete для этого объекта. Обязательно удалите этот указатель в деструкторе класса B.

Для получения дополнительной информации о том, что происходит при вызове delete на объект, см.: http://www.parashift.com /c++-faq-lite/freestore-mgmt.html#faq-16.9

0
ответ дан Kris Kumler 25 August 2018 в 11:17
поделиться

Нет. указатель будет удален. Вы должны называть delete в A явным в деструкторе B.

0
ответ дан RvdK 25 August 2018 в 11:17
поделиться

Он называется «деструктор», а не «deconstructor».

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

edit: Чтобы уточнить:

Скажите, что у вас есть

struct A {}

class B {
    A *a;
public:
    B () : a (new A) {}
    ~B() { delete a; }
};

class C {
    A *a;
public:
    C () : a (new A) {}        
};

int main () {
    delete new B;
    delete new C;
}

Выделение экземпляра B, а затем удаление является чистым, потому что то, что B выделяет внутри, также будет удалено в деструкторе.

Но экземпляры класса C будут утечки памяти, поскольку он выделяет экземпляр A, который он не выпускает (в этом случае C даже не имеет деструктора).

22
ответ дан Sebastian Mach 25 August 2018 в 11:17
поделиться

Если у вас есть обычный указатель (A*), деструктор не будет вызван (и память для экземпляра A не будет освобождена), если вы не сделаете delete явно в деструкторе B. Если вы хотите автоматическое уничтожение, посмотрите на интеллектуальные указатели, такие как auto_ptr.

5
ответ дан Unihedron 25 August 2018 в 11:17
поделиться

Когда вы вызываете delete на указателе, выделенном new, вызывается деструктор объекта, на который указывает.

A * p = new A;

delete p;    // A:~A() called for you on obkect pointed to by p
27
ответ дан user 25 August 2018 в 11:17
поделиться