#include<stdio.h>#include<stdlib.h>//在预处理时循环展开//define常量在预处理为main.i文件时就已全部替换#define PI 3+2intmain(){//vs要求定义语句都放在前面int a = PI * PI;int b =10;int c =012;int d =0xA;printf("a = %d",a);system("pause");}
补码
#include<stdio.h>#include<stdlib.h>intmain(){int i =-5;int j;
j = i +2;//unsigned 无符号 默认缺省 signed 有符号unsignedint k =0xffffffff;printf("j = %d\n",j);//%u以无符号整型输出printf("k = %u\n",k);system("pause");}
溢出
#include<stdio.h>#include<stdlib.h>intmain(){short a,b;//有符号 short int型可表示最大正整数为32767
a =32767;
b = a +1;//发生数据溢出printf("b = %d\n",b);system("pause");}
浮点数
#include<stdio.h>#include<stdlib.h>intmain(){float i =3e-3;//e 为10的幂次//符号位1位 指数位 8位 尾数位 23位float f =1.456;//浮点数是近似值是由于指数位只能用2的幂次来近似某些数值后再与尾数位相乘//所以判断时不能使用等号判断float a=1.23456789e10;//float有效数字为7位float b;
b= a+20;printf("b= %f\n",b);//发生精度丢失if(f==1.456){printf("f is equal to 1.456 \n");}else{printf("f is not equal to 1.456\n");}//要使用是否在精度范围内来判断是否相等if(f-1.456>-1e-7&&f-1.456<1e-7){printf("f is equal to 1.456 \n");}else{printf("f is not equal to 1.456\n");}system("pause");}
字符型
#include<stdio.h>#include<stdlib.h>intmain(){char a ='A';char b =65;char c ='\0';//空字符用于表示字符串的结束 相当char c = 0;char*p ="abc";//字符串常量与整型，浮点型常量不同，她是被存储在数据区的常量区中，整型常量是从数据区移动到栈区赋值给变量char*p2 ="abc";char d = a+32;//大写转小写字母//判断是否为大写字母if(a>='A'&&a<='Z'){printf("变量a为大写字母");}printf("a= %c",a);printf("a= %d",a);//在内存中对应存储的值为65，经查表打印字符Aprintf("abc\b");// \b为光标后退一格并不会删除printf("abc\b ");//后退一格再输出空格实现将c删除的效果printf("abc\rd");// \r回到行首 system("pause");}
混合运算
#include<stdio.h>#include<stdlib.h>intmain(){float f;int i =5;
f = i/2;//i/2结果为整型2再转成float类型2.0long l =5;short s;
s = l+1;//会出现警告，通过(short)l 强转解决system("pause");}
#include<stdio.h>#include<stdlib.h>intmain(){int i;float f;double d;char c;int ret;
ret =scanf("%i%f%lf %c",&i,&f,&d,&c);//在%c前添加一个空格，模式匹配为了%c忽略用来间隔的空格，double类型在输出的时候可以用%f，但在输入的时候要用%lfprintf("%i%f%f%c\n",i,f,d,c);system("pause");}
算术运算符
#include<stdio.h>#include<stdlib.h>intmain(){int i,k;int j =0;scanf("%d",&i);//判断是否为对称数while(i!=0){
k = i%10;printf("%d\n",k);
j = j*10+k;
i = i/10;}printf("%d\n",j);system("pause");}
逻辑运算符和逻辑表达式
#include<stdio.h>#include<stdlib.h>intmain(){int year;int i =0;while(scanf("%d",&year)!=EOF){//运算符优先级if(year%4==0&&year%100!=0||year%400==0){printf("%d is leap year\n",year);}else{printf("%d is not leap year\n",year);}}//短路与和短路或
i ==0&&printf("system is error\n");//等于0的时候打印
i ==0||printf("system is error\n");//不等于0的时候打印system("pause");}
位运算符
#include<stdio.h>#include<stdlib.h>intmain(){short s =0x10;// << 高位丢弃，低位补0 相当于乘2 移位器效率高// >> 右移 低位丢弃 正数高位补0 负数高位补1 正数相当于除以2，低位舍弃//如果是负数 >> 右移 需要先加1再右移 达到除以2，低位舍弃的效果
s = s<<1;printf("s = %d",s);
s =0xf0f7;
s =~s;printf("negetion s = %x",s);//1.一个数跟自己异或结果为0//2.一个数跟0异或结果是自己//3.按位异或满足交换律printf("5&7",5&7);//值为5 都为1才为1printf("5|7",5&7);//值为7 都为0才为0printf("5^7",5&7);//值为7 位异或0则不变 位异或1则取反system("pause");}
找出出现一次的那个数
#include<stdio.h>#include<stdlib.h>#define N 5intmain(){int a[N]={6,9,7,9,6};int result =0;int i;//利用异或性质找出只出现一次的那个数for(i=0;i<N;i++){
result = result^a[i];}printf("result = %d\n",result);//利用按位与，判断一个数是不是2的幂次，a&a-1 = 0system("pause");//若一些数中只有两个数出现一次，其他数均出现两次，请找出那个数//首先分堆 将所有数进行异或运算得到的结果为要寻找的那两个数各位的相同情况//选取这两个数不同的那一位并设为1其他位均设为0，与所有数进行按位与，即可通过结果分为两堆//且两堆各自包含一个所求数，其他数均为成对出现，此时每堆所有数进行按位异或即可找出结果}
找出两个出现一次的数
#include<stdio.h>#include<stdlib.h>#define N 8intmain(){short a[N]={5,6,9,11,7,9,6,5};short result =0;short obj1=0,obj2=0;int i;for(i=0;i<N;i++){
result = result^a[i];}// a&(-a)可找出此数a最低位为1的那个数，根据负数补码特性
result = result&-1*result;for(i=0;i<N;i++){if(a[i]&result){
obj1 = obj1^a[i];}else{
obj2 = obj2^a[i];}}printf("obj1=%d obj2=%d",obj1,obj2);system("pause");//如果在103个数中找3个出现一次的数//让数组中所有的数与0000 0001进行按位与，分成两堆，想要分成其中一堆存在两个目标值，一堆存在一个目标值//再让这两堆各自所有数进行异或操作，如果其中有一堆的值等于0，则目标数的最低位相同，三个目标值都存在一堆之中//这时让所有数与0000 0010进行按位与，重复操作直至两堆各自异或值都不等于0，此时奇数个堆存在存在一个目标值即异或的结果，偶数个堆存在两个目标值，继续通过找两个出现一次的数的方法进行分堆处理}
条件运算符
#include<stdio.h>#include<stdlib.h>intmain(){int i,j,k;int ret;//根据三目运算符判断最大值//while(scanf("%d%d%d",&i,&j,&k)!=EOF) {// ret = i>j?(i>k?i:k):(j>k?j:k); //或者 (i>j?i:j)>k?(i>j?i:j):k// printf("max = %d\n",ret);//}//利用三目运算符实现正数负数除以2的操作 关于取模a%b=a-(a/b)*b//while(scanf("%d",&k)!=EOF){// ret = k>=0?k>>1:k+1>>1;// printf("k/2=%d\n",ret);//}//如果5，6，7不括起来k = 5，因为赋值运算符优先级高于逗号运算符
k =(5,6,7);//逗号表达式整体的值是最后一个表达式的值 例如while(fflush(stdin),scanf("%d",&i))system("pause");}
#include<stdio.h>#include<stdlib.h>intmain(){int i;while(fflush(stdin),scanf("%d,&i")!=EOF){if(i>0){printf("%d is bigger than zero");}else{printf("%d is not bigger than zero");}}system("pause");}
switch
#include<stdio.h>#include<stdlib.h>intmain(){int year, month;while(scanf("%d%d",&year,&month)!=EOF){switch(month){case1:case3:case5:case7:case8:case10:case12:printf("%dmonth is 31 days",month);break;case4:case6:case9:case11:printf("%dmonth is 30 days",month);break;case2:printf("%dmonth is %d days",month,28+(year%4==0&&year%100!=0||year%400==0));break;default:printf("err month");}system("pause");}}
goto无条件转移语句
#include<stdio.h>#include<stdlib.h>voidprint(){
label:printf("I am print func");//goto是不可以跳转到其他函数的}intmain(){int i =1;int total =0;
label:
total = total + i;
i++;if(i<=100){goto label;//向上跳转实现循环}printf("tatal = %d",total);system("pause");}
while循环
#include<stdio.h>#include<stdlib.h>intmain(){int i =1;int total =0;while(i<=100){
total = total +i;
i++;//是表达式趋近于假}printf("total = %d",total);system("pause");}
for循环
#include<stdio.h>#include<stdlib.h>intmain(){int i,total;for(i=1,total=0;i<=100;i++){
total = total +i;}printf("total = %d",total);/*i =1, total=0;
for(;;){
if(i<=100){
total = total +i;
}else {
break; //结束整个循环
}
i++;
} *///i =1, total=0;//for(;i<=100;i++){// if (i%2==1){// continue; //跳过循环体下面未执行的语句// }// total = total +i;//} system("pause");}
#include<stdio.h>#include<stdlib.h>intmain(){int a[]={31,28,31,30,31,30,31,31,30,31,30,31};int year,month,day;int i;while(scanf("%d%d%d",&year,&month,&day)!=EOF){int total =0;for(i=0;i<month-1;i++){
total = total + a[i];}
total = total + day;if(month>2){
total = total +(year%4==0&&year%100!=0||year%400==0);}printf("%04d-%02d-%02d is %dth day",year,month,day,total);}//输入两个日期计算相差多少天 sum = delt(year1,year2) - dayofyear(year1) + dayofyear(year2) //delt函数为计算两个年份的1月1号相差多少天//输入一个日期计算今天星期几 向后计算 delt%7 向前计算 （7-delt%7）%7 delt为计算与已知为星期天的日期相差的天数//输入一个日期和一个整数n，计算从该日期起经n天以后的日期 ->date-> tomorrow of the date system("pause");}
数组与指针
一维数组
#include<stdio.h>#include<stdlib.h>#define N 5voidprint(int a[],int len){//a和len都是形参 int i;for(i=0;i<len;i++){printf("a[%d] = %d",i,a[i]);}}intmain(){// int i = 10;// int a[i]; //定义时a[]内不能使用变量// int a[0]; //不能为0，没有意义//一个函数的函数栈1M 在栈中定义的数组有大小限制int a[N]={1,2,3,4,5};int b[5]={0};//剩余元素默认都是0// b = {1,2,3,4,5} 数组声明后不能再对b进行赋值，因为此时的b已经是一个常量地址确定下来//数组访问越界//a[5] = 6;print(a,N);//函数调用是值传递，传递的是数组a的地址，是指针类型，大小是4个字节//实参a，N的值传递给了形参a，len//一维数组的传递，无法将长度传递过去//函数执行就是压栈弹栈的过程system("pause");}
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){int a[5]={1,2,3,4,5};//多用于清空数组 int b[5];int ret;memcpy(b,a,sizeof(a));
ret =memcmp(a,b,sizeof(a));memset(a,0,sizeof(a));//0表示指定填充的内容 sizeof(a)表示要设置的字节大小}
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){int i;char*p;scanf("d",&i);//一旦申请，一直存在，除非free
p =(char*)malloc(i);//p="hello" 若这样赋值存储的是hello字符串常量的地址，并不是将字符串拷贝到申请的堆空间中strcpy(p,"hello");puts(p);//内存释放时要使用malloc返回的地址，不能偏移，可定义一个新的变量进行偏移free(p);system("pause");}
栈与堆的申请
#include<stdio.h>#include<stdlib.h>#include<string.h>//栈空间申请一次就给1M空间，通过栈顶指针进行管理//堆空间申请一次就要进行虚拟地址到物理地址的映射//栈空间函数执行结束后会弹栈，这片内存会释放提供给其他函数使用char*print_stack(){char c[]="I am print_stack";puts(c);return c;}//堆空间一旦申请，一直存在，除非freechar*print_malloc (){char*p;
p=(char*)malloc(20);strcpy(p,"I am print_stack");puts(p);return p;}intmain(){char*p;//p=print_stack();
p=print_malloc();//可在不同函数中malloc和freefree(p);puts(p);system("pause");}
#include<stdio.h>#include<stdlib.h>voidb(){printf("I am function b");}voida(void(*p)()){p();}intmain(){void(*p)();//函数指针，用于存储函数的入口地址//p=b;//p();a(b);//传递一种行为给函数asystem("pause");}
//func.c函数定义文件#include"func.h"//函数的定义intprintstart(int i){//有参函数printf("*******\n");return i+3;}voidprintmessage(){//无参函数printstart(0);printf("how do you do");}
//main.c主程序文件#include"func.h"//增量编译 只编译修改的文件//函数声明和调用最好复制函数名，否则容易出现无法解析的外部符号intmain(){int i =10;//链接 func.obj里的函数的入口地址，替换main.obj中的函数符号int a =printstart(i);//函数的返回值要立刻接收，函数结束栈空间就被释放printmessage();system("pause");}
#include<stdio.h>#include<stdlib.h>#include<setjmp.h>
jmp_buf envbuf;voidb(){printf("I am b func \n");longjmp(envbuf,5);//直接回到envbuf存储的上下文位置，栈顶指针直接回到保存位置并将i赋值为5，赋值为0会死循环，但内部做了优化不会使值为0}voida(){printf("I am a func \n");b();printf("finish b\n");}intmain(){int i;
i=setjmp(envbuf);//将当前进程的上下文保存在envbufif(0==i){//将常数放在==的前面，防止误将==写成=a();}system("pause");}
递归实现阶乘
#include<stdio.h>#include<stdlib.h>//递归 自身调用自身intf(int n){if(n==1){return1;}return n*f(n-1);}//递归实现走台阶 递归不断地压栈弹栈 执行效率不如非递归 intstep(int n){if(n==1){return1;}if(n==2){return2;}returnstep(n-1)+step(n-2);}intmain(){int n;int i,first,second,total;//while(scanf("%d",&n)!=EOF){// printf("%d!=%d",n,f(n));//} //一个人上台阶，台阶总计有n个台阶，1次只能走一个台阶，2个台阶，走到n个台阶有多少种走法？//while(scanf("%d",&n)!=EOF){// printf("%d层台阶有%d种走法",n,step(n));//}while(scanf("%d",&n)!=EOF){//非递归实现走台阶 已知公式f(n) = f(n-1) +f(n-2) 类似费波纳序列//任何递归都可以拆成非递归实现
first =0;
second =1;for(i=0;i<=n;i++){
total = first +second;
first = second;
second = total;}}system("pause");//汉诺塔问题 //先将n-1个盘子借助从a借助c移动到b//将最后一个盘子从a移动到c//最后将n-1个盘子从b借助a移动到c}
//头文件c++标准形式#include<iostream>// c语言中 include<stdio.h>
using namespace std;// 命名空间 此命名空间包含cout cin 等对象//命名空间 区别同名的变量和函数 //命名空间的声明
namespace std1{voidsort(){
cout <<"sort1"<< endl;}}
namespace std2{voidsort(){
cout <<"sort2"<< endl;}}//条件编译#if 0#endif//int main(int argc,char *argv[]){ return 0} 带命令行参数的主函数写法intmain(void){//输出 --- 对代码的简单描述
cout <<"hello world"<< endl;//endl 换行，并且清空，刷新缓冲区 \n仅是换行//cout 相较于c中printf 1.可连续输出 2.自动识别类型
cout <<"123"<<" "<<456<< endl;//cout是个对象，不是关键字，也不是函数 //c++变量的声明不用写在开头int a =10;char b ='b';float c =1.234f;
cout << a <<" "<< b <<" "<< c << endl;//cin 相较于scanf 1.可连续输入 2.自动识别类型类型
cin >> a >> b >> c;
cout << a <<" "<< b <<" "<< c << endl;//命名空间的使用 using namespace 空间名(整个空间对外) using 空间名::变量/函数名 (仅指定变量或函数对外)
using namespace std1;sort();//不打开命名空间可以采用 命名空间名::变量名/函数名 ：::作用域运算
std2::sort();system("pause");//方便观察结果return0;}
for循环
#include<iostream>
using namespace std;intmain(){// int i=0;//c++可在for循环的()内声明变量，在vs中其作用域仅在for循环内，而在vc中其作用域是在main函数内for(int i=0;i<5;i++){
cout<<i<<endl;}for(int i=0;i<5;i++){
cout<<i<<endl;}system("pause");return0;}
#include<iostream>
using namespace std;
class CPeople {//基类 父类
public:voidStudy(){
cout<<"Study"<<endl;}
protected:voidfun(){
cout<<"protected fun"<<endl;}
private:voidfun1(){
cout<<"private fun"<<endl;}};//继承的写法
class CChild : public CPeople{//派生类 子类
public:voidGoToSchool(){
cout<<"GoToSchool"<<endl;}};
class CMan : public CPeople{
public:voidGoToWork(){
cout<<"GoToWork"<<endl;}};//private子类不能访问 protected子类可以访问 public子类以及类外都可以访问//继承的限定修饰符 public 父类修饰符保持不变 (访问权限不变)// protected 父类的public降级成protected private和protected不变(高级降为同级，同级及以下不变，降低访问权限)// private 全部降级为private 降低访问权限
class COldMan : public CPeople{
public:voidGoToPark(){
cout<<" GoToPark"<<endl;}};intmain(){
CChild child;
child.Study();
CMan man;
man.Study();system("pause");return0;}
构造函数的继承
#include<iostream>
using namespace std;
class CPeople{
public:CPeople(){
cout<<"CPeople"<<endl;}};
class Cxiaoming : public CPeople{
public:Cxiaoming(){
cout<<"Cxiaoming"<<endl;}};
class Cxiaohua : public Cxiaoming{
public:Cxiaohua(){
cout<<"Cxiaohua"<<endl;}};intmain(){//继承构造的的调用顺序 先父类后子类
Cxiaoming xiaoming;
Cxiaohua xiaohua;//实例化小华要先实例化小明，实例化小明要先实例化CPeople system("pause");return0;}
有参构造函数的继承
#include<iostream>
using namespace std;
class CgrandFather{
public:CgrandFather(int a,int b){
cout<<"CgrandFather"<<endl;}//若父类有多个构造函数 那么根据子类初始化列表决定调用哪个构造函数CgrandFather(int a){
cout<<"CgrandFather"<<endl;}~CgrandFather(){
cout<<"~CgrandFather"<<endl;}};
class CFather : public CgrandFather{
public:CFather(int a):CgrandFather(a,2){
cout<<"CFather"<<endl;}~CFather(){
cout<<"~CFather"<<endl;}};
class CSon : public CFather{
public:int age;//父类有参构造函数 要在子类构造函数初始化列表 给父类构造函数传递参数//默认是调用父类无参构造函数 CSon() : CFather(){}CSon():CFather(1){
cout<<"CSon"<<endl;}~CSon(){
cout<<"~CSon"<<endl;}};intmain(){{//构造函数先调用辈分大的再调用辈分小的
CSon son;//析构函数先调用辈分小的再调用辈分大的}system("pause");return0;}
#include<iostream>
using namespace std;#define SUM(x) x*x//常规函数调用 跳转到所调用函数在内存中的代码段，执行结束再跳回主函数//内联函数调用 直接将所调用的函数的相应代码复制替换到主函数中//内联函数的声明//声明和定义前都要加上inlineinlinevoidfun();
class CStu{
public://类内定义的函数都是内联函数，隐式定义和显式定义voidfun(){}inlinevoidfun1(){}voidfun2();};//类外定义的有inline的是内联函数，没有inline便不是内联函数inlinevoid CStu::fun2(){}intmain(){//内联函数比宏的功能更强
cout<<SUM(2+3)<<endl;fun(2+3);system("pause");return0;}//内联函数定义inlinevoidfun(int i){
cout<<i*i;}
虚函数
#include<iostream>
using namespace std;//多态与虚函数//多态 父类的一个指针，可以有多种执行状态 相同的代码实现不同的功能 父类的指针调用子类的函数//虚函数是实现多态的语法基础
class CFather {
public://若父类函数没有virtual关键字 因为是父类指针类型 所以只能调用父类的函数//若父类函数有virtual关键字 那么父类指针便可以调用子类函数成员//虚函数子类和父类函数名要相同//父类指针指向哪个子类就调用哪个子类的函数
virtual voidshow(){
cout<<"CFather"<<endl;}};
class CSon : public CFather{
public:int age;voidshow(){
cout<<"CSon"<<endl;}};intmain(){//父类的指针指向子类的空间
CFather *fa=new CSon;
fa->show();system("pause");return0;}
虚函数特点
#include<iostream>
using namespace std;
class CFather {
public:
virtual voidshow(){
cout<<"CFather"<<endl;}};
class CSon : public CFather{
public:int age;//重写 针对于相同函数父类是虚函数的情况 父类是普通函数则是覆盖//子类重写的函数默认是虚函数 可显式加virtual 也可以不加//返回值以及函数参数完全相同才构成重写关系 返回值不同是协变 只允许相同函数返回各自类的引用类型//构造函数 内联函数 不能是虚函数
virtual voidshow(){
cout<<"CSon"<<endl;}};intmain(){
CSon son;system("pause");return0;}//虚表是维护一个对象虚函数的列表 此对象父类的虚函数地址被存储在表中 类似一个指针数组//若这个子类重写了父类的虚函数，那么虚表中虚函数地址会修改成子类重写的函数地址//多态实现过程//1.根据父类的指针，找到父类的函数 2.看所调用的函数是不是父类的虚函数 //是则进入虚表按表中地址执行函数(自己/重写) 不是则执行自己的函数
取虚表的内容
#include<iostream>
using namespace std;
class CFather {
public:
virtual voidfun(){
cout<<"CFather"<<endl;}
virtual voidshow(){
cout<<"CFather"<<endl;}};
class CSon : public CFather{
public:int age;
virtual voidfun(){
cout<<"CSon"<<endl;}
virtual voidshow(){
cout<<"CSon"<<endl;}};intmain(){//对象空间的最开始四字节内容，就是虚表(虚函数列表)的地址，叫虚指针
CFather *fa=new CSon;//先将CFather*类型强转成int*类型取值为虚表地址，再强转为int*类型便于在虚表中进行指针偏移，最后再取*得到的是虚函数地址typedefvoid(*p)();//将void (*)()类型重命名为p*((int*)*(int*)fa+0);//fun函数地址*((int*)*(int*)fa+1);//show函数地址*((int*)*(int*)fa+2);//虚表结尾0x00000000 也占四个字节((p)*((int*)*(int*)fa+0))();//调用fun函数 先强转为对应函数类型指针然后()调用system("pause");return0;}
联编
#include<iostream>
using namespace std;
class CA{
public:
virtual voidfun(){
cout<<"CA"<<endl;}};
class CB : public CA{
public:
virtual voidfun(){
cout<<"CB"<<endl;}};voidfun(){
cout<<"fun"<<endl;}intmain(){
CA a;fun();//静态联编 在编译过程中决定的
CA *ca=new CB;
ca->fun();//静态联编 编译过程中就已经决定调用哪个函数int i;
cin>>i;
CA *p;switch(i){case1:
p=new CA;break;case2:
p=new CB;break;}
p->fun();//运行的时候才能决定到底调用谁的fun()函数system("pause");return0;}
纯虚函数
#include<iostream>
using namespace std;
class CFather {
public://纯虚函数特点 1.可以没有函数实现 2.类中有纯虚函数是不能实例化对象的 3.有纯虚函数的类必须用子类重写纯虚函数，才能实例化该子类对象//有纯虚函数的类 叫做抽象类 除数据成员和构造函数之外所有函数都是虚函数 叫做接口类//纯虚函数写法
virtual voidfun()=0;
virtual ~CFather()=0;};
class CSon : public CFather{
public:voidfun(){
cout<<"CSon"<<endl;}};intmain(){system("pause");return0;}
虚析构
#include<iostream>
using namespace std;
class CFather {
public:~CFather(){
cout<<"CFather"<<endl;}};
class CSon : public CFather{
public:~CSon(){
cout<<"CSon"<<endl;}};
class Cxiaoming{
public:~Cxiaoming(){
cout<<"Cxiaoming"<<endl;}};intmain(){
CFather *fa=new CSon;//在实例化子类的时候，实际上是先实例化父类再实例化子类，申请了父类成员空间和子类成员空间两部分空间//若不使用虚析构那么释放fa指针，只会调用父类的析构函数而不会调用子类的析构函数//使用析构函数则在释放父类指针时，子类的析构函数和父类的析构函数都会被调用// delete fa; //delete调用析构函数只看指针类型 指针是谁的类型就调用谁的析构函数 指针所指的空间仍被释放掉//类型错误不会造成对象空间泄露 但有可能造成对象成员申请空间泄露(原本在析构函数中释放的空间)
delete (Cxiaoming*)fa;system("pause");return0;}
虚继承
#include<iostream>
using namespace std;
class CA {
public:int a;};//普通继承 派生类实例包含了一份完整的基类实例数据，并简单的将派生类类成员变量添加到基类的成员变量之后//虚继承内存布局不同于普通继承 由于指针可以是指向派生类的基类指针 而内存布局导致不能再通过声明指针类型计算偏移才引入了虚基类表指针成员//派生类中虚基类表存储了 虚基类表指针与该类对象指针的偏移量 虚基类表指针与虚基类对象的偏移量//用虚继承解决多继承访问不明确的问题 //菱形继承 普通继承会在CD拷贝两份CA类中的数据成员导致出现命名冲突和冗余数据的问题//而虚继承则是让该类，承诺愿意共享它的基类 ，这个被共享的基类称为虚基类 此处为CA//不论虚基类在继承体系下出现了多少次，在派生类中都只包含一份虚基类成员
class CB :virtual public CA{
public:};
class CC :virtual public CA{
public:};
class CD : public CB,public CC{
public:};intmain(){
CD d;
d.a;system("pause");return0;}//1）在普通继承中，如果继承的子类本身有虚函数，就会在从父类继承过来的虚表上进行扩展；// 而在虚继承中，如果子类本身有虚函数，编译器就会为其单独生成一个虚表指针（vptr）和虚函数表，如果子类本身没有新增虚函数，那么vptr就不会存在，也不会有对应的虚函数表。//2）普通继承中，是先按父类的方式构造对象，然后在此基础上进行扩展和覆盖；而在虚继承中，不是这样的。//3）虚继承中，父类对象的虚表是单独保存的，通过新增的虚基类指针和虚基类表，来标明各个父类对象内存空间的偏移值。
2017
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
