继承类中的内存分配和operator=问题
小弟遇到一个问题甚是苦恼，迟迟未解，始终找不到解决方法。A是基类，B是继承类，定义了两个构造函数，重载赋值预算符。 但是在运行时始终报错。检查了一天都没发现问题。 请牛人指点迷津。
class A
{
private:
int size;
double * a;
public:
A();
A(int m_size);
A & operator= (A & m_a);
~A();
int Size() {return size;};
};
class B : public A
{
private:
double * b;
public:
B();
B(int m_size);
B & operator= (B & m_b);
~B();
};
///////////////////////////////////////////////////////////////////////////////
A::A()
{
a = new double(2);
}
B::B()
: A()
{
b = new double(2);
}
A & A::operator=(A & m_a)
{
if (this == &m_a)
return *this;
delete [] a;
a = new double(m_a.size);
size = m_a.size;
for (int n = 0 ; n < size; n++)
{
a[n] = m_a.a[n];
}
}
B & B::operator=(B & m_b)
{
if (this == &m_b)
return *this;
A::operator=(m_b);
delete [] b;
b = new double(m_b.Size());
for (int n = 0 ; n < m_b.Size(); n++)
{
b[n] = m_b.b[n];
}
}
A::A(int m_size)
{
size = m_size;
a = new double[m_size];
}
B::B(int m_size)
: A(m_size)
{
b = new double[m_size];
}
A::~A()
{
delete [] a;
}
B::~B()
{
delete [] b;
}
int main()
{
B dp;
B temp(200);
dp = temp;
}
[解决办法]
class A
{
private:
int size;
double * a;
public:
A();
A(int m_size);
A(const A & m_a);
A & operator= (const A & m_a);
~A();
int Size() const {return size;};
};
class B : public A
{
private:
double * b;
public:
B();
B(const B & m_b);
B & operator= (const B & m_b);
~B();
B(int m_size);
};
A::A()
:size(2)
{
a = new double[2];
}
A::A(const A & m_a)
{
a = new double[m_a.size];
size = m_a.size;
for (int n = 0 ; n < size; n++)
{
a[n] = m_a.a[n];
}
}
A & A::operator=(const A & m_a)
{
if (this == &m_a)
return *this;
delete [] a;
a = new double[m_a.size];
size = m_a.size;
for (int n = 0 ; n < size; n++)
{
a[n] = m_a.a[n];
}
return *this;
}
B::B()
: A()
{
b = new double[2];
}
B::B(const B & m_b)
:A(m_b)
{
b = new double[m_b.Size()];
for (int n = 0 ; n < m_b.Size(); n++)
{
b[n] = m_b.b[n];
}
}
B & B::operator=(const B & m_b)
{
if (this == &m_b)
return *this;
A::operator=(m_b);
delete [] b;
b = new double[m_b.Size()];
for (int n = 0 ; n < m_b.Size(); n++)
{
b[n] = m_b.b[n];
}
return *this;
}
A::~A()
{
delete [] a;
}
B::~B()
{
delete [] b;
}
A::A(int m_size)
{
size = m_size;
a = new double[m_size];
}
B::B(int m_size)
: A(m_size)
{
b = new double[m_size];
}
int main()
{
B dp;
B temp(2);
dp = temp; //赋值重载
B tt(temp); //拷贝构造
return 0;
}
