学习零起点c++源码笔记

学习零起点c++源码笔记
python些许经验.好久不写,手生了.

要注意字典是以:分隔.
整数除法是//,免得除成浮点数
写程序地址+=w,在循环中要注意.不要加重复了.
不要随便return 应该 continue
串转数字时,先要判断是否是数字.用(串.isdigit())
print(时,都有可能出现,打印出gbk解析不了的符).真是.
有些网站,先爬取内容,再来分析.免得麻烦.
range(数,-1,-1)这样倒着数.
是-1.不是0,或其它1呀什么的.
好久不写,错误百出.
firefox的缓冲头,在后面.点错了.还.
if判断式后面得有:号.
每一页下载过的要记录下来.免得断开了,又找不着.

空 函数(整);          
空 函数(长);       
空 函数(浮);      
空 函数(双精);       
//普通函数重载,是可以都命名为函数的
    立方体 a;           
    a.和(2,3);          
    a.和();          
//成员函数重载类似
//常成员或者引用成员都不可赋值的,只能初化
    A(整 a,整 b):数(a),总(b){}
    //总为引用成员,只能这样初化
A(A&t){输出<<"复制构造函数运行\n";n=t.n;m=t.m;}
    ~A(){删 x;x=无效;}
//析构对象的同时删除成员指针指向的内存空间，为了稳妥起见将指针赋为空
//浅层复制
        *x=*(a.x);                  
//读取旧对象的成员指针x指向的空间处的数据并赋给新对象的成员指针x所指向的内存区域
    双精 a=12.3456789012345;
    输出<<置精度(15)<<a;
    符号 双精(){中 i;}
    A a(99.9);
    输出<<"双精(a):"<<双精(a)<<行尾;
//可以这样
    A a(99);          
    a.取();
    a=1000;          
//隐式转换了,a可通过数字直接转换
     数&符号++(){++n;中*本;}
    数(常 数&s){本->n=s.n;输出<<"复制构造函数执行\n";}
    //这样返回&,仔细思考
    数 x=++i; 
    //因为是构造对象并用另一个对象对它进行初始化，
   //因此右侧即使按别名返回对象，也会调用复制构造函数。
    i=++i;//调用赋值运算符函数"="进行赋值，
    //右侧按引用返回对象不会调用复制构造函数，
    //按值返回对象则会调用复制构造函数
常 数&符号++(){++n;中*本;}
常 数 符号++(整 o){数 临时(*本);++n;中 临时;}
    x=i++;//这一步构造了两个,一是函数中,一是返回
//重载自加
//++i与i++,
    常 数 符号+(常 数&r){中 数(n+r.取());}
    常 数&符号=(常 数&r){
        如(本==&r)中*本;*n=r.取();中*本;
    }
//常数赋值
    空 喜欢(){房间();}//子直接调用父的函数
    空 你好(整 i)常{}//常类对象,调用的你好方法
类 D:公 C
{
    公:
    整 数(){中 4;}
    整 a(){中 A::数();}
    整 b(){中 B::数();}
    整 c(){中 C::数();}
};
//减少混淆
    c.A::你好();           //基类A的你好函数(成员名限定由类名A加域操作符::组成)
    c.B::你好();           //基类B的你好函数


//枚的用法:    
    枚 天{星期日,星期一,星期二,星期三,星期四,星期五,星期六};
    天 今天;今天=星期一;
   B b;
   b.置(4,6);
   B&rb=b;
   输出<<rb.取()<<行尾;//10
   A a;
   a.置(7,8);
   输出<<a.取()<<行尾;//15
   A&ra=b;                        
   输出<<ra.取()<<行尾;//10,派生类给基类指针,仍是派生类       
  输出<<p->取()<<行尾;
  输出<<p->A::取();//使用父类取.
  父亲*p父亲=新 子;//这个为基,先是父构造,再是子构造   
  p父亲->跳();//父非虚,调用父 
  p父亲->跑();//父为虚,调用子
  删 p父亲;          
//编译时静态:
构 A{整 取(){中 1;}};
构 B:公 A{整 取(){中 2;}};
   A a;整 一=a.取();输出<<"a的值是："<<一<<行尾;
   B b;一=b.取();输出<<"b的值是:"<<一<<行尾;
//a为1,b为2
构 A{整 取(){中 1;}};
构 B:公 A{整 取(){中 2;}};
A*p;若 1:p=新 A;断;若 2:p=新 B;断;输出<<p->取();
//输出一直为1,运行时静态,没有虚,运行时静态只为1
构 A{虚 整 取(){中 1;}};
构 B:公 A{整 取(){中 2;}};
A*p;若 1:p=新 A;断;若 2:p=新 B;断;输出<<p->取();
//1,或2,运行时动态,有虚在
构 A{虚 整 取(){中 1;}};
构 B:公 A{整 取(){中 2;}};
A*p;A a;B b;p=&a;
整 一=p->取();输出<<"a的值是："<<一<<行尾;
p=&b;一=p->取();输出<<"b的值是:"<<一<<行尾;
//编译时动态,1,2
A p;若 1:p=A();若 2:p=B();//总是输出1,编译时动态
//1执行父类的构造函数创建一个父类临时对象并赋给p
//2执行子类的构造函数创建一个子类临时对象并赋给p
   A*p=0;                 
//声明一个指向基类A的指针p，并将其赋值为0。这是因为指针在使用时须赋予一个内存地址，没有也要赋一个0值
//基类.虚 一();调用非虚其它相同名函数.
//继承类,同样如此,都有相同名字函数,只第一个为虚
//则各调用各基类调用基,继承调用继承
空 一(父亲);两个(父亲*);三(父亲&);   
若 1:p=新 子;一(*p);//对象
若 2:p=新 女儿;两个(p);//地址             ;
若 3:p=新 父亲;三(*p);//为引用          
//1将对象作为参数传递给函数one()中
//2将对象的内存地址传递到函数two()中
又 空(纸::*p)();
//定义成员函数指针
p 函数[3]={&纸::读,&纸::写,&纸::燃烧};
//成员函数数组
纸*pp=0;//类对象
(pp->*函数[n-1])();//核心在此
//其实等价于(函数(*pp,参数))
   空(*p[5])(浮&,浮&);  
         若'1':p[i]=平方;断;
         若'2':p[i]=立方体;断;
         若'3':p[i]=交换;断;
//函数指针数组,后面均为函数
//使用方式
p[i](a,b);           
//与向量<共针<...>>类似
//利用好将函数<>作为对象,来与模板结合好
空(人类::*pf)()=0;//类的函数指针,这是成员针
若'1':p=新 妈;断;若'2':p=新 父亲;断;
若'3':p=新 叔叔;断;
//p变化,pf变化,参数变化,千变万化
若'1':pf=&人类::跑;断;若'2':pf=&人类::吃;断;
(p->*pf)();//核心.p变化,pf变化,参数变化,
整 符号++(){输出<<"++i\n";rx++;中 rx;}
整 符号++(整){输出<<"i++\n";整 i=rx;rx++;中 i;}
//前加与后加
元<类 T>
空 显示(T a){输出<<"模板函数!"<<a<<行尾;}
元<>空 显示<整>(整 a){输出<<"具体化模板函数:"<<a<<行尾;}
//特化,需要表示出剩余的模板参数
元<类 T1,类 T2=整>类 人们;//默认类型
元<元<类 T>类 TT,类 T>
o流&符号<<(o流&出,常 TT<T>&tt){}
//这种,窗口类<单参>都包含完了
//联 的目标减少字节占用空间.
    联{整 a;整 b;};
//这两个是一个整体,输入a,b变,输入b,a变
    输出<<"1&1:"<<(1&1)<<行尾;
    输出<<"1&0:"<<(1&0)<<行尾;
    输出<<"0&1:"<<(0&1)<<行尾;
    输出<<"0&0:"<<(0&0)<<行尾;
    输出<<"1&2:"<<(1&2)<<行尾;
//第1个为1,其余均为0
    位集<8>数1(85),数2(0); //均为0
    输出<<数1<<"&"<<数2<<":"<<(数1&数2)<<行尾;
    位集<8>数3(73),数4(85); //取85相关1位
    输出<<数3<<"&"<<数4<<":"<<(数3&数4)<<行尾;
    位集<8>数5(73),数6(15); //取低4位
    输出<<数5<<"&"<<数6<<":"<<(数5&数6)<<行尾;
    位集<8>数7(73),数8(240); //取高4位
    输出<<数7<<"&"<<数8<<":"<<(数7&数8)<<行尾;
    整 a=1,b=2;a=a^b;b=b^a;a=a^b;
    输出<<"a:"<<a<<"b:"<<b<<行尾;
//交换两个数
a=a&~1;//1取反,不论a是多少位数,这样都能将最后1位清0
//三个条件：（1）该对象是指针或引用形式；（2）该对象的静态与动态类型不同；（3）应用场景为带虚函数的继承体系结构。
//多态,差不多了.

其它的看不进去了.暂时就这样吧.