C++:43---派生类向基类转换、静态/动态的类变量

#include <iostream>class A {};class B:public A{};int main(){	A *a;	B b;	a = &b;	return 0;}

#include <iostream>class A {};class B:public A{};int main(){	A a;	B b;	a = b;	return 0;}

A a;B *b;b = &a; //程序错误，不能将基类对象转换为派生类对象

class A{};
class B :public A{};
class C :protected A{};
int main()
{
A *a;
B b;
C c;
a = &b; //正确
a = &c; //错误
return 0;
}

class A{};
class B :protected A
{
void func() {
A *a;
B b;
a = &b;   //正确，成员函数内可以
a = this; //正确，成员函数内可以
}
friend void func2(); //友元函数
};
void func2()
{
A *a;
B b;
a = &b; //正确，友元函数内可以
}
int main()
{
A *a;
B b;
a = &b; //错误，因为为保护继承
return 0;
}

class A{};
class B :protected A{};
class C :public B {
void func1() {
A *a;
B b;
a = &b;   //正确
a = this; //正确
}
};

//假设B公有继承于A
A *a;
B b;
a = &b;   //将派生类转换为基类，正确
B *p = a; //将基类再转换为派生类，错误

class A {};
class B:public A{};
int main()
{
A a;  //静态类型
B b;  //静态类型
A *p; //动态类型
p = &a; //p指向了a
p = &b; //p又指向了b
return 0;
}
class A {
protected:
int a;
public:
void setA(int num) { a = num; }
void cout_getA() { cout << "A" << a << endl; }
};
class B :public A {
public:
void setA(int num) { a = num; }
void cout_getA() { cout << "B" << a << endl; }
};
int main()
{
A a;
B b;
a.setA(10);
b.setA(20);
A *p1, *p2;
p1 = &a;
p2 = &b;
p1->cout_getA();
p2->cout_getA();
return 0;
}

class A
{
public:
int a = 10;
void show1()const { cout << "A:show1\n"; }
virtual void show2()const { cout << "A:show2\n"; }
};
class B :public A
{
public:
int a = 15;
void show1()const { cout << "B:show1\n"; }
virtual void show2()const { cout << "B:show2\n"; }
};
int main()
{
A a;
B b;
A *pa = &b;
cout << pa->a << endl;
pa->show1();
pa->show2();
return 0;
}

class A
{
public:
int a = 10;
void show1()const { cout << "A:show1\n"; }
virtual void show2()const { cout << "A:show2\n"; }
};
class B :public A
{
public:
int a = 15;
void show1()const { cout << "B:show1\n"; }
virtual void show2()const { cout << "B:show2\n"; }
};
int main()
{
A pa;
B pb;
pa = pb;
cout << pa.a << endl;
pa.show1();
pa.show2();
return 0;
}

class A {};
class B :public A {
public:
int num = 10;
};
int main()
{
B b;

A a = b; //基类指向与派生类
a.num;   //错误，num属于B，而A内不含有此成员
B *pa = new B;
A *pb = new B; //基类指向与派生类
pa->num;       //正确
pb->num;       //错误，num属于B，而A内不含有此成员
return 0;
}

class A {
public:
int a;
public:
A(int num) :a(num) {};
A(A const &other); //拷贝构造
};
A::A(A const &other)
{
this->a = other.a;
}
class B :public A {
public:
int b;
public:
B(int num) :A(num) {};
};
int main()
{
A a1(10); //定义A类对象
B b(20);  //定义B类对象
A a2(a1); //拷贝构造，使用与A类类型a1对象
A a3(b);  //拷贝构造，使用B类类型的b对象，b对象的内容被截断
return 0;
}

#include <iostream>
using namespace::std;
class A {
public:
int a;
public:
A(int num) :a(num) {};
public:
A& operator=(A const& other); //赋值运算符
};
A& A::operator=(A const& other)
{
this->a = other.a;
}
class B:public A{
public:
int b;
public:
B(int num) :A(num) {};
};
int main()
{
A a1(10); //定义A类对象
B b(20);  //定义B类对象
A a2(30);
a1 = b;   //将b对象赋值给a1，b对象的内容被截断
a1 = a2;  //将a2对象赋值给a1
return 0;
}