test.cpp

struct der
{
	private:    // No resources :-(
		int *p=new int[4];             // This is a resource.
                                   // If you don't do anything it will leak.
	public:
}; 

struct derWithDestructorOnly: public base
{
	private:  
		int *p=new int[4];
	public:
	    ~derWithDestructorOnly() {
	        delete [] p;      // When the object is destroyed you need to relase the memory.
	    }
            // This is still broken as it does not implement the rule of three see below.	
}; 

struct derWithRuleOfThree: public base
{
	private:  
		int *p=new int[4];
	public:
	    ~derWithRuleOfThree() {
	        delete [] p;      // When the object is destroyed you need to relase the memory.
	    }
	    derWithRuleOfThree(derWithRuleOfThree const& rhs) {
	        for(int loop = 0; loop < 4; ++loop) [
		    p[loop] = rhs.[loop];
		}	        
	    }
	    derWithRuleOfThree& operator=(derWithRuleOfThree const& rhs) {
	        for(int loop = 0; loop < 4; ++loop) [
		    p[loop] = rhs.[loop];
		}
		return *this;
	    }
}; 

int test1()
{
    der  			derObject;
}
   // Object out of scope.
   // the destructor did not clean it up you leaked 4 bytes of memory.

int test2()
{
    derWithDestructorOnly	derObject;
}
// Worked correctly the memory was correctly released by the destructor of the object.

int test3()
{
    derWithDestructorOnly	derObjectOne;   // derObjectOne.p  = 0x456780
    derWithDestructorOnly	derObjectTwo;   // derObjectOne.p  = 0x4567A0
	
    derObjectTwo = derObjectOne;
    // Whoops.
    // The rule of three was not implemented.
    //     derObjectTwo.p == derObjectOne.p == 0x456780 
    //     You have lost all reference to 0x4567A0 (so this memory has now leaked.
}
    // The destructor of derObjectTwo is called first.
    // It calls delete [] 0x456780 thats fine.
    // The destructor of derObjectOne is called next.
    // It calls delete [] 0x456780 thats A PROBLEM as you just deleted it.

int test4()
{
    derWithRuleOfThree	derObjectOne;   // derObjectOne.p  = 0x456780
    derWithRuleOfThree	derObjectTwo;   // derObjectOne.p  = 0x4567A0
	
    derObjectTwo = derObjectOne;
    // Everything works.
}

Now I get all you are saying. When we have resources(dynamic memory allocation through new) it's our responsibility to free them. so we have to free this just before that object lifetime ends otherwise after destruction of object memory is going to leak. so we are doing that by using delete keyword in destructor. and you are talking about this work we have to do when we have resources right ?

But I have one Question why memory will not leak in derWithRuleOfThree but leak in derWithDestructorOnly. As ultimately in derWithRuleOfThree we are copying derObjectOne to derObjectTwo. so ptr variable p in derObjectTwo get address of variable which pointed by ptr varible p of derObjectOne. so it's obivious that memory will leak. https://stackoverflow.com/a/4172724/11862989 in his answer fredoverflow(user with 237k Rep) said regarding Rule of three " "Unfortunately, this "rule" is not enforced by the C++ standard or any compiler I am aware of.".