destructor

I have some problems with destructor, in next code: #include <stdlib.h> #include <cstdio> class Foo2 { public: Foo2() { printf("foo2 const\n"); } ~Foo2() { printf("foo2 dest\n"); // <--- wasn't called for bionic libc } }; static Foo2& GetFoo2() { static Foo2 foo2; printf ("return foo2\n"); return foo2; } class Foo1 { public: Foo1() { printf("foo1 const\n"); } ~Foo1() { printf("foo1 dest\n"); GetFoo2(); } }; int main( int argc, const char* argv[] ) { printf("main 1 \n"); static Foo1 anotherFoo; printf("main 2 \n"); } Why destructor for foo2 wasn't called for bionic and was for glibc ? EDIT

I need to create a service which will maintain a WCF session. In the constructor I read in data from the DB and when the session ends I have to save it back. If I understand correctly the session ends when I call Close() on the Client (My client ServiceClient was created with SvcUtil.exe). When I test it I see that it is sometimes called after approx. 10 minutes, sometimes after 20 minutes and sometimes not at all. So when is the destructor called? Service [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)] public class Service:IService { private User m_User = null; public

Actually I am thinking about trivially destructible objects, not only about POD (I am not sure POD can have base class). When I read this explanation for is_trivially_destructible from cppreference I notice this: Storage occupied by trivially destructible objects may be reused without calling the destructor. So, it is safe to do that: struct A { int a; }; struct B : A { int b; }; int main() { A* a = new B; delete a; } B::~B() won't be called - and AFAIK (please correct if I am wrong) the entire memory will be freed. And B::~B() for sure is trivial. I know this code smells badly, but my

Consider this test case: class MyObject : public QObject { Q_OBJECT public: MyObject() { qDebug() << "MyObject constructor"; } virtual ~MyObject() { qDebug() << "MyObject destructor"; } }; class Tracker : public QObject { Q_OBJECT public: Tracker() {} public slots: void onDestructor() { qDebug() << "About to be destroyed!"; } }; int main(int argc, char** argv) { QCoreApplication app(argc, argv); Tracker tracker; MyObject *obj = new MyObject(); QObject::connect(obj, SIGNAL(destroyed()), &tracker, SLOT(onDestructor())); delete obj; return app.exec(); } It prints this: MyObject constructor

I have a linked_list and currently my destructor is not working properly. Not entirely sure why. Can somebody explain me how to solve this? class linked_list { private: struct node { // String in this node std::string data; // Pointer to next node struct node *next; }; //First item in the list struct node *first; Here is my destructor linked_list::~linked_list(void) { while (first) { delete first; first = first->next; } } The problem lies here: delete first; first = first->next; When you delete first , but then try to access first->next . Cache first->next into a temp variable of type node* ,