destructor

Suppose there exists a type T such that std::is_trivially_destructable<T>::value == true , and suppose further that T is the value type of some vector class. When the vector's destructor is called, or the vector is assigned to another vector, it must destroy and deallocate its current storage. As T is trivially destructable, is it necessary that I call T 's destructor? Thanks for your help! According to the C++ Standard (section 3.8), you can end an object's lifetime by deallocating or reusing its storage. There's no need to call a destructor that does nothing. On the other hand, letting the

Destructors are weird . I was attempting to eliminate the need of using the disposable pattern by using 'smart' reference management, ensuring that the garbage collector could collect objects at the correct time. In one of my destructors I had to wait for an event from another object, which I noticed it didn't. The application simply shut down and the destructor was terminated in middle of execution. I'd expect a destructor is always allowed to finish running, but as the following test indicates that is not true. using System; using System.Diagnostics; using System.Threading; namespace

I was reading about different ways to clean up objects in Python, and I have stumbled upon these questions ( 1 , 2 ) which basically say that cleaning up using __del__() is unreliable and the following code should be avoid: def __init__(self): rc.open() def __del__(self): rc.close() The problem is, I'm using exactly this code, and I can't reproduce any of the issues cited in the questions above. As far as my knowledge goes, I can't go for the alternative with with statement, since I provide a Python module for a closed-source software (testIDEA, anyone?) This software will create instances of

I'm reading around the web and the documentation but to be honest, I don't get it. Since I'm new to cocos2d-x I would like to understand better how the objects are created/retained and what I'm supposed to do to release them (if required). The thing that confuses me is the usage of smart pointers that I don't know very well. Imagine that in my CCLayer (added to the CCScene) I add a CCSprite, so i do: this->sprite = CCSprite::create("mySprite.png"); this->addChild(sprite); then since I've used create() I'm supposed to release it somewhere? in the destructor of the CCLayer maybe? or I have

#include <iostream> #include <vector> using namespace std; int main() { vector< vector<int> > dp(50000, vector<int>(4, -1)); cout << dp.size(); } This tiny program takes a split second to execute when simply run from the command line. But when run in a debugger, it takes over 8 seconds. Pausing the debugger reveals that it is in the middle of destroying all those vectors. WTF? Note - Visual Studio 2008 SP1, Core 2 Duo 6700 CPU with 2GB of RAM. Added: To clarify, no, I'm not confusing Debug and Release builds. These results are on one and the same .exe, without even any recompiling inbetween.

As far as I know, I should destroy in destructors everything I created with new and close opened filestreams and other streams. However, I have some doubts about other objects in C++: std::vector and std::string s: Are they destroyed automatically? If I have something like std::vector<myClass*> of pointers to classes. What happens when the vector destructor is called? Would it call automatically the destructor of myClass ? Or only the vector is destroyed but all the Objects it contains are still existant in the memory? What happens if I have a pointer to another class inside a class, say:

Does Qt automatically remove connections between objects , when one of the side is deleted ? e.g connect (A .. , B ..) , when A (a pointer) is deleted , or B is deleted , will the connection be disconnected ? Is it necessary to use disconnect explicitly in destructor ? Yes, the QObject::~QObject destructor takes care of that: All signals to and from the object are automatically disconnected, and any pending posted events for the object are removed from the event queue. However, it is often safer to use deleteLater() rather than deleting a QObject subclass directly. Do take care though: Warning

I have a PHP class that creates a PNG image on the fly and sends it to browser. PHP manual says that I need to make sure that imagedestroy function is called at end to release the memory. Now, if I weren't using a class, I would have some code like this: function shutdown_func() { global $img; if ($img) imagedestroy($img); } register_shutdown_function("shutdown_func"); However, I believe that appropriate place for my class would be to place a call to imagedestroy in class' destructor. I failed to find out if destructors get called the same way shutdown functions does? For example, if execution