destructor

I have a templated class, myFoo, which stores "stuff" of type T which can be either primitive or pointers to complex types. When myFoo is deleted, I want to release all the memory associated with everything it happens to be storing. This means I need to call delete on every pointer being stored but I might also end up calling delete on a primitive. Is this safe?? I've included a sketch of myFoo below to better highlight what's going on. I'm not sure if the behaviour of the destructor is well defined. template<class T> class myFoo { public: myFoo(int size) { size_ = size; T* foo = new T[size_];

I'm trying to write a unit test that detects an invalid use of the lock() feature of my class. In order to do so, I want to use the destructor and throw an exception from there. Unfortunately, instead of catching the exception, g++ decides to call std::terminate(). There is a very simplified version of the class: class A { public: A() : f_lock(0) {} ~A() { if(f_lock) throw my_exception("still locked"); } lock() { ++f_lock; } unlock() { --f_lock; } private: int f_lock; }; There is a valid test: A *a = new A; a->lock(); ... a->unlock(); delete a; There is the invalid test I'm trying to write: A

This question already has an answer here: Pseudo-destructor call does not destroy an object 1 answer The following program... int main() { int{1}.~int(); } does not compile on (see conformance viewer ) : clang++ trunk, with -std=c++1z g++ trunk, with -std=c++1z CL 19 2017 Introducing a type alias for int ... int main() { using X = int; int{1}.~X(); } ...makes the program valid on all previously mentioned compilers, without warnings (see conformance viewer ) . Why is a type alias required when invoking int 's destructor? Is this because int is not a valid grammar element for a destruction

recently in a job interview I was asked about the problem of leaking memory in derived classes when the base class's destructor is not declared virtual. I wrote a small test to confirm my answer, but I found something interesting. Obviously, if you create a Derived object via new but store its pointer as a Base* , the derived object's destructor won't be called, if the pointer is deleted (so much for my answer to the question). I thought whether the derived class's destructor is virtual or not is irelevant in that case, but on my system the following code shows otherwise: #include <iostream>

When I'm inside a destructor is it possible that some other thread will start executing object's member function? How to deal with this situation? C++ has no intrinsic protection against using an object after it's been deleting - forget about race conditions - another thread could use your object after it's been completely deleted. Either: Make sure only one place in the code owns the object, and it's responsible for deleting when no-one is using the object. Make the object reference counted - by added explicit reference counting code, or finding an appropriate base-class that implements

Say, I have my own C# class defined as such: public class MyClass { public MyClass() { //Do the work } ~MyClass() { //Destructor } } And then I create an instance of my class from an ASP.NET project, as such: if(true) { MyClass c = new MyClass(); //Do some work with 'c' //Shouldn't destructor for 'c' be called here? } //Continue on I'd expect the destructor to be called at the end of the if scope but it never is called. What am I missing? The equivalent to a C++ destructor is IDisposable and the Dispose() method, often used in a using block. See http://msdn.microsoft.com/en-us/library/system

I saw a presentation on cppcon of Piotr Padlewski saying that the following is undefined behaviour: int test(Base* a){ int sum = 0; sum += a->foo(); sum += a->foo(); return sum; } int Base::foo(){ new (this) Derived; return 1; } Note: Assume sizeof(Base) == sizeof(Derived) and foo is virtual. Obviously this is bad, but I'm interested in WHY it is UB. I do understand the UB on accessing a realloc ed pointer but he says, that this is the same. Related questions: Is `new (this) MyClass();` undefined behaviour after directly calling the destructor? where it says "ok if no exceptions" Is it valid