destructor

I'm a little confused. Basically, I've got 2 different resource managers (AudioLibrary and VideoLibrary) that both inherit from a shared BaseLibrary class. This base class contains references to both audio and video. Both audio and video inherit from a parent class called Media. I'm keeping the data in a map, filled with unique_ptr. But, to my surprise, I've discovered when these pointers are eventually deleted via .erase, only the base destructor for Media is called. I guess I've missed something, but I thought that the compiler/run-time library would know that it's either pointing to a video

I'm currently trying to learn about classes and constructors/destructors. I understand what the two do, but I'm having a harder time with the destructors because I can't think of a practical application for its use. Can anyone provide an example with an explanation? Destructors are special member functions used to release any resources allocated by the object. The most common example is when the constructor of the class uses new , and the destructor uses delete to deallocate the memory. class Myclass { int *m_ptr; public: Myclass():m_ptr(new int) { } ~Myclass() { delete m_ptr; } //ToDo: Follow

I found this code on cppreference.com. It's the strangest C++ I've seen, and I have a few questions about it: union S { std::string str; std::vector<int> vec; ~S() {} }; int main() { S s = { "Hello, world" }; // at this point, reading from s.vec is undefined behavior std::cout << "s.str = " << s.str << '\n'; s.str.~basic_string<char>(); new (&s.vec) std::vector<int>; // now, s.vec is the active member of the union s.vec.push_back(10); std::cout << s.vec.size() << '\n'; s.vec.~vector<int>(); } I want to make sure I've got a few things right. The union forces you to initialise one of the union

This question already has an answer here: Why do new style class and old style class have different behavior in this case? 1 answer I'm trying to understand why object destruction works differently in new style classes compared to old style ones. class Wrapper(): class Inner(object): def __del__(self): print 'Inner destructor' innerInstance = Inner() def __del__(self): print 'Wrapper destructor' if __name__ == '__main__': x = Wrapper() on exit, this will output: Wrapper destructor Inner destructor however, if i use Wrapper as a new style class, only the wrapper destructor is called, and the

I have a code that is leaking on Windows. It runs fine on many unix platforms and the leak only occurs on Windows. The binary consists of exe, 1 dll and 2 static libs. The exe links to both the dll and the static libs, while the static libs link with the dll as well. The leak occurs in the exe code when instead of calling to a vector deleting destructor, for some reason scalar deleting destructor is called. This results in only the first object in the array to be deleted while the rest of the array stays in memory. The leaking pseudo-code looks like this: class MyClassFromExe : public

When can an object of a class call the destructor of that class, as if it's a regular function? Why can't it call the constructor of the same class, as one of its regular functions? Why does the compiler stops us from doing this? For example: class c { public: void add() ; c(); ~c() ; }; void main() { c objC ; objC.add() ; objC.~c() ; // this line compiles objC.c() ; // compilation error } By definition, a constructor is only called once, when the object is created. If you have access to an object, then it must have been created, so you're not allowed to call the constructor again - this is