• Выделение памяти необходимое для всего объекта Base + Derived + ...
  
• "Стандартное конструирование части Base" — все поля(члены) Base нулями и установка указателя на таблицц виртульных функции Base
  
• "Пользовательское конструирование" части Base
  
• "Стандартное конструирование части Derive" — все поля(члены) Derived нулями и установка указателя на таблицц виртульных функции Base
  
• "Пользовательское конструирование" части Base
  
• ...

• ...
  
• Установка указателя на таблицц виртульных функции Derived — части MoreDerived нет
  
• "Пользовательское разрушение/файнализинг" части Derived
  
• "Стандартное разрушение/файнализингчасти Derived" — все поля(члены) Derived нулями и удаление gcrootов
  
• Установка указателя на таблицц виртульных функции Base — части Derived нет
  
• "Пользовательское разрушение/файнализинг" части Base
  
• "Стандартное разрушение/файнализингчасти Base " — все поля(члены) Base нулями и удаление gcrootов
  
• Отдаем память

class Base
{
    ~Base()
    {
         foo();
    }

    public virtual void foo()
    {
        Console.WriteLine("Base::foo");
    }
}

class Derived : Base
{
    public overide void foo()
    {
        Console.WriteLine("Derived::foo");
    }
}

class Program
{
    public static void Main()
    {
        Base b = new Derived;
        b = null;
        GC.Collect();
    }
}

ref struct Base
{
    ~Base()
    {
        foo(); 
    }

    virtual void foo()
    {
        Console::WriteLine("Base::foo");
    }
};

ref struct Derived : Base
{
    virtual void foo() override
    {
        Console::WriteLine("Derived::foo");
    }
};

int main()
{
    Base ^ b = gcnew Derived;
    delete b;
}

struct Base
{
    ~Base()
    {
        foo(); 
    }

    virtual void foo()
    {
        
    }
};

struct Derived : Base
{
    virtual void foo()
    {
        std::cout << "Derived::foo" << std::endl;
    }
};

int main()
{
    Base * b = new Derived;
    delete b;
}

class Base
{
    ~Base()
    {
         foo();
    }

    public virtual void foo()
    {
        Console.WriteLine("Base::foo");
    }
}

class Derived : Base
{
    Derived () { ... }

    ~Derived ()
    {
        o.Dispose();
    }
    public overide void foo()
    {
        o.HelloWorld();
        Console.WriteLine("Derived::foo");
    }

    DisposableObject o;
}

class Program
{
    public static void Main()
    {
        Base b = new Derived;
        b = null;
        GC.Collect(); //тыдыж!!!! :(
    }
}

A>Ужос!

struct Base
{
    void foo(float) { cout << "float"; }
};

struct Derived : Base
{
    void foo(int)    { cout << "int"; }
};

void bar()
{
    Derived d;

    d.foo(4.35); //ок :)) выведет int
}

ref struct Base2
{
    void foo(float) { cout << "float"; }
};

ref struct Derived2 : Base2
{
    void foo(int)    { cout << "int"; }
};

void bar2()
{
    Derived2 d;

    d.foo(4.35); //не ок :)) выведет float
}

A>Отныне настаиваю на изгнании обсуждений C++/CLI со страниц славного форума по C++!

PC>>Я в шоке Читаю стандарт С# и С++/CLI.

class C
 {
  public:

   C();

   void init(int a,int b,int c);
 };

C c;

c.init(1,2,3);

class Base
 {
  public Base() { doIt(); }

  public virtual void doIt() {}
 }

class Derived : Base
 {
   SomeClass obj;

  public Derived()
   {
    obj=new SomeClass();
   }

  public override void doIt() { obj.method(); }
 }

PC>Там еще очень много подстав... Статью что-ли написать?

PC>    d.foo(4.35); //не ок :)) выведет float
PC>

d.foo((int)4.35);

d.foo(4.35F);

struct code_line
{
    int num;
    ...
    template<class Archive> void serialize(Archive & ar)
    {
        ar & num;
    }
};

struct file_coverage_info
{
    std::hash_map<code_line,int> lines_hit;
    std::set<code_line> lines_missed;
    std::set<code_line> lines_uncompiled;

    template<class Archive> void serialize(Archive & ar)
    {
        ar & lines_hit & lines_missed & lines_uncompiled;
    }
};

class Base 
{
  private: 
    Handle m_fileHandle;
    protected: 
  virtual void Close()
    {
      CloseHandle(m_fileHandle);
    }
    virtual ~Base()
    {
      Close(); // 
    }
}

class Derived : public Base
{
  private:
    void* m_buffer;
    virtual void Close()
    {
      delete[] m_buffer;
        Base::Close();
    }
}

PC>Почему ты так уверен, что я это не понимаю?

1.1.4 stable rev. 510

A>>Ужос!

PC>Для native типов в С++/CLI все остается по прежнему

PC>Там еще очень много подстав... Статью что-ли написать?

using namespace System::IO;

int main() {
    FileStream f = File::Create("test"); // error C3673: 'System::IO::FileStream' : class does not have a copy-constructor
    FileStream f = FileStream("test", FileMode::Create); // error C3673
    FileStream f("test", FileMode::Create); // OK
}

S>class Base 
S>{
S>  private: 
S>    Handle m_fileHandle;
S>    protected: 
S>  virtual void Close()
S>    {
S>      CloseHandle(m_fileHandle);
S>    }
S>    virtual ~Base()
S>    {
S>      Close(); // 
S>    }
S>}

S>class Derived : public Base
S>{
S>  private:
S>    void* m_buffer;
S>    virtual void Close()
S>    {
S>      delete[] m_buffer;
S>        Base::Close();
S>    }
S>}
S>

void base::close()
{
    CloseHandle(handle_);
    handle_ = INVALID_HANDLE; //вроде так... забыл Win API :shuffle:
}

void derived::close()
{
    delete[] buffer_;
    buffer_ = 0;
}