湖南住房和城乡建设厅网站,电商小程序开发需要多少钱,企业服务总线,网上商城怎么做推广1.基础知识
1.1 类之间的关系
has-A#xff0c;uses-A 和 is-A
has-A 包含关系#xff0c;用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示#xff0c;即一个类中的数据成员是另一种已经定义的类。 常和构造函数初始化列表一起使用 uses-A 一个类部分地…1.基础知识
1.1 类之间的关系
has-Auses-A 和 is-A
has-A 包含关系用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示即一个类中的数据成员是另一种已经定义的类。 常和构造函数初始化列表一起使用 uses-A 一个类部分地使用另一个类。通过类之间成员函数的相互联系定义友元函数友元类或对象参数传递实现。 is-A 机制称为继承。关系具有传递性,不具有对称性。 1.2 继承概念 万事万物都有继承 1.3 继承示例代码 注意C中的继承方式public、private、protected会影响子类的对外访问属性。 示例代码
#include iostream
using namespace std;class Parent
{
public:void print(){a 0;b 0;coutaaendl;coutbbendl;}int b;
protected:
private:int a;
};//class Child : private Parent
//class Child : protected Parent public
class Child : public Parent
{
public:
protected:
private:int c;
};void main11()
{Child c1;//c1.c 1;//err//c1.a 2;//errc1.b 3;c1.print();couthello...endl;system(pause);return ;
}
1.4 重要说明 1、子类拥有父类的所有成员变量和成员函数 2、子类就是一种特殊的父类 3、子类对象可以当作父类对象使用 4、子类可以拥有父类没有的方法和属性 2.派生类的访问控制
派生类继承了基类的全部成员变量和成员方法除了构造和析构之外的成员方法但是这些成员的访问属性在派生过程中是可以调整的。
2.1 单个类的访问控制 1、类成员访问级别public、private、protected 2、思考类成员的访问级别只有public和private是否足够
示例代码
#include iostream
using namespace std;//public 修饰的成员变量 方法 在类的内部 类的外部都能使用
//protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
//private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部//派生类访问控制的结论
//1 protected 关键字 修饰的成员变量 和成员函数 ,是为了在家族中使用 ,是为了继承
//2 项目开发中 一般情况下 是 public
//3class Parent
{
public:int a; //老爹的名字
protected:int b; //老爹的银行密码
private:int c; //老的情人
};//保护继承
class Child3 : protected Parent
{
public:
protected:
private:
public: void useVar(){a 0; // okb 0; // ok //b这这里 写在了子类Child3的内部 2看protected 3密码protected//c 0; //err}
};void main()
{Child3 c3;//c3.a 10; //err//c3.b 20; //err//c3.c 30;//err}//私有继承
class Child2 : private Parent
{
public:void useVar(){a 0; //okb 0; //ok//c 0; // err}protected:
private:
};void main22()
{Child2 c2;//c1.a 10; err//c2.b 20; err//c3.b 30;
}class Child : public Parent
{
public:void useVar(){a 0; //okb 0; //ok//c 0; // err}protected:
private:
};/*
C中的继承方式public、private、protected会影响子类的对外访问属性 判断某一句话能否被访问1看调用语句这句话写在子类的内部、外部2看子类如何从父类继承public、private、protected 3看父类中的访问级别public、private、protected
*/
//共有继承
void main21()
{Parent t1, t2;t1.a 10; //ok//t1.b 20; //err//t2.c 30 ; //errcouthello...endl;system(pause);return ;
}
2.2 不同的继承方式会改变继承成员的访问属性 1C中的继承方式会影响子类的对外访问属性 public继承 父类成员在子类中保持原有访问级别
private继承 父类成员在子类中变为private成员
protected继承 父类中public成员会变成protected 父类中protected成员仍然为protected 父类中private成员仍然为private 2private成员在子类中依然存在但是却无法访问到。不论种方式继承基类派生类都不能直接使用基类的私有成员 。 3C中子类对外访问属性表 2.3 “三看”原则
C中的继承方式public、private、protected会影响子类的对外访问属性 判断某一句话能否被访问 1看调用语句这句话写在子类的内部、外部 2看子类如何从父类继承public、private、protected 3看父类中的访问级别public、private、protected 2.4 派生类类成员访问级别设置的原则 思考如何恰当的使用publicprotected和private为成员声明访问级别 1、需要被外界访问的成员直接设置为public 2、只能在当前类中访问的成员设置为private 3、只能在当前类和子类中访问的成员设置为protectedprotected成员的访问权限介于public和private之间。
示例代码
//类的继承方式对子类对外访问属性影响#include cstdlib
#include iostreamusing namespace std;class A
{
private:int a;
protected:int b;
public:int c;A(){a 0; b 0; c 0;}void set(int a, int b, int c){this-a a; this-b b; this-c c;}
};
class B : public A
{
public:void print(){//couta a; //errcoutb b; //okcoutc endl; //ok}
};class C : protected A
{
public:void print(){//couta a; //errcoutb b; // okcoutc endl; //ok}
};class D : private A
{
public:void print(){//couta a; //errcoutb bendl; //okcoutc cendl; // ok}
};int main()
{A aa;B bb;C cc;D dd;aa.c 100; //okbb.c 100; // ok//cc.c 100; // err 保护的//dd.c 100; // erraa.set(1, 2, 3); //okbb.set(10, 20, 30); //ok//cc.set(40, 50, 60); // err//dd.set(70, 80, 90); //errbb.print(); //okcc.print(); //okdd.print(); ///**/system(pause);return 0;
}
3.继承中的构造和析构
3.1 类型兼容性原则 类型兼容规则是指在需要基类对象的任何地方都可以使用公有派生类的对象来替代。通过公有继承派生类得到了基类中除构造函数、析构函数之外的所有成员。这样公有派生类实际就具备了基类的所有功能凡是基类能解决的问题公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况
子类对象可以当作父类对象使用子类对象可以直接赋值给父类对象子类对象可以直接初始化父类对象父类指针可以直接指向子类对象父类引用可以直接引用子类对象在替代之后派生类对象就可以作为基类的对象使用但是只能使用 基类继承的成员。类型兼容规则是多态性的重要基础之一。 总结子类就是特殊的父类 (base *p child;) #include iostream
using namespace std;class Parent
{
public:void printP(){cout我是爹...endl;}Parent(){coutparent构造函数endl;}Parent(const Parent obj){coutcopy构造函数endl;}private:int a;
};class child : public Parent
{
public:void printC(){cout我是儿子endl;}
protected:
private:int c;
};/*
兼容规则中所指的替代包括以下情况子类对象可以当作父类对象使用子类对象可以直接赋值给父类对象子类对象可以直接初始化父类对象父类指针可以直接指向子类对象父类引用可以直接引用子类对象*///C编译器 是不会报错的 .....
void howToPrint(Parent *base)
{base-printP(); //父类的 成员函数 }void howToPrint2(Parent base)
{base.printP(); //父类的 成员函数
}
void main()
{//Parent p1;p1.printP();child c1;c1.printC();c1.printP();//赋值兼容性原则 //1-1 基类指针 (引用) 指向 子类对象Parent *p NULL;p c1;p-printP(); //1-2 指针做函数参数howToPrint(p1);howToPrint(c1); //1-3引用做函数参数howToPrint2(p1);howToPrint2(c1); //第二层含义//可以让子类对象 初始化 父类对象//子类就是一种特殊的父类Parent p3 c1;couthello...endl;system(pause);return ;
}
3.2 继承中的对象模型
类在C编译器的内部可以理解为结构体子类是由父类成员叠加子类新成员得到的 问题如何初始化父类成员父类与子类的构造函数有什么关系
在子类对象构造时需要调用父类构造函数对其继承得来的成员进行初始化在子类对象析构时需要调用父类析构函数对其继承得来的成员进行清理
#include cstdlib
#include iostream
using namespace std;class Parent04
{
public:Parent04(const char* s){coutParent04() sendl;}~Parent04(){cout~Parent04()endl;}
};class Child04 : public Parent04
{
public:Child04() : Parent04(Parameter from Child!){coutChild04()endl;}~Child04(){cout~Child04()endl;}
};void run04()
{Child04 child;
}int main_04(int argc, char *argv[])
{run04();system(pause);return 0;
}
3.3 继承中的构造析构调用原则 1、子类对象在创建时会首先调用父类的构造函数 2、父类构造函数执行结束后执行子类的构造函数 3、当父类的构造函数有参数时需要在子类的初始化列表中显示调用 4、析构函数调用的先后顺序与构造函数相反
#include iostream
using namespace std;//结论
//先 调用父类构造函数 在调用 子类构造函数
//析构的顺序 和构造相反/*
1、子类对象在创建时会首先调用父类的构造函数2、父类构造函数执行结束后执行子类的构造函数3、当父类的构造函数有参数时需要在子类的初始化列表中显示调用4、析构函数调用的先后顺序与构造函数相反
*/class Parent
{
public:Parent(int a, int b){this-a a;this-b b;cout父类构造函数...endl;}~Parent(){cout析构函数...endl;}void printP(int a, int b){this-a a;this-b b;cout我是爹...endl;}
private:int a;int b;
};class child : public Parent
{
public:child(int a, int b, int c) : Parent(a, b){this-c c;cout子类的构造函数endl;}~child(){cout子类的析构endl;}void printC(){cout我是儿子endl;}
protected:
private:int c;
};void playObj()
{child c1(1, 2, 3);
}
void main()
{//Parent p(1, 2);playObj();couthello...endl;system(pause);return ;
}
3.4 继承与组合混搭情况下构造和析构调用原则
先构造父类再构造成员变量、最后构造自己先析构自己在析构成员变量、最后析构父类
#include iostream
using namespace std;class Object
{
public:Object(int a, int b){this-a a;this-b b;coutobject构造函数 执行 aa b bendl;}~Object(){coutobject析构函数 \n;}
protected:int a;int b;
};class Parent : public Object
{
public:Parent(char *p) : Object(1, 2){this-p p;cout父类构造函数...pendl;}~Parent(){cout析构函数...pendl;}void printP(int a, int b){cout我是爹...endl;}protected:char *p;};class child : public Parent
{
public:child(char *p) : Parent(p) , obj1(3, 4), obj2(5, 6){this-myp p;cout子类的构造函数mypendl;}~child(){cout子类的析构mypendl;}void printC(){cout我是儿子endl;}
protected:char *myp;Object obj1;Object obj2;
};void objplay()
{child c1(继承测试);
}
void main()
{objplay();couthello...endl;system(pause);return ;
}
3.5 继承中的同名成员变量处理方法 1、当子类成员变量与父类成员变量同名时 2、子类依然从父类继承同名成员 3、在子类中通过作用域分辨符::进行同名成员区分在派生类中使用基类的同名成员显式地使用类名限定符 4、同名成员存储在内存中的不同位置 总结同名成员变量和成员函数通过作用域分辨符进行区分 #include iostream
using namespace std;class A
{
public:int a;int b;
public:void get(){coutb bendl;}void print(){coutAAAAA endl;}
protected:
private:
};class B : public A
{
public:int b;int c;
public:void get_child(){coutb bendl;}void print(){coutBBBB endl;}
protected:
private:
};void main()
{B b1;b1.print(); b1.A::print();b1.B::print(); //默认情况system(pause);
}//同名成员变量
void main71()
{B b1;b1.b 1; //b1.get_child();b1.A::b 100; //修改父类的bb1.B::b 200; //修改子类的b 默认情况是Bb1.get();couthello...endl;system(pause);return ;
}
3.6 派生类中的static关键字 继承和static关键字在一起会产生什么现象哪 理论知识
基类定义的静态成员将被所有派生类共享根据静态成员自身的访问特性和派生类的继承方式在类层次体系中具有不同的访问性质 遵守派生类的访问控制派生类中访问静态成员用以下形式显式说明 类名 :: 成员 或通过对象访问 对象名 . 成员 总结 1 static函数也遵守3个访问原则 2 static易犯错误不但要初始化更重要的显示的告诉编译器分配内存 3 构造函数默认为private #include iostream
using namespace std;//单例
class A
{A(){coutA的构造函数endl;}
public:/*static int a;int b;*/
public:/*void get(){coutb bendl;}void print(){coutAAAAA endl;}*/
protected:
private:
};//int A::a 100; //这句话 不是简单的变量赋值 更重要的是 要告诉C编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错../*
class B : private A
{public:int b;int c;
public:void get_child(){coutb bendl;coutaendl;}void print(){coutBBBB endl;}
protected:
private:
};
*///1 static关键字 遵守 派生类的访问控制规则//2 不是简单的变量赋值 更重要的是 要告诉C编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错..//3 A类中添加构造函数 //A类的构造函数中 A的构造函数是私有的构造函数 ... //被别的类继承要小心....//单例场景 .... UMLvoid main()
{A a1;//a1.print();//B b1;// b1.get_child();system(pause);
}void main01()
{// B b1;//b1.a 200;system(pause);
}
4.多继承
4.1 多继承概念 一个类有多个直接基类的继承关系称为多继承
多继承声明语法 class 派生类名 : 访问控制 基类名1 , 访问控制 基类名2 , … , 访问控制 基类名n { 数据成员和成员函数声明 }类 C 可以根据访问控制同时继承类 A 和类 B 的成员并添加自己的成员
#include iostream
using namespace std;class Base1
{
public:Base1(int b1){this-b1 b1;}void printB1(){coutb1:b1endl; }
protected:
private:int b1;
};class Base2
{
public:Base2(int b2){this-b2 b2;}void printB2(){coutb2:b2endl; }
protected:
private:int b2;
};class B : public Base1, public Base2
{
public:B(int b1, int b2, int c): Base1(b1), Base2(b2){this-c c;}void printC(){coutc:cendl; }
protected:
private:int c;
};void main()
{B b1(1, 2, 3);b1.printC();b1.printB1();b1.printB2();couthello...endl;system(pause);return ;
}
4.2 多继承的派生类构造和访问
多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员派生类对象访问时应该加以识别。
4.3 简单应用
4.4 虚继承 如果一个派生类从多个基类派生而这些基类又有一个共同的基类则在对该基类中声明的名字进行访问时可能产生二义性 分析如下
#include iostream
using namespace std;class B
{
public:int b;
protected:
private:};class B1 : virtual public B
{
public:int b1;};class B2 : virtual public B
{
public:int b2;
};class C : public B1, public B2
{
public:int c;
};void main()
{C c1;c1.b1 100;c1.b2 200;c1.c 300;c1.b 500; //继承的二义性 和 虚继承解决方案//c1.B1::b 500;//c1.B2::b 500;couthello...endl;system(pause);return ;
} 小结 1)如果一个派生类从多个基类派生而这些基类又有一个共同 的基类则在对该基类中声明的名字进行访问时可能产生二义性 2)如果在多条继承路径上有一个公共的基类那么在继承路径的某处汇合点这个公共基类就会在派生类的对象中产生多个基类子对象 3)要使这个公共基类在派生类中只产生一个子对象必须对这个基类声明为虚继承使这个基类成为虚基类。 4)虚继承声明使用关键字 virtual 4.5 总结
继承是面向对象程序设计实现软件重用的重要方法。程序员可以在已有基类的基础上定义新的派生类。单继承的派生类只有一个基类。多继承的派生类有多个基类。派生类对基类成员的访问由继承方式和成员性质决定。创建派生类对象时先调用基类构造函数初始化派生类中的基类成员。 - 调用析构函数的次序和调用构造函数的次序相反。C提供虚继承机制防止类继承关系中成员访问的二义性。多继承提供了软件重用的强大功能也增加了程序的复杂性。
