class - double free or corruption (fasttop) -- c++

I just came across a strange problem. I will paste the full code below:

#include 

#include 
#include 

using namespace std;

    // declare a base class
    class Base
    {
      public:
        Base();

        Base(int n, int arr[2]);
        Base(const Base &base);

        Base &operator=(const Base &rhs);

        int getSize() const;
        int *getA() const;

        ~Base();


      private:
        int *a;
        int size;
    };

    class Case
    {
      public:
        Case();
        Case(int n, int arr[2]);

        Case(const Case &rhs);

        Case &operator=(const Case &rhs);

        int getSize() const;
        int *getA() const;

        ~Case();

      private:

        int *a;
        int size;
    };

    class Dase
    {
      public:
        Dase();
        Dase(int bSize, int barr[2], int cSize, int carr[2]);
        Dase(const Dase &dase);


        Dase &operator=(const Dase &rhs);

        Base getB() const;
        Case getC() const;

        ~Dase();

      private:
        Base b;

        Case c;
    };

// implementation
Base::Base() : size(0)
{
    a = NULL;
}

Base::Base(int n, int arr[2]) : size(n)

{
    a = new int[n];
    for (int i = 0; i < size; i++)
        a[i] = arr[i];
}

Base::Base(const Base &base)
{
    size = base.getSize();


    a = new int[size];
    for (int i = 0; i < size; i++)
        a[i] = base.getA()[i];
}

Base &Base::operator=(const Base &rhs)
{
    if (this == &rhs)
        return *this;


    size = rhs.getSize();
    delete[] a;
    a = new int[size];
    for (int i = 0; i < size; i++)
        a[i] = rhs.getA()[i];
    return *this;
}

int *Base::getA() const
{

    return a;
}

int Base::getSize() const
{
    return size;
}

Base::~Base()
{

    delete[] a;
}

Case::Case() : size(0)
{
    a = NULL;
}

Case::Case(int n, int arr[2]) : size(n)
{

    a = new int[n];
    for (int i = 0; i < size; i++)
        a[i] = arr[i];
}

Case::Case(const Case &rhs)
{
    size = rhs.getSize();

    a = new int[size];

    for (int i = 0; i < size; i++)
        a[i] = rhs.getA()[i];
}

Case &Case::operator=(const Case &rhs)
{
    if (this == &rhs)
        return *this;

    size = rhs.getSize();

    delete[] a;
    a = new int[size];
    for (int i = 0; i < size; i++)
        a[i] = rhs.getA()[i];

    return *this;
}

int *Case::getA() const
{

    return a;
}

int Case::getSize() const
{
    return size;
}

Case::~Case()
{

    delete[] a;
}

// implement class Dase
Dase::Dase() : b(Base()), c(Case())
{
    // delebrately left empty
}

Dase::Dase(int bSize, int barr[2], int cSize, int carr[2])

{
    b = Base(bSize, barr);
    c = Case(cSize, carr);
}

Dase::Dase(const Dase &dase)
{
    b = dase.getB();
    c = dase.getC();
}


Dase &Dase::operator=(const Dase &rhs)
{
    if (this == &rhs)
        return *this;

    b = rhs.getB();
    c = rhs.getC();

    return *this;

}

Base Dase::getB() const
{
    return b;
}

Case Dase::getC() const
{
    return c;

}

Dase::~Dase()
{
    b.~Base();
    c.~Case();
}

In the above code, I defined 3 classes: Base, Case, Dase. I included their declarations and implementations. The following is the main code:

#include "classes.h"

int main()
{
    int arr[2] = {1, 2};

    int brr[2] = {3, 4};

    Dase d1(2, arr, 2, brr);
    Dase d2;

    d2 = d1;
}

This is a very simple main code, but I got "double free or corruption (fasttop)" error in the runtime.

I noticed that when I deleted the destructor in the class Dase, this problem went away. What shall I do to fix this problem if I want to keep the destructor for Dase? Shall I change its implementation?

Thank you!

Answer

You should not call destructors explicitly. It's done automatically.

So, replace

Dase::~Dase()
{
    b.~Base();
    c.~Case();
}

with

Dase::~Dase()
{
}