菱形继承和C++相关问题
菱形继承和C++相关问题
- 菱形继承
- 继承中的同名问题
- 重载加常量情况
- 委托构造
菱形继承
菱形继承是因为多继承存在问题而存在的
像这样都是a的话出现二义性，要采用virtual继承，所以菱形继承它也叫虚继承。
#include<iostream>
#include<string>
using namespace std;
class A
{
public:
A(int a) : a(a){}
protected:
int a = 555;
};
class B : public A
{
public:
B(int a):A(a){}
};
class C : public A
{
public:
C(int a): A(a){}
};
class D : public B, public C
{
public:
D(int a): B(90), C(68) {}
void print()
{
cout << A::a << endl;
cout << B::a << endl;
cout << C::a << endl;
}
};
int main()
{
D d(10);
d.print();
system("pause");
return 0;
}
如结果所示，存在二义性问题，这a应该都是一个值，采用virtual继承的方式来解决
在B，C的继承方式前加个virtual,这样子类就必须调用爷爷的构造函数
#include
#include
using namespace std;
class A
{
public:
A(int a) : a(a){}
protected:
int a = 555;
};
class B : virtual public A
{
public:
B(int a):A(a){}
};
class C : virtual public A
{
public:
C(int a): A(a){}
};
class D : public B, public C
{
public:
D(int a): B(90), C(68),A(a) {}
void print()
{
cout << A::a << endl;
cout << B::a << endl;
cout << C::a << endl;
}
};
int main()
{
D d(10);
d.print();
system("pause");
return 0;
}
如图所示，打印的结果都是10，这样就不存在二义性问题了
继承中的同名问题
就2种
1.数据成员同名
2.函数同名
在对象的访问中：
如果不加以修饰，那么按照就近原则，
如果用类名限定了，那么自然就调用那类中的
用指针访问时候
注意的是：可以用父类的指针，对子类对象进行初始化，但不能用子类的指针对父类初始化
1.如果不加以修饰，那么调用的，取决于指针的类型，如果是父类的指针类型，那么肯定就调用父类的。
#include<iostream>
#include<string>
using namespace std;
class father
{
public:
father(){}
father(string name):name(name){}
protected:
string name;
};
class son : public father
{
public:
son(){}
son(string name1, string name2) :father("father")
{
this->name = "son";
}
void print()
{
cout << son :: name << endl;
cout << father::name << endl;
}
protected:
string name;
};
int main()
{
son m;
m.print();
father* p = new son;
p->print();
system("pause");
return 0;
}
如果所示，这里是父类的指针类型，只能调用父类的东西，调用了子类的东西，编译器自然就报错了。
重载加常量情况
主要是： 有个MM类，它的对象为mm
1.mm = mm + 1
2.mm = 1 + mm运算符重载的使用情况
#include<iostream>
#include<string>
using namespace std;
class MM
{
public:
MM(int date) : date(date) {}
MM operator + (int m)
{
this->date = this->date + m;
return *this;
}
void print()
{
cout << date << endl;
}
private:
int date;
};
int main()
{
MM mm(1);
mm = mm + 1; // 采用的函数运算符重载 ， 实质是: mm.成员函数()
mm = 1 + mm; // 报错的原因是 1.成员函数() 1无法完成这种转化
mm.print();
system("pause");
return 0;
}
解决这一问题的方法：就是要使用友元函数的运算符重载
#include<iostream>
#include<string>
using namespace std;
class MM
{
public:
MM(int date) : date(date) {}
/*MM operator + (int m)
{
this->date = this->date + m;
return *this;
}*/
friend MM operator + (MM date1,MM date2)
{
return MM(date1.date + date2.date);
}
void print()
{
cout << date << endl;
}
private:
int date;
};
int main()
{
MM mm(1);
mm = mm + 1; // 采用的函数运算符重载 ， 实质是: mm.成员函数()
mm = 1 + mm; // 报错的原因是 1.成员函数() 1无法完成这种转化
//使用友元函数重载，来解决这一问题
mm.print();
system("pause");
return 0;
}
委托构造
构造委托也叫做委托构造，它能够允许有一个构造函数调用另外一个构造函数
它只能采用初始化列表
c++中大部分情况，都需要初始化列表，所以建议，最好每次都是用初始化参数列表
#include<iostream>
#include<string>
using namespace std;
class MM
{
public:
MM(): MM(10, "温柔了岁月") {} //这就是委托构造，采用初始化列表
MM(int age , string name) : age(age),name(name){}
private:
int age;
string name;
};
int main()
{
system("pause");
return 0;
}