destructor

Consider the following code: #include <iostream> #include <type_traits> // Abstract base class template<class Crtp> class Base { // Lifecycle public: // MARKER 1 Base(const int x) : _x(x) {} protected: // MARKER 2 ~Base() {} // Functions public: int get() {return _x;} Crtp& set(const int x) {_x = x; return static_cast<Crtp&>(*this);} // Data members protected: int _x; }; // Derived class class Derived : public Base<Derived> { // Lifecycle public: Derived(const int x) : Base<Derived>(x) {} ~Derived() {} }; // Main int main() { Derived d(5); std::cout<<d.set(42).get()<<std::endl; return 0; } If

I have template class Array where the template type T should be either pointer or not-pointer type. template<class T> class TArray { static const int max_len=100; T* data; int length; public: TArray(){data=new T[max_len]; this->length=0;} void Add(T value){data[length++]=value;} ~TArray(); }; The problem is how to free space, since we can not call delete for not pointer types like this template<class T> TArray<T>::~TArray() { //for(int i =0; i < length; i++) // delete data[i]; // NOT WORKING WITH OBJECTS THAT ARE NOT POINTERS !!! delete[] data; } Let's have addition class class A { int* a;

I have a SQL class that connects to the DB and retreives a DataTable. I am aware that the SqlConnection must be disposed when finished. I know this can be done using a using block, but is it also acceptable to put the Dispose() call inside the destructor of this class? Herre is my code: public class SQLEng { //Connection String Property //Must be set to establish a connection to the database public string ConnectionString{ get; set; } SqlConnection _Conn; //Overridden Constructor enforcing the Connection string to be set when created public SQLEng(string connectionString) { ConnectionString =

If I have a class with an array of pointers to another class Vehicle : class List { public: //stuff goes here private: Vehicle ** vehicles; } If I now write the destructor of the class List , do I manually iterate over the array (I know how many items are in the array) and delete every pointer to a vehicle, or will C++ automatically call the destructors of all the Vehicles in the array? (Like it does if there's a private string/... in the class or if it would be a STL container of Vehicle pointers) EDIT: I forgot about delete [] vehicles , but if I would do that, would it also delete the

matrix m1(5,5); matrix m2(5,5); m1 = matrix(m2); For the above code (for an arbitrary class, matrix), will the destructor be called for the information associated with m1, when the information of m2 is copied over to it? No, an assignment operator will need to deal with releasing whatever resources m1 may hold before performing an assignment. The destructor will be called only when m1 is about to go out of scope. No, once an object which is allocated on the stack is constructed it isn't deconstructed until it either goes out of scope or you call its destructor explicitly (which you should

The following is the C++ source code. The code has a class HumanBeing and with Display and verify functions. Each function prints statements. #include <iostream> using namespace std; class HumanBeing { public: void display() { cout << "hello aam a human being" << endl; } void print() { cout << "verify print" << endl; } }; int main() { HumanBeing vamshi; vamshi.display(); vamshi.print(); return 0; } This is the corresponding assembly code of the above c++ code .file "verify.cpp" .local _ZStL8__ioinit .comm _ZStL8__ioinit,1,1 .section .rodata .LC0: .string "hello aam a human being" .section

Suppose you have an object which can be accesed by many threads. A critical section is used to protect the sensitive areas. But what about the destructor? Even if I enter a critical section as soon as I enter the destructor, once the destructor has been called, is the object already invalidated? My train of thought: Say I enter the destructor, and I have to wait on the critical section because some other thread is still using it. Once he is done, I can finish destroying the object. Does this make sense? In general, you should not destroy an object until you know that no other thread is using

I have one question about failed constructor and failed destructor in C++. I noticed that when the constructor failed, an exception will be thrown. But there is no exception thrown in destructor. My question is 1) If constructor failed, what exception will be thrown? bad_alloc? or anything else related? Under what situation, a constructor would fail? What about the successfully constructed part? 2) Under what situation, a destructor would fail? If no exception is thrown, what would happen to the destructor? How does the compiler deal with it? What's the return value to the function it is