c++之——派生类的同名成员和函数调用方式及构造析构顺序

 1 #include<iostream>
 2 using namespace std;
 3 class Object {
 4 public:
 5     Object(int test) :a(1), b(2), c(3) { cout << "object 构造\n"; }
 6     ~Object()
 7     {
 8         cout << "object 析构\n";
 9     }
10     int a;
11     int b;
12     int c;
13     void same_fuc()
14     {
15         cout << "object test...\n";
16     }
17     void o_print()
18     {
19         cout << "a b c is" << a << " " << b << " " << c << endl;
20     }
21
22 };
23 class Parent :public Object {
24 public:
25     Parent(int test):Object(1), a(100),b(200),c(300),obj1(1),obj2(2)//NOTE
26     {
27         cout << "parent 构造。。。\n";
28     }
29     ~Parent()
30     {
31         cout << "Parent 析构。。。\n";
32     }
33     int a;
34     int b;
35     int c;
36     void same_fuc()
37     {
38         cout << "Parent test...\n";
39     }
40     void p_print()
41     {
42         cout << "a b c is" << a << " " << b << " " << c << endl;
43     }
44     Object obj1;
45     Object obj2;
46 };
47 class Child :public Parent
48 {
49 public:
50     Child() :Parent(1), a(1000), b(2000), c(3000) { cout << "child 构造\n"; }
51     ~Child()
52     {
53         cout << "child 析构,,,\n";
54     }
55     void c_print()
56     {
57         cout << "a b c is" << a << " " << b << " " << c << endl;
58     }
59     void same_fuc()
60     {
61         cout << "child test...\n";
62     }
63     int a;
64     int b;
65     int c;
66 };
67
68 int main()
69 {
70
71     Child c1;
72     c1.c_print();
73     c1.a = 520;//默认等价于c1.Child::a=520;
74     c1.c_print();
75     c1.Parent::a = 5200;
76     c1.p_print();
77     c1.c_print();
78     c1.Object::a = 52000;
79     c1.o_print();
80     c1.c_print();
81
82     c1.same_fuc();//默认等价于c1.Child::same_fuc();
83     c1.Parent::same_fuc();
84     c1.Object::same_fuc();
85     return 0;
86 }

时间: 2024-10-17 07:28:55

c++之——派生类的同名成员和函数调用方式及构造析构顺序的相关文章

(继承及其访问限定符)&&(派生类及其默认成员函数)&&(赋值兼容规则)

◆继承: ★继承概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能.这样产生新的类,称派生类.继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程. 继承定义格式 ★继承关系&访问限定符 class Base { public: Base() { cout<<"B()" <<endl; } ~Base () { cout<<"~

(继承及其访问限定符)&amp;&amp;(派生类及其默认成员函数)&amp;&amp;(赋值兼容规则)

◆继承: ★继承概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能.这样产生新的类,称派生类.继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程. 继承定义格式 ★继承关系&访问限定符 class Base { public: Base() { cout<<"B()" <<endl; } ~Base () { cout<<"~

C# - 阻止派生类重写虚成员

1 using System; 2 3 namespace 类_阻止派生类重写虚成员 4 { 5 // 声明一个抽象类Animal(用abstract关键字声明抽象类) 6 public abstract class Animal 7 { 8 // 基类的抽象方法Voice(); 功能在派生类实现 9 public abstract void Voice(); 10 } 11 12 // 派生类(子类)继承自Animal 13 // 14 public class Horse : Animal

python多继承中子类访问祖先类的同名成员

子类调用父类的同名成员 方式1: class A: def f_a(self): print("----A----") class B: def f_a(self): print("----B----") class C(A, B): def f_a(self): A.f_a(self) # 子类调用父类同名方法,括号里要写self,表明这是一个类调用 B.f_a(self) # 但这样如果修改了父类方法,那么子类就要多处修改 print('----C----')

C++派生类的成员内存布局

class A {}; class B : public virtual A {}; class C : public virtual A {}; class D : public B, public C {}; int main() { A a; B b; C c; D d; cout << sizeof(a) << endl; cout << sizeof(b) << endl; cout << sizeof(c) << endl

c++中派生类对基类成员的三种访问规则(转)

C++中派生类对基类成员的访问形式主要有以下两种:1.内部访问:由派生类中新增成员对基类继承来的成员的访问.2.对象访问:在派生类外部,通过派生类的对象对从基类继承来的成员的访问.今天给大家介绍在3中继承方式下,派生类对基类成员的访问规则. 1.私有继承的访问规则当类的继承方式为私有继承时,基类的public成员和protected成员被继承后成为派生类的private成员,派生类的其它成员可以直接访问它们,但是在类的外部通过派生类的对象无法访问.基类的private成员在私有派生类中是不可直接

C++派生类成员的访问属性

既然派生类中包含基类成员和派生类自己增加的成员,就产生了这两部分成员的关系和访问属性的问题.在建立派生类的时候,并不是简单地把基类的私有成员直接作为派生类的私有成员,把基类的公用成员直接作为派生类的公用成员. 实际上,对基类成员和派生类自己增加的成员是按不同的原则处理的.具体说,在讨论访问属性时,要考虑以下几种情况: 基类的成员函数访问基类成员. 派生类的成员函数访问派生类自己增加的成员. 基类的成员函数访问派生类的成员. 派生类的成员函数访问基类的成员. 在派生类外访问派生类的成员. 在派生类

C++:基类和派生类

4.1 派生类的声明 继承实例如下: class Person{ //声明基类Person public: void print() { cout<<"name:"<<name<<endl; cout<<"age:"<<age<<endl; cout<<"sex:"<<sex<<endl; } protected: string name;

C++派生类与基类的转换规则

基类与派生类对象之间有赋值兼容关系,由于派生类中包含从基类继承的成员,具体表现在以下几个方面,需要的朋友可以参考下 只有公用派生类才是基类真正的子类型,它完整地继承了基类的功能.基类与派生类对象之间有赋值兼容关系,由于派生类中包含从基类继承的成员,因此可以将派生类的值赋给基类对象,在用到基类对象的时候可以用其子类对象代替. 具体表现在以下几个方面: 派生类对象可以向基类对象赋值. 可以用子类(即公用派生类)对象对其基类对象赋值.如 A a1; //定义基类A对象a1 B b1; //定义类A的公