class A{
static int a , b; '注意，static是不占“这个类A的内存“的！！！
}
class A{
private:
int a: ' 类A所占的内存，是要包含private类型变量的！！ 即是否是private类型无关
}
class A : private/public B{
' 类A所占的内存，要包含sizeof(B)所占的内存！！！ 是否是private继承，不影响
} ' 即一个类的内存 = (该类 + 父类 + 爷类 + 爷爷类) 的
' "非static" "private/public" 的变量 之和
class FA{ ... }
class SON{ ... } '没有继承关系！！
FA a; SON b;
FA c = (FA)b; ' 错！ FA和SON这2个类，没有任何关系，不可以强制转换
SON d = (SON)a;
'C语言的强转(T1 -> T2)：
' 1，T1和T2这两个类型，必须有关系的！！ 比如上面的FA和Son，这两个类 就完全没有任何关系
' 2，比如有T1 大于 T2， 所谓“大于”是指：T1必须要比T2 “丰富”“大”
' 虽然T1和T2有关系，但如果T1很小（T1只有ABC属性） 而T2很大（T2有ABCDE属性）
' 所谓“属性”是： 组成该类 所“必需”的东西。 组成T2必须要有DE属性，而你T1就没有DE属性
' 这自然是转换不成的！！ 即必须是“大的东西“ -> 转成 -> “小的东西”
' 这就是为什么： 子类可以转成父类，但父类不可以转成子类。因为父类东西很少，子类所需东西很多
class FA{
void name(){ DE("I'm FA")E; }
};
class SON : public FA{
public:
void name(){ DE("I'm SON")E; } '继承的重载
};
' 不管是否有“虚函数”， 下面情况都符合
FA fa; fa.name(); '假如，FA里没有name函数，就会报错。
SON s; s.name(); '假如，SON里没有name函数，就会使用FA的name函数
fa = s; '可以，子类很丰富 子类里 一定有父类所需要的东西（即使子类是空，他会继承所有父类的东西）
'这个强转，只包含对”数据data“的强转。 即此时fa.data = son里的data(不等于原先fa的data值)
'强转不包含对“函数”的强转。 即fa.func 一定是fa里定义的！！ 不是son里的重载。
s = fa; '报错！！！ 子类所需的东西很多， 父类的东西却很少。
' 不管是否有“虚函数”， 下面情况都符合
FA* fa = new FA; SON* son = new SON;
son = fa; '报错！！ fa父指针 不可以转为 子类指针
fa = son; '可以， fa->data 是son里的data值。
' 不涉及“虚函数”的情况：
FA* fa = new SON; ' fa是(FA*)类型， (*fa)即fa所指向的内存/对象 是FA类型！！
' 这一点 很像”强转“，fa的func完全是FA定义的func； 但fa的data 是取决于SON初始化里的data
' 其实就可以理解为“强转”， 即将(new SON)的这块内存/对象，强转为 FA类型。
========== 此时，引入“虚函数”： 将上面的两个name都改为virtual===================
FA* fa = new SON; ' fa是(FA*)类型， 关键是要讨论： fa所指向的对象！！
' 此时fa指向的对象，不再是FA。 fa指向的对象 是SON类型！ 通过typeid(*fa)获取
' 但比如sizeof(fa) = 8， sizeof(son) = 32；
' 虽然，fa指向的内存/对象 是SON类型。 但不是真正的SON类型！！ 他的sizeof 是和FA一样的！！！
' 即(*fa)这个对象/内存， 他的typeid是SON子类类型， 但sizeof = FA类的大小
' fa->XX，这个XX 必须是FA类里 有定义的！！ 因为fa的sizeof是FA类的大小！！！
' 即SON里独有的data和func， fa是访问不到的！！！
' fa->data（这个data，一定是父类的！！ 即使son有重名的，这个data也是父类的！！
' fa->func（他是子类的） fa->fa::func() （可以调用父类的！！）
// 前提是，SON必须是 ：public FA来继承的父类，否则son里的FA数据是private的 //
===即： fa可使用的函数有（自己的[X个] + 子类重写的） ===
=== 而fa可使用的数据data，只能是他自己的 （和子类没有任何关系）！！！ ===
// 还有一点，只要类里有“虚函数”，那么该类和其子类 的sizeof，就会变大 因为有虚表。
/* 多态就是： FA* fa = new SON; 和 FA& fa = s1; (SON s1)
为什么允许这种写法呢？？
因为子类son对象里，确实有“所有父类FA”的东西！！！ 自然可以当成是父类对象来使用 */
FA* fa = new SON; ' fa是FA*类型； (*fa)是SON类型； (*fa)的大小是FA的大小
' 只要FA里有虚函数（不管SON是否重写），那么 (*fa)就是SON类型
' 只要FA里没有虚函数，那么(*fa)是FA类型
fa->xx; ' xx必须是FA里定义的data/func； 但如果我们就是要访问“son里独有的data和func”呢？？
'需求： 通过父类FA*指针，来访问 子类独有的data和func
'为什么会有这个需求呢？ 因为fa所指的内容/内存 确实是SON类型！！！
'只不过那块内存，有一些东西被“禁用”了(SON独有的被禁用)，所以(*fa)的大小是FA的大小。
'换句话说， 有一些东西 被你浪费掉了，空占内存！！！ 你是可以使用它的
SON* son = (SON*)fa; '必须加(SON*)强转符号。
son->XX; '可以访问到SOn的所有东西。 我们并没有新new内存！！！
'我们做的：只是“指针的强转”！！ 此时fa和son指向的内存地址 是完全相同的！！！
'仅仅是一个“指针类型的强转”而已！！！ 但本质已经发生的变化。
'原来(*fa)虽然是SON类型，但他的大小sizeof是(FA的大小)
'但现在(*son)虽然也是SON类型，但他的大小sizeof是(SON的大小)！！！ 变大了非常多！！！
'也说明，原来fa指向的内存，虽然他的sizeof是FA的大小，但其实是sizeof的问题...
'他的指向的内存 就是SON的大小，因为你最开始 就是"new SON"，肯定是SON大小的内存呀！！！
'只不过，用FA* fa = new SON指向时， FA*会做一些封装，把SON独有的内存 给”禁用“掉！！
'此时，我们简简单单的“指针类型转换“：(SON*)fa，其实是把 原来”禁用“掉的内存 重新打开了。
同理，FA* fa = new SON; 和 “SON s; FA& fa = s;” 这两种写法，本质一样！！！
SON s;
FA& fa = s; // 如果FA有虚函数，则fa是SON类型 fa.XX是子类的东西。
// 否则FA没有虚函数， 则fa是FA类型。
FA* fa = new SON1; ' fa->不可以访问SON1独有的东西
SON1* s1 = (SON1 *)fa; ' s1->可以访问SON1和FA的东西
SON2* s2 = (SON2 *)fa; '这不会报语法错误，但他的逻辑合理吗？
' s2->XX 和 TYPE(*s2)，你可以发现： 这s2 还是SON1类型！！！
' 因为，你根本没有新开内存/对象，你只是做了指针强转。
' 而只有1块内存 他是SON1类型的； 他肯定是无法转成： SON2类型 （SON1和SON2，类完全不同）
// 为什么会出现这种情况呢？ 因为(SON2 *)这种强转 是static静态的
// 他只能在编译期 判断合法性。 如果是new SON1，则(SON1 *)正确。
// 如果是new SON2，则(SON2 *)正确。 而究竟new是什么内存对象，这是“运行期”才能知道的！！！
// 所以， 我们需要在“运行期” 动态的去判断 合理性。
// 引入“dynamic_cast"，他就是：===帮助开发者，做安全检查===
FA* fa = new SON1;
SON1* s1 = dynamic_cast<SON1 *>(fa); // s1 != nullptr，说明 fa指向的内存对象 是SON1类型
SON2* s2 = dynamic_cast<SON2 *>(fa); // s2 == nullptr
' 其实就是在判断： (*fa)的类型 只有是SON1时： 将fa -> SON1*类型，才是合理的。
SON1 s1;
FA& fa = s1; '引用的本质是指针，所以（这种写法，和FA* fa = new SON1，本质一样！！）
try{ SON1& s1 = dynamic_cast<SON1 &>(fa); // 正常
SON2& s2 = dynamic_cast<SON2 &>(fa); // 报错！！
}catch(exception){}
' 注意，dynamic_cast必须应用于：虚函数和继承的情况！！！
' 即你的fa类，必须有“虚函数“！！！ 如果FA没有虚函数，dynamic_cast<XX>(fa); 编译就会报错
' dynamic_cast就是处理：FA* f = new SON 和 FA& fa = s1; 的情况！！
' 其实就是多态。
FA* fa1 = new SON(123); 'FA里面有虚函数
FA& fa2 = son1;
/* fa1的“静态类型”是：FA*； fa2的“静态类型”是：FA&
所谓“静态类型”，是在变量声明时 编译期间，就已经“得知”的！！！！
“动态类型“是： 他只针对于”指针、引用“来说的， 即该指针/引用 所指向的内存 的类型！！！
而对于非指针引用 或 不涉及虚函数： 他自然没有动态类型这一说，或者说他的静态动态都一样。
但这里， fa1/fa2的动态类型(含义是：fa1/fa2所指向的内存 的类型)是： SON类型。
只有涉及到虚函数： 才会有静态类型 和 动态类型，不一致的问题。 */
Son* son = new FA(); '错误， 子类指针 不可以指向 父类对象
Fa* fa = new Son(); '正确， 父类指针 可以指向 子类对象
fa->子类Son的成员; '错误！！ 虽然fa指向子类对象，但毕竟fa是FA类型，他不能访问子类的东西
'那么，fa不能访问子类的东西，为什么还允许fa 指向 子类对象呢？？？
class FA{
void func(){ C("1111"); }
}
class Son1 : public FA{
void func(){ C("2222"); }
}
class Son2 : public FA{
void func(){ C("3333"); }
}
'如果我们要： 可能调用Son1的func函数(2222)，也可能调用Son2的func函数(3333)；
' 你可能会这样写：
Son1 s1; s1.func();
Son2 s2; s2.func(); '这种方式，你定义了“2”个变量。
Fa* fa = new Son1; '此时， fa->func() 他调用的 还是(1111)，而不是(2222)
'因为，fa是FA类型，他自然只能调用自己FA的函数。
' 引入：虚函数
class FA{
int a;
virtual void func(){ C("1111"); } '虚函数的写法
} '===注意，虚函数 必须要“实现”出来！！！ 这一点非常重要!!!! ===
'如果：virtual void func() final {...} 虚函数加上了final，则不允许子类重写！！
class Son1 : public FA{
int b; '规范问题： 子类重写父类的虚函数，最好前面写上virtual，这是规范
virtual void func() override{ C("2222"); }
} '后面的override 同样是规范！！ 因为“虚函数”的重写 必须是“同返回值，同参数列表”！！
'你void func(int)就不是对应的父类的虚函数！！！
'override就是完全配合虚函数使用的，假如你子类 不是同返回值 同参数，override就会报错
'即override修饰的函数，一定是个子类的函数，且该函数在父类里 一定是个虚函数。
class Son2 : public FA{
virtual void func() override{ C("3333"); }
}
Fa* fa = new Son1;
'1，fa->a这肯定是正确的 因为fa是FA类型，用人家自己的成员变量 肯定是可以的。
'2，fa->func()这是个难点！！！ fa如果要调用(111)的func，肯定是可以的，毕竟就是人家FA的东西
' 但这里，fa->func()是调用的(2222) 此时是“父类指针，调用 虚函数”！！！
' 那么，他是“动态绑定”，即运行到fa->func()这段代码行时，才知道 要调用的是 哪个son的func
' 可能是son1的，也可能是son2的。 即“运行”时 根据new的哪个子类 选择调用哪个函数
/* 虚函数：
1， 他是“重写”，即必须完全的“同返回值”“同参数列表”
父类是： virtual void func(int){}
则子类的虚函数重写，必须是： virtual void func(int);类型 （前面的virtual可以略）
如果是void func(int,int)，他就不是虚函数的重写， 因此要规范加上override 表明是重写
2， 父类的虚函数，必须要“实现”出来，不能只是声明出！！！ 这是虚函数很重要的性质！！！z
因为父类的虚函数，子类可以不重写！！！ （虚函数，子类可以重写 也可以不重写！）
如果是：FA* fa = new Son1; 如果子类没有重写，就会调用父类的虚函数
假如son1没有重写，就会调用fa的虚函数 （此时，不允许fa的虚函数是没有实现的）
这与普通函数不同，普通函数 即使不实现，只要你代码里没有使用该函数 也可以的
因为在编译期，会检查 你是否使用了该函数。
但，这里是“动态绑定”，编译期间 是不知道 你究竟要调用哪个函数！！！
3， 虚函数，一定是配合“父类指针”使用的！！！
如果是用“普通对象”来调用虚函数，则虚函数的作用就体现不出了
因为对象是obj.的方式，他在编译期就知道 不涉及动态绑定，而new 在运行时才知道。
=== 这里也拓展， new 即指针的ptr->xxx 方式，他是运行时才知道的。 === */
' 多态，就是针对虚函数的。 如果没有虚函数，有就没有多态这个概念了
'===记住“多态”的核心： FA* fa = new SON1/2/3; 这就是他的核心！！！！===
' 1，多态体现在“具有继承性质”的父类和子类之间，子类重新定义父类的虚函数
' 2，通过父类的指针，只有到了运行时（new的那段代码行），才能找到动态绑定在父类指针上的对象
' 这个对象，可能是父类 也可能是子类，从而调用 父类/子类 的虚函数
class FA{
virtual void func() = 0; '这个是“纯虚函数”，只能声明 不能实现！！！
} '一旦类中有了纯虚函数， FA a / FA* a=new FA; 都是错误的！！！
'带有纯虚函数的类 叫做：“抽象类”，他不能有实例化对象。
'抽象类里， 也可以有“已经实现了的函数” FA* a = new SON; 这是正确的！！
'此时的a，他虽然是FA*类型，但他是指向的SON类型的，
'抽象类，用于做父类，所有继承的子类 都必须实现这些纯虚函数。
' “纯虚函数”他也是“虚函数”，因此 也是符合虚函数的性质的（即支持多态）。
' 我们知道，虚函数的精髓 就是“ FA* f = new SON;” 这么一句话 （调用父类+子类的构造）
' 那么，new的内存 你肯定需要自己去释放；
delete f; '但这句话， 只会执行“FA的析构”（因为f是FA*类型）
'即，你执行了2个构造 却只执行了1个析构！！ 内存，一定没有清除干净！！！
' 比如有X个构造， 你就要执行X个析构。 这才是清除干净了！！
' 即，你此时 需要执行FA的析构 + SON的析构，才是正确的。 如何让他自动执行SON的析构呢？？
' 涉及到“虚函数”， 就要把父类FA的析构函数 也写成virtual虚函数！！！
'我们思考： 将父类的~FA析构函数 写成虚函数，他会产生什么影响呢？
' 1，父类的析构是虚函数，所有他的子类的析构 也“自动的”变成了虚函数！！
' （这类似于： 父类的void func(int)是虚函数，那么子类的void func(int)也就变成了虚函数）
' （当前，规范是： 最好子类的虚函数 也写上virtual。 虽然不写，也是完全一样的）
' 2，此时子类的~SON也自动的变成了“虚函数”。
' FA* f = new SON; 虽然f是FA类型，但他可以f->func 从而调用“子类”实现的func函数
' 同理这里也是一样，虽然f是FA类型，但因为~SON是虚函数 所以是可以调用到他的。
=== 即，只要涉及到继承， 就把父类FA的析构函数 设置为：虚函数！！ '规定！！'
=== virtual ~FA(){} 这是规定！！！ 必须这样写，否则就无法执行“子类的析构” ===
=== 这样， FA* f = new SON; 但delete f时，他会调用FA和SON的析构 ===
class Son : Fa{
Son(){ DE(1); } '可以看到，你Son的构造函数 是空的，就没有涉及到Fa的构造
Son(int){ DE(2); } ' 那么，为什么 Fa的构造函数 总是先与Son一步呢？？？
}
Son s(123); '为什么Fa的构造，会先于Son的DE(2)呢？
/* 其实，“子类的所有构造函数” 如果没有写 “父类Fa的构造”
比如，Son(){..} 他就等价于： Son() : Fa() {...}，“必须放到：初始化列表里“！！！
比如 Son(){ Fa(123); } 他其实是形如： Son() : Fa() { Fa(123); }
即对于所有Son的构造函数，他一定会在进入 “Son构造函数的{...}”之前，执行Fa的构造！！！
要么你不显式规定，要调用哪个父类构造，即： Son(xx){ ... }
那么，他一定会在进入{...}之前，调用Fa的无参构造！！
=== 可能你的{...}又执行了Fa的构造，即Fa的构造函数 会多次调用 ===
=== 但在{..}里写FA的构造，没有任何用！！！ 即临时创建了FA的内存，然后又立刻释放了！！===
要么你显式的规定，即： Son(xx) : Fa(xx) { ... }
这样的话，也是在进入Son的{...}之前，调用了Fa(xx)的构造函数，不会自动调用Fa()无参构造了 */
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
/* 我们思考： class Son : Fa 这句话，到底底层干了什么？？？
猜测： 单纯这简单的 继承“:Fa"一句话，他会执行： （比如是：Son -> Fa -> GFa）
1， 递归到GFa （先创建GFa的内存 ， 然后调用GFa的构造函数）
2， 回溯到Fa （ 先创建Fa的内存 ， 然后调用Fa的构造函数）
3， 回溯到Son （先创建Son的内存 ， 然后调用Son的构造函数）
即你简单的一句： Son s; 他不仅只有Son的内存对象，还有Son的所有父类的内存对象
只不过，你看不到“Son的所有父类的内存对象” 只是你使用不到它，但它是真实存在的！！！
也就是，千万不要以为 你Son s的消耗 只是Son里的变量，（因为sizeof(Son)是非常大的，包含父类）
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
再思考，继承要干什么呢？？ 你Son，不就是想使用“父类Fa、GFa”的data和func嘛~~~ */
class Son : Fa{
'在这个Son类里面，通过Fa::data 或 FA::func()的方式，调用Fa/GFa的数据和函数！！！
'也就是，虽然此时是有Fa和GFa的对象obj的，但你得不到这个obj，无法通过obj.data来调用。
' 只能通过： “ FA:: ” 的方式，来使用FA和GFa的数据和函数。
}
Son s; ' s.data/func的方式，可以得到：Son/Fa/GFa的数据和函数
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
class Son : Fa{
Son(Fa* f = 0); '构造函数
}
SOn::Son(Fa* f) : Fa(f){ ... }
'看这样的一份代码，到底在做什么....
/* 这个Son(..)是构造函数，他的参数 是一个父类型的指针，当然无需关注他是什么类型
只需知道： Fa类有一个构造函数 参数也是这个参数！！（即： Fa(Fa* f){}）
然后，当我们调用Son的构造时，先调用了Fa的构造。
其实你这样说 非常不严谨。 比如Son s; 他是（创Fa内存 调用Fa无参构造 -> 创Son内存 调Son无参构造 */
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
' 父类对象，不仅可以单独存在 还可以作为子类对象的一部分而存在； 这是什么意思呢？？
FA fa; 'fa是个父类对象，这叫做单独存在。
Son son1; 'son1是个子类对象，但他里面 其实是有个“父类对象”的！！！！
' 为什么会这么说呢？ 因为(FA)son1 这种类型转换是合法的。 说明son1里 肯定是有个FA对象
' SON s; FA fa(s); 他会调用： FA(const FA& f)的拷贝构造！！
' 也说明： s他自动转换为了FA类型。
=== 即在必要的时候， 子类SON 是会自动的转换为 父类FA类型的！！！ ===
' protected： 在继承(涉及父类子类)时，才会用到他
' 表示该变量，只能被当前类/当前类的子类，所访问到。
' private： 只有当前类能访问到，他的子类 不能访问到！！！
class FA{
int a , b , c; 'a是public， b是protected， c是private
}
Fa fa; '外界只能fa.a，不能访问b和c
class Son : _?_ FA {...}
Son son;
/* 其中的_?_，表示 以哪种“权限”来继承FA父类。
public FA： Son类里可以访问到a和b， 且a在Son中是public类型，b在Son中是protected类型！！
外界只能son.a，其他son.b和c都是错误的
protected FA: Son类里可以访问到a和b. 且a和b在Son里 都是protected类型！！！
虽然a在FA是public类型，但Son是通过protected方式继承的FA，a到Son里 变成了protected
即Son的子类，是可以访问到祖先的a和b的
外界通过son. 谁也访问不了son.abc都是错的
private FA: Son类里可以访问a和b. 且a和b在Son里 都是Private类型！！！
即Son类里是可以访问ab，但Son的子类 访问不了祖先的ab。
外界通过son. 谁也访问不了 son.abc都是错的 */
class FA{
void func(){...}; '这3个重载函数，都是public的
int func(int){...};
LL func(int,int){...};
}
class Son : public FA{
' 在子类Son中，没有关于FA的func的重写
' 则无论是在Son这里类里，还是是在外界son.XX，都可以直接调用FA的3个重载函数！！！
}
class Son : public FA{
Son(){
' 但如果，你在Son中 重写了func函数（此时无关返回值和参数，只要重名即可）
' 则此时，则无论是在Son这里类里，还是是在外界son.XX， 只能访问 int func(double)
' 父类的那3个函数，就完全消失了！！！
' 你现在在ST()构造里，只能访问string func(string)这1个函数！！！
FA::func(); '如果你非要访问FA里的func，就要通过FA：：的方式 来访问。
}
string func(string){...} '重写了func，导致FA的3个func 都失效。
}
Son son; 'son.func只能访问 Son里定义的这func。
'通过son.FA::func()方式，你可以访问到 FA里的3个函数！！
' 还有一种最暴力的方式，来解决“函数遮盖”的问题： using
class Son : public FA{
using FA::func; '使得父类的这3个func函数，在子类Son中 再次定义出现（重载）！！
Son(){
'此时，直接func() 他可以调用4个不同的函数（3个FA，1个Son自己的）
'同时，外界son.func() 也有4种选择。
}
string func(string){...}
}
class ST{
ST(int a, int b = 123);
}
ST::ST(int a, int b){ // 这个b，不可以有默认值！！
}
' 这上下两种写法，都是可以的。 声明和实现，只能有1个含有默认值
class ST{
ST(int a, int b);
}
ST::ST(int a, int b = 123){ }
class ST{
int a, b;
ST(int a, int b = 0); '注意这里，初始化列表 不能写在.h的函数声明里！！！
} '初始化列表，必须写在.cpp的函数实现里！！
ST::ST(int a, int b) : a(a), b(b){}
'如果一个类ST，他不想当“父类“ 即不允许有子类继承他！！！
class ST final{}
class XX : ST{} '错误
class ST final : FA{}
class XX : ST{} '错误
' static_cast静态转换，就当成最普通正常的转换即可，和C的括号()方式 差不多
' 是“编译”期间进行的，说明 他是不会进行正确/安全性的检查，你需要使用仔细
int a = (int)2.999; ' C的风格
int a = static_cast<int>(2.999); ' C++的风格
static_cast<父类>(子类); '不能颠倒， 父类转为子类 这是编译期间做不了的！！
' 在“运行”期间，进行类型检查 比如，将父类转换成子类！！
/* C++将内存分为了5个区域：
1，栈： “函数”内的局部变量
2，堆： 使用new申请，如果没有delete 程序结束后，OS会进行回收
3，全局/静态存储区： 全局变量，静态变量
4，常量存储区： 常量，不允许修改。 比如用""包含起的字符串 就是常量
5，程序代码区： 存你的程序代码
栈： 空间有限（这是系统所规定的），分配速度很快，你无法控制他的分配和释放。
堆： 你可以自己决定所要分配的内存大小，不要超过实际的物理内存大小即可。
分配速度要慢，可以用new来分配，很灵活。 */
' void* malloc(int bytes); void free(void*);
int* p = NULL;
p = (int*)malloc(10 * sizeof(int)); '分配40字节
if(p != NULL){
...
free(p);
}
' new不用去关注，你要分配多大(bytes)的字节，这很麻烦。
' 你如果只要1个， 就直接： T* p = new T; -> delete p;
' 如果你要100个 即一个数组： T* p = new T[100]; -> delete[] p; 注意这种写法
// 注意，new时是数组[]，就要对应delete[]这种方式。
// delete时，不用写具体的数组元素个数(100) 写了也会被忽略掉
// ===系统有办法知道，这个数组的大小===
int* p = new int; ' *p 为任意数
int* p = new int(123); ' *p 设置初始值为123
i = 123;
i ++, a = i; ' 注意，a == 124！！！！！
// （后置i++）他是遇到“逗号,”就会让(i+=1)！！！
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
(i ++)：
1，他会申请一个变量：int temp_i = i; 然后立刻返回！！！
并且，这个temp_i会被标记为"右值"，<不用管什么是左/右值，他只是个标记>
<什么叫标记呢？ 给了你一个X变量（即T X = ??）
<如果告诉你X是个右值，就说明： X这个变量，"马上"就会被释放(临时变量)>
2，立刻让i += 1； （即，主要出了这个 {i ++}： 1，他会返回一个对象 2，i += 1）
' 比如： a = (i ++); 令(i ++)中，其内部产生的临时变量是temp_i (其值 == i)
' 首先，执行a = temp_i; (时刻注意，temp_i也是个变量！！（不用管他是左值还是右值)
' 要么： int a = temp_i; （temp_i是个int型的变量，自然可以用int来接受）
' 要么： int&& a = temp_i; （temp_i不仅是个变量，还是个"右值“变量）
' 所以， 可以用“右值引用” 来 引用到这个 ”右值变量“上。
' 所谓”右值引用”，也不要把他想的太复杂。
' 首先1，他肯定是“引用”！！！ 即int&& p = a; (保证a是个右值变量)
' 即修改（p = X）或者 修改（a = X）； 都会使得 -> (p == a == X)
' 即，这就是普通引用的用法。 ==没啥区别！！==
' 只不过，int& p = a（保证a是个左值）。 int&& p = a（保证a是个右值） 就这点差别
' 总之，执行完（a = temp_i）之后，再执行： i += 1；
==== 即，一共是做了“2”个事情！！====
int i = 5;
int& p = (++ i); '注意，(++i)返回的对象，就是（i这个对象）！！！
' 即p = (++ i)： 第一步， 执行i += 1操作，并且（++ i）就是返回i这个内存。
' 第二步， 执行p = i; 这个操作！！
' 此时， p和i 是指向的同一块内存，因为p引用到了i
int&& p = std::move( (++ i) );
' (++ i)： 他会返回i这个内存（i = 6）；
' move（左值i）： 他并不会返回一个temp_i，他就是返回的 i这个内存本身！！！
' move，只是做了一个“强转”！！！ 即把i，在这个语句内，强转为“右值”
' 即move的作用是： 告诉编译器，这个左值i 我以后不会再使用他，他即将被释放掉。
===此时， (&p) == (&i); 这两个p和i，指向同一个内存！！
===不用管，p是左值/右值引用， '左值/右值'只是在类型匹配，绑定时，会使用到
=== "只要已经绑定成功了（现在p已经引用到i上了）"，那么p和i，就是同一块内存
=== 此时， 修改（p = x）或者（i = x），都会使得： p == i == x
void func(ST t){ ... }
' 如果是func( obj ); t是通过调用ST的拷贝构造函数(obj)的方式，创建出内存
' 然后，func结束后 t的析构执行。
' 如果是func( 123 ); 且ST有ST(int){}的构造函数。 “隐式类型转换”
' t会调用ST(int){}的构造函数创建内存， 然后调用析构
int array[ sizeof(int) ] 在C语言里，对吗？
' sizeof()是编译期间的运算符，在编译期间就确定了
权限(私有/公用/保护) 类里定义函数
C的struct： 不能 不能 'C里可以有：函数指针
C++的struct： 能 能
' 判断一段程序，是由C编译器、C++编译的呢？
' 每种类型的编译器，在进行编译时，会“内置一些宏定义”
#ifdef __cplusplus
DE("这是C++编译器")E;
#else
DE("这是C编译器")E;
#endif
' 1，成员： class的成员 默认是private的 struct是public
' 2，继承： class的继承 默认是private的 struct是public
' 1.cpp里的static int A; 他的作用域“仅限于1.cpp”里！！！ 即本文件内
' 我们知道： 1.cpp里有int A， 那么在2.cpp 就不可以有int A
' 你只能在2.cpp里，通过extern int A; 来“共用” 1.cpp里的int A
' 但，如果1.cpp里是static int A; 则这个A，就作用在1.cpp里。
' 你不能在2.cpp里 通过"extern"来引用1.cpp里的A。
' 换句话说， 你在2.cpp里 可以定义int A； 这两者是不冲突的！！！
class ST{
int a;
STT b;
ST() " : " { ... }
} '在构造函数的“ : ”时，就会给所有成员变量“分配内存”！！！
'即b的无参构造会被调用！！ 即还没有进入{...}之前，a和b就已经有内存了！！！
' 因为{...}就是干“赋值”的事情的！！！ 如果连“内存”都没有，赋值肯定是不可行的。
' 因此，你也可以想到在{...}之前，ST的所有成员变量 就已经分配了内存 真实存在了！！！
'即使你不写":" ， 他也自动会有： ST() : b() { ... } 因为b要创建内存的呀~
' 但假如，你要给b自定义初始化，比如调用他的STT(int)的构造函数。
' 如果你写成： ST(){ b = STT(123); } 一共调用了“2次”STT的构造函数！！！
ST() : b(123) { ... } '这样写的话： 他用调用“1次“STT构造函数！！！
' 构造函数： 他是用来“创建内存”的！！！ 他的底层，非常复杂！！！
' 不要以为，你单单通过调试，就可以看清楚“构造函数”的工作
' 即只要涉及到ST a...;这种形式， 有ST开头，说明这是在“定义”，即“需要创建内存。
' 则一定会调用“构造函数”
'构造函数（创内存），他分为两种： 1，普通构造函数 2，拷贝构造函数
ST() : ... { ... }
ST(int a) : ... { ... } '普通构造函数，可以写多个！！！
ST(const ST& t , int a=1, int b=2) : ... { ... }
'拷贝构造，和普通构造，非常相像。 唯一区别是：他的第一个参数是“const ST&" 这是死的！！！
' 后面也可以继续有参数，但必须要有“默认值”。
ST a(); '这是错误的！！！ 他不会调用“无参构造”
ST a; '这才会调用“无参构造”！！！
ST a(123) ' 他会调用“有参构造”
'你只要是：ST a... 这就是“要么构造函数，要么拷贝构造”！！不会调用“赋值运算符”！！
ST a = b; '这两种方式，都绝对不会调用”赋值运算符“，因为连ST a这个对象还没有创建出！
ST a = ST(123); '即便你有=等于号，但要么调用构造函数，要么是拷贝构造函数。 只有这2种可能
ST a = ST(); '不要这样写！！！ 虽然也是调用“无参构造”，但他还会调用”拷贝构造“
'虽然你调试，他只会调用“无参”。 但如果你把“拷贝构造”设置为explicit，这句话是报错的
'应该是： ST()调用无参构造。 然后这个tmp对象，调用ST a(tmp)拷贝构造。
'反正你要知道：现在是在创建a(a连内存都没有)，而构造函数（普通构造、拷贝构造）就是分配内存的
' 底层确实很乱，难以分析。 但绝不会调用“赋值运算符”，因为a连内存都没有。
' 因为很复杂，所以一定要牢记：
' ST a = ST(..)这种写法： 既会调用构造，也会调用拷贝构造！！！
ST b(a); '这是调用“拷贝构造”的最正规的写法！！！
ST b{a}; ' 即便拷贝构造有explicit， 这两种写法，都是会调用“拷贝构造”的
ST b = a; '这个"=号"就很影响，你会以为和“赋值运算符”有关... 和它没有任何关系！！
'因为，这里有ST开头，说明是在“定义变量，创建内存”，一定只和“构造函数”有关！！
'他会把ST b=a 变成： ST b(a); 这种形式！！！ 即只会调用“拷贝构造"
'而这种ST b(a)形式，就是最正规的拷贝构造函数的调用方式。
' 这个（ST b=a）变成（ST b(a)），就是“隐式拷贝构造“ 你加上explicit就报错了。
ST b = ST(123); '这里和上面的(ST b = ST()一个问题。)
'你这样分析： ST(123)肯定是调用了“有参构造” 从而创建了tmp对象。
' 于是：ST b = tmp 再变为： ST b(tmp) 调用了“拷贝构造“
' 虽然这个“拷贝构造”的调用，你调试不出。 但你改为explicit，就错了。
'explicit一般用于“单参数的普通构造函数”， 对于”拷贝构造函数“ 就不要加explicit了。
当然，”构造函数“肯定是和“创建内存”有相当密切的联系，所以你会以为 他俩是同一个东西。
你可以这样认为： 在“创建该类内存”后，会立刻的“调用构造函数“
因为，我们思考： 构造函数 只有在“定义变量”时，才可以调用！！！
case1： ST s; '先创建内存，然后调用s的构造函数
cast2： Son s(123); 其中，Son(int a) : Fa(a){ ... } // 注意，这个:Fa(a)是初始化列表！！！
1，创建Fa内存 调用Fa的”有参“构造Fa(a)。 2，创建Son内存 调用Son的”有参“构造 */
SON s; '只要执行到这一行： 1，先执行FA的构造 2，再执行SON的构造
'在程序执行到“return 0"时， 会自动销毁s这个局部变量！！
' 1， 先执行~SON的析构函数； 2， 然后执行~FA的析构函数（SON的父类）
// 即构造是“从内到外”的， 析构是“从外到内”的
// 这两者必须对应！！！ 有X个构造，就应该有X个析构！！！ （否则，一定是有问题的）
FA* f = new FA; ' 构造函数，他是取决于“new FA"这句话的，和前面的FA*类型无关
' new FA： 只会调用FA的构造函数；
' new SON： 1，调用FA父类的构造 2，调用SON的构造
FA* f = new SON;
'即使程序执行了“return 0” 也不会执行析构，即系统不会自动给你释放内存！！
' 因为“new”出来的内存，是完全由“用户”所决定的！！！ 你要负责他的申请和释放！！！
' 所以，你造成了“内存泄漏”，
delete f; ' 你必须执行： delete f（他才会执行析构函数！！）
' 因为f是FA类型的指针（虽然他指向SON内存）， 所以只会执行“FA的析构函数！！！”
' 可以发现，这里有个大问题！！！ 你new SON，即肯定是申请了一块SON的内存。
' 而最终只是执行了FA父类的析构，就没有执行SON的析构； 说明，你肯定没有删除干净！！！
SON* f = new SON;
delete f; '因为f是SON类型指针，在delete时： 1，先执行~SON的析构 2，再执行~FA的析构
ST& func(int a){
A = a;
return *this;
} /* *this可以返回“自身对象”的引用。
this是“成员函数”里 隐藏起来的 “函数参数”，表示指向当前对象的指针
*this自然是对指针取值，即该对象本身。
this只能在“成员函数”中 使用。
在调用成员函数时，编译器会将该函数“重写”成：
函数实际是： ST& func(ST* const this , int a){}
调用实际是： obj.func( &obj , 123 );
这也就解释了： 为什么在成员函数里，可以直接调用”A“这个成员变量
因为，你使用A这个成员变量， 其实他是this->A 的形式。
this是"指针常量” (注意区分“常量指针” const ST* 和 ST* const)
即该this总是指向“该本体对象”，不能指向其他地方。
如果成员函数是const的： func() const{}
那么他实际上是： func(const ST* const this){} 的形式。 */
' class里可以有：static成员变量，static成员函数。
class ST{
static int A; '这只是“声明”，该变量 并没有定义出来！！ 可以当成，就没有他
static void func(int);
}
int ST::A; '这才是“定义”出来了，即分配了内存。 在定义时，无需写static
'你通过： ST::A 和 obj.A 这两种方式，都可以修改A这个static变量。
void ST::func(int c){ '静态函数的实现，也不需要写static
B = c; '这是非法的！！ 静态函数，只能使用“静态变量”！！！
A = c; '这是可以的。
} ' 同样，你可以通过 ST::func(123) 和 obg.func(123) 两种方式，来调用静态函数
class ST{
const int A = 123;
ST(){}
ST(int c) : A(c){} ' 对const的初始化，必须放在“初始化列表”里，不能通过赋值方式
}
ST st1(); ' 对于st1来说，他的st1.A就已经const了！！ st1.A==123 永远不能变了。
ST st2(456); ' st2.A = 456！！！ 且也是永远不能变了。
' 可以发现，虽然最初A=123，按说不能变了。 但这个const，他还是变了！！
' 说明，构造函数 他的权限是很大的
' const必须要初始化有值，如果没有A=123，那么st1就是非法的。
class ST{
void func() const; ' const的对象（const ST s），只能调用const的成员函数！！
} ' 非const的对象（ST s）， 所有的函数(不管是否const) 都可以调用！！
class ST{
mutable int A;
void func() const; '该函数里，你A = 123;肯定是报错的。 因为该函数是const的
} '或者，const ST s; 你s.A = 123; 肯定是报错。 因为该对象是const的
' 但假如说，你就想修改A的值 (不管是在const函数里，还是const对象里，就要修改A)
' 1种做法是：把func函数改为非const，但不好 -> 导致const对象，就调用不到func了！！！！
' 引入mutable，他就是用来修饰“某个成员变量”的！！！
' mutable的成员变量表示：无论什么情况下，他“永远”都是可以改变的。
const ST s;
s.A = 123; '这是合法的！！ 可以看到，s虽然是const的，但const是一个很”虚“的概念。
void func() const{ A = 123; '这也是合法的。' }
class ST{
void func(){
' 直接在class的定义里，实现成员函数 他会自动被当做“inline函数”来处理。
} ' 当然，不一定成功。
} ' 因此，如果你直接在类里 实现某个成员函数，尽量简单些 以增加inline成功的概率。
/* C++的struct 成员默认都是public的。
而C++的class， 默认都是private的！！！
class ST{
int a; '他是private的
};
C++的struct的继承，默认是public。 而class的继承，默认是private */
class ST{ ' 在h1.h中，头文件里 只写“声明”
int num;
void init();
};
void ST::init(){ ' 在1.cpp里，实现该类的函数
num = 123;
}
' 在2.cpp里，就不能再对init()进行实现！！！ 因为在1.cpp里 已经实现过了
' 隐式构造函数转换，即对于构造函数ST(int)，不一定非要形如ST(123)来会创建对象
ST(int a){}
ST(int a, int b){}
ST a(123); '这是最正规的写法。
ST a = {123}; '他的意思是： {123}他会“创建临时对象”ST(123)，然后对象进行”=赋值“！！！
' 即{123}这个东西， 他会“隐式”的转换，转换成一个“ST的对象”！！！
ST a(123,456); '这是最正规的写法。
ST a = {123 , 456}; ' {123,456}会调用“构造函数”，创建出一个临时对象ST(123,456)
' 这个右侧的临时对象tmp， 再赋值给a对象！！！
void f1(ST a){} '你写： f1( {123} ); 他通过ST(int)创建了ST的对象tmp，赋值给a了。
void f2(ST a){} '你写： f2( {1, 2} ); 他通过ST(int,int)创建了ST的对象，再赋值给a。
' 但我们的初衷，也许不是这样。 这是编译器自动帮我们做的。
' 为了防止这种“智能化”的做法。 引用explicit，写在”构造函数的前面“！！！
' 表示，该构造函数 必须通过ST(int)的方式来构造，不能通过{int}来自动转换。
vector<int>::reverse_iterator it = v.rbegin();
*it; ' *it他返回的是： 引用！！！
const vector<int> v{1,2,3}; '表示：这个vector里面的元素，都是不能改变的
vector<int>::const_iterator it = v.begin(); ' *it = 12; 是错误的
'而且，因为该vector是const类型的，所以v.begin() 其实是const类型的。 == v.cbegin()
vector<int>::const_iterator it = v.cbegin(); 'cbegin()返回的是：const类型迭代器
vector<int*> v;
auto it = v.begin(); '注意，迭代器是“指针”！！ (*it)才是vector里的元素！！！
'*it 就是一个int*。 所以 *(*it) 才是一个int
const char* p = string.c_str(); '必须是const类型，c_str()他是以'\0'结尾的
vector<int&> v; '这是错误的！！ 引用他只是个别名！！ 不是一个对象！！
'不要在for循环里，添加/删除vector的元素！！！ 因为vector一旦修改，他里面的迭代器就会“失效”！！
int* p = new int(123);
vector<int*> v{ st };
vector<int*>::iterator it = v.begin();
' p == *it; p是指针，指向(123)的地址。 it是迭代器(指针)，*it是vector里的元素(指针)
' *p == *(*it) == 123
delete (*it); '这里不是删除vector的元素。 而是删除的(int* p)这块内存
int func(double);
int func(double a){ ... } '函数的前置写法
auto func(double)->int;
auto func(double a)->int{ ... } '函数的后置写法
/* nullptr是C++11引入的
typeid(NULL) == int； typeid(nullptr) == nullptr_t 这两个是不同的。
通常： 对“指针”的初始化/赋值，都用nullptr最好。 */
void func(void* f) { '重载函数
' func( nullptr );会进入这里
}
void func(int f) {
' func( NULL );会进入这里
}
' const是可以“运行时求值”的
const int A = 123 + func();
' c++11引入的， 他是“编译期间”求值 自然会提高运行效率
struct{
char A[X]; '他的sizeof == X （不存在对齐问题）
};
struct{
int A[X]; '他的sizeof == 4*X （不存在对齐问题） 比如4*3=12 (不是8倍数) 也是合法的
}; '即，若结构体只存在一种类型变量， 不会产生“对齐问题”
struct{
int A; '但，只要有{>=2}种类型变量，就会产生“对齐问题”
double B; '即，此时他的sizeof == 8的倍数。 12 -> 18
};
/* 对齐问题： 主要还是为了“效率”！！！
在Windows下 是凑成"8"倍数。 而在Linux下 是凑成“4”倍数。
比如你的真正的sizeof是12.
在windows下， 会补齐为16字节。 在linux下，会补齐为12字节。
这会导致，在linux下 丢失数据了！！！ -> 引入#pragma pack() */
#pragma pack(1) // 这句话是：告诉编译器，对齐方式为(1)字节对齐
struct{ // 即，他实际是多少字节，就是多少。 不进行对齐！！！
int A;
double B; '4 + 8 = 12， 那它就占用12字节
};
#pragma pack() // 恢复，即让编译器的对齐方式
struct{
int A;
double B; '12字节， 但会对齐到16字节
};
'auto的“自动类型推测”，发生在“编译期间“，不会降低程序的运行效率
/* 使用cout输出时，实际上是在往“输出缓冲区”中 输入内容
那么，输出缓冲区什么时候会把内容 输出到“屏幕”上去呢？
1，要么 缓冲区满了
2，要么 执行了main函数的return，程序要结束了
3，要么 使用了endl ( endl函数，他会调用flush()函数！！
而flush()会强制的将“输出缓冲区”的内容显示到“屏幕”上，然后将该缓冲区清空 )
那么问题来了： 为什么要设置这个”输出缓冲区“呢？
1，当我们cout时，确实是要将“每个字符” 输出 到”屏幕“上
此时，这个输出缓冲区 确实也没有作用。
2，但我们是在往“文件”里写入内容， 而文件是在“硬盘”上，速度太慢了。
总不能，写入“每个字符”，就要写一次文件。
而这个“输出缓冲区”，是在“内存”上，将数据临时保存到该“内存区域”上
然后最后，一次性的把所有数据写入“文件硬盘”上。
*/
' 不要把\r 和 \t给混了.... \t很简单，就是一个tab键而已
' 而\r是 “将当前的光标，移动到当前行的开头” ！！！
puts("12345\rABC"); ' 他会输出： A B C 4 5
'即光标移到开头后，会把你原来开头的"123"给覆盖掉！！！
int a = 2;
func:
if(a >= 1){
-- a;
goto func; '循环
}else{
C("我马上就要出循环了")E; 'func就是个语句！！ 不可以使用break/continue
}
func1:
int a = 123; '不要以为a是局部变量，不要以为a和C("fun111")是属于func1的内容
C("fun1111")E; '就当做把func1去掉！！！
func2: '即这5行代码，如果你没有goto语句
C("fun2222")E; '就相当于： func1: 和 func2 就等于没有写出来！！！
' 换句话讲， func1只是对代码的一个定位！！！ 类似于光标的作用！！
' 一定要理解这里！！！ 不要把func1: 当做是个命名区域 不是的！！ 他就是一个定位，给goto看的！！
goto func2; '他会直接：跳到C("3"); 然后紧接着到达“exit(0)"，
'即对于 C("1") 和 C("2")直接跳过！！
C("1");
func1:
C("2");
func2:
C("3");
exit(0);
/* 往文件里写数据时，不会立刻往磁盘上写。
系统会往一个“缓冲区”里写数据，当该缓冲区满之后 才会将缓冲区内容写到磁盘里，再将缓冲区清空。
假如，你直接退出程序，而没有关闭文件 fclose(..);
会导致：缓冲区的数据没有写到磁盘里，造成数据丢失。
而fclose(..)的好处是： 他的执行，会将“缓冲区“的数据 立刻写入到磁盘里！！！ */
FILE* file = fopen("in.txt" , "w"); '不存在则创建，否则“清空内容”！！！
' fopen会开辟出一块内存(大小为sizeof(FILE)的大小，FILE是个结构体)
' File里会存放一些： 文件名，使用方式，还有一个char*型的字符指针！！
' 该字符指针表示： 当前文件，从哪里开始读/写数据
if(file == NULL){
puts("文件打开失败");
}else{
char c = fputc('B' , file); '往file里，写入一个字符； B也可写成int
if(c == EOF)
puts("写入失败");
}
char a = fgetc(file);
while(a != EOF){
putchar(a);
a = fgetc(file); '从file中，每次读取1个字符 （FILE结构体里的指针，会自己移动）
} '但弊端是： 1个字节=255； 而char=127； 如果某个字节值为255（对应char=-1） 和EOF冲突！
'因此，引入feof(FILE*)函数； 他会自动判断（FILE结构体里的指针，当前是否指向了文件末尾）
char a = fgetc(file);
while(feof(file) == 0){ '要么返回1（说明指向末尾了）； 要么返回0
putchar(a);
a = fgetc(file);
}
/* 在windows OS下的文本文件txt，其二进制文件： 每行的末尾 会有连续的“0D 0A”
0D表示\r 即回到当前行的开头； 0A表示\n 即换行。
每一行，在末尾 都会有"0D 0A"来表示： 当前下标 换到下一行的开头。
'虽然，我们使用时 直接用一个\n即可。 但对应最底层，是2个操作！！ */
/* void func(int a){ ... }
其中，a称为“形参”， 在调用函数时，会被形参分配内存，调用结束后，形参的内存被释放
在真正调用该函数时：func(x) 其中，x称为“实参" */
/* 函数的代码，也是要占用内存的， 每个函数都会占用内存，会有一个起始地址。
因此，可以用“指针”指向这个函数的起始地址。 函数名，就是该函数的起始地址。
定义形如： 函数返回值 (*p)(参数列表);
p指针，可以指向所有与其有相同的“返回值，参数列表”的函数 */
int Max(int a, int b){
return 123;
}
int (*p)(int , int); '定义了一个“函数指针变量”，注意这种规范，必须是两个括号！！
' 也可以写成： int (*p)(int a , int b); 都可以
p = Max; '或p = &Max，都是让p指向Max函数的起始地址。 此时p和Max都指向函数的起始地址。
p(34 , 56); ' 以下这3种写法，都是正确的。 都相当于调用： Max(34 , 56)
(p)(34 , 56); ' 不要写成：p 、 *p 这些都是错误的。
(*p)(34 , 56); ' p()也是错误的， 他等价于：Max() 这肯定是错的，必须要有参数
'引申：你写成“ Max(int , double){ ... } ”的形式，说明我们不使用参数！！！
' 但你也要必须传递“2个”参数！！！ Max()也是错误的！！！
printf("%x , %x", p , Max); '输出Max函数的起始地址，都是一样的。 不能用cout来输出！！
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
int (*F)(double) = &func; '注意，F是个“变量”！！！ 函数变量
F(3.33);
typedef int (*F)(double);
F f = &func; '注意，F不是个变量 他只是个typedef！！！ f是此时“函数指针”的变量！！！
f(3.33);
using F = int(*)(double);
F f = &func; ' F只是个typedef！！！
f(3.33);
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
void func(int a){ ... }
void (*F)(int) = &func; 'F的返回值和参数，必须与func一致
' F的使用方式，和func是完全一样的！！！ 那为什么还要写“F这个函数指针”呢？？
/* 因为有些库函数，他接收的函数参数 就单纯一个函数名！！！ 不特定他的返回值和参数！！
这种情况，比如你的func函数 是有重载的！！！ 有func() 和 func(int)
那你的： 库函数(func)，究竟func是哪个函数呢？？ 不知道，你也无法分清楚。
解决方式是： void (*F1)() = &func; void (*F2)(int) = &func;
虽然后面都是&func，分不清。 但你的函数指针(F1,F2)的参数类型 是确定了的 */
' 当你要指向一个“全局函数”func时： 你要这样写。
void (* func1)(int) = &func;
' 当你要指向一个“成员函数”func时： 你要这样写。 注意这里的写法！！！ (ST::* func2)
void (ST::* func2)(int) = &ST::func;
void XX(char , int , unsigned int , long long , double){
return;
} '他的 typeid(XX).name()为： F v c i j x d E， 注意 与你的XX命名是没有关系的！！
' 不管XX是什么，其实编译器判断的依据是“返回值 和 参数列表”！！！
'void(v) char(c) int(i) long long(x) double(d) LL(x) ULL(y)等命名规则
' 比如还有个YY函数，与上面的XX的返回值+参数列表都是一样的，那么他俩的命名是一样的！！！
' 不关注，具体这两个函数内部的代码是怎样的。 只要返回值+参数列表是一样的，他俩的命名就一样。
int Max(int a, int b){ return max(a,b); }
void func(int a , int (*p)(int,int)){
C( p(12 , 45) );
}
func(123 , Max); '注意这里，传递的是Max，而不是Max(x, y)！！！
'因为p是要指向某函数的指针/地址， 而函数名就是地址，传递地址！！！
'注意，typedef就只有个改名的功能！！！
void (*p)(int , double); '这是在“定义”！！！定义了一个指针
typedef void (*FuncType)(int, double); '这不是在“定义”， 而是换了个名字！！！
FuncType p; '现在，你通过： FuncType p 就等价于“上面的第一个语句“ 定义了一个指针
void fun(int a , void (*p)(int, double)){ 'p是个指针，是个变量！！！ 写的麻烦。。。
p(1 , 2.333);
}
void fun(int a , FuncType p){ '起到了 和”上面一模一样“的目的！！！ 代码更简洁了~~
p(1 , 2.333);
}
void dfs1(int);
void dfs2(int);
void dfs1(int a){
if(a == 0) return;
dfs2(a - 1);
}
void dfs2(int a){
if(a == 0) return;
dfs1(a - 1);
}
/* 由于函数的使用，必须要遵循"从上到下“的顺序！！！
因此，像上面的代码 如果没有函数声明，一定是使用不了的 */
char str[] = "xx";
const char* p = str; 'const char* == char const*
p[0] = '.'; '报错！！！ 若p 是 char*类型，则是正确的。
str[0] = '.'; '这肯定是正确的。 说明：const char* 不是说：他指向的内容不可以改变
' 而是： “他指向的内容，不可以通过p这个指针改变！！
const int& p = a; '表示：不能通过p来修改a的值， 但a的值 是可以修改的
char* const p = str;
int* const p = &a;
' 类型* const： 这种写法为，“指针常量” 含义为：该指针必须指向这个内存，不能指向其他！！
' 因此，他必须要初始化。 你进行p = &a的赋值 、++p，只要是改变指针的指向，都是错误的！！！
int& p = 123; '错误！！！ 因为123是常量。
const int& p = 123; '这是可以的！！！ 这一点，同样适用于“函数传参”
void func(int& p){} 'func(123)这是错误的！！ 必须是const int& p的类型，才能传递“常量”
/* 程序内部会维护一张表，该表记录所有的“变量名”<->“其对应内存地址”的关系 */
int a = 1;
int* p = &a;
*p = 2; '注意，不要以为*p == 1，而是理解为：*p == a。 *p=2 -> 会导致a=2
p[3] == *(p + 3); '指针先后移动3位
int A[1005] = {123}; 'C(A) = 0x6011a0
int* p = A; 'C(p)=0x6011a0 , C(&p)=0x7fff32dba388 说明p也是个变量 , C(*p) = 123;
func(int a[] , int* b){
' C(a) = 0x6011a0 , C(&a) = 0x7fff32dbaa90 说明a也是个变量
' C(a) = 0x6011a0 , C(&b) = 0x7fff32dbaa98 说明b也是个变量
}
'指针数组， 是一个数组 存放很多个指针
int* p[10];
p[i] = &A[i];
const char* p[] = {"123" , "456" , "789"}; '这是他最大的应用；
'注意，p是个数组， 他里面是有3个指针！！！ 3个const char*类型的指针变量！！！
'数组指针， 他是一个指针！！ 指向一个[固定大小]的数组
int A[3] = {1 , 2 , 3};
int (*p)[3] = &A; '注意这里， 虽然A和&A是一样的，但语法规定 要使用&A
C(p) == C(A) == C(&A) = C(&A[0]); '这4个都是一样的。
FOR(i , 0 , 2){
C(p + i) / C(p[i]); '注意，这种用法都是错误的！！！
} 'p的类型是[3]（int[3]=12字节），你让p + 1，就等于：让p往后偏移12字节（已经越过A数组了）
int* tmp = (int*)p; '注意，这里要进行强转
FOR(i , 0 , 2){
C( *(tmp + i) ); '这才是，正确把A数组的值给输出出来！！
}
'数组指针
int A[2][3] = {1,2,3,4,5,6};
int (*p)[3] = A; '注意，这里又成A了； 即指向了A[0] 第一维度
FOR(i , 0 , 1){
int* tmp = (int*)p;
FOR(j, 0 , 2)
C( *(tmp + j) );
p ++; '注意这里的p++，他是[3]类型！！ ++会导致+12字节，指向了A的第二维度A[1]
}
char s1[] = "ABC";
char s2[] = "ABC";
' C(&s1); C(&s2); 表示的是，该数组内存的值“ABC”的首地址（因为，数组名 = 数组元素首地址）
' 一定要牢记， &s1表示的是： s1数组内存里的“ABC”的首地址。 sizeof(s1) == 4
' 因为，数组这个名字 他不像指针，他是不占内存的，他不是个变量！！！
' 你想想，他s1就是个数组，表示一块内存区域，里面不是存的s1，存的就是直接是这个数组的值。
' 而且，s1 != s2，说明 “ABC”这两个串 占据不同的内存！！
' 因为是把“ABC”放到不同的数组里，因为是不同的数组，自然内存区域是不同的。
const char* s1 = "ABC";
const char* s2 = "ABC";
' C(&s1) 他可不是“ABC”的地址！！！ 他是s1这个指针变量的地址！！！
' 你可以通过： C( &"ABC" )这种方式，得到在常量区里的地址
/* 但通过调试得知， 这个两个“ABC”的内存是一样的！！！
这里和上面，是完全不同的含义。 上面是，把“ABC”内存 放到了一个数组(内存)里面。
而这里，你是没有开辟一个数组/内存来 存储这个“ABC”内容的！！！ 你只申请了2个指针而已。
一个单纯的“ABC”字符串， 他是称为“字符串常量”，C语言专门有个内存 来存放字符串常量
而且这一特定区域，因为是常量！！ 即不能修改（只读） 所以要用const
用const也意味着，你不能修改“这块内存区域”！！ 即s1[1] = 'X'是非法的！！
所以，这里的“ABC”就存放在这个特定的内存区域，有固定的内存地址，即s1和s2指向相同内存！！ */
void func(int A[]){
C(A); C(&A); C(&A[0]);
' 但这里，A和&A[0]肯定是一样的，等于main函数中的123的地址。
' 但重要在&A这里！！！ 此时，因为是在传递参数！！ 所以此时的A，他确实是一个变量！！！
' 即&A != A， 但不要以为 数组名也是个变量，不是的。 只不过在函数参数这里，确实是个变量。
}
main(){
int A[] = {123, 456};
C(A); C(&A); C(&A[0]); '这3个都是一样的，说明：这个数组名A 并不是一个变量！！！
} '这个A 并不占内存， 而是表示 该数组里的首元素A[0]的地址！！！
void func(int* p){
C(p); 'p 为 &A的地址。
C(&p); '&p 他是个变量，而且是个临时变量，就指这个函数参数中p变量的地址。
}
main(){
int* p = &A;
C(p); 'p 为 &A的地址。
C(&p); '注意这里， 指针和数组名不同！！ 指针p 他是个变量 占内存，&p就是这个变量的地址
}
/* 多个cpp源文件 ->(编译)-> 多个.obj目标 ->(链接)-> 一个exe文件
在编译阶段：
1，预处理 2，编译 3，汇编 */
' 预处理包含： 1，宏定义 2，文件包含 3，条件编译
#define AB "123 456"
string s = AB; // s = "123 456";
'即，宏定义 他是不会”分割空格的”！！！ 他是看后面的整个行！！！！ 不会断开
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#define A(X) ... // ...里面，不可以有B(X)，宏定义遵循从上到下的顺序
#define B(X) A(X) // 这是可以的。
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
/* #define PI 3.1415926 #define就是宏定义命令，在预编译期间 会进行“宏展开”
宏展开，只耗用编译时间，不占用运行时间
#define的作用域，就是该cpp文件！！！ 其他cpp文件使用不到
可以用#undef PI来提前终止他的定义域
在宏定义时，常会使用到 \ 来表示，这些代码是同一行的，只不过分行了
#define P printf \ \的意思，就相当于：printf("123456");
("123456"); */
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#define C(x) cout << #x << " -> " << x << endl;
'这个#x的意思是： 你x所代指的参数，而且是一模一样！！！
'#的名称为： “字符串化”， 即传来的是什么 就把他转为string输出
C(123); '123 -> 123
int a = 123; '你传进入的“长什么样”， 那么你的#x 就会输出什么！！！
C(a); 'a -> 123
FOR(i, 1 , 2)
C(i); 'i -> 1 和 i -> 2
A[1] = 5, A[2] = 6;
FOR(i , 1 , 2)
C(A[i]); 'A[i] -> 5 和 A[i] -> 6
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
' #define是允许重复多定义的！！
// 1.cpp里
#include "h1.h"
#define A 123
cout << A; '即使h1.h里有(#define A 456)，也是会选择当前1.cpp里的对A的define，所以输出123.
' 但如果，当前1.cpp里没有对A的define。 则会输出(h1里对A的define)
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
__FILE__ '当前所在的文件。 （char s[X]类型）
__LINE__ '当前所在的行号。 （int类型）
__func__ '当前所在的函数。
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
'第一种方式：
#define Windows '这里可以不写后面的值
#ifdef Windows '#ifdef 和 #ifndef 刚好是相反的意思。但使用是完全一样的
int main() {...}
#else '这个else也可以不写
int main() {...}
#endif
'第二种方式：
int main(){
#ifndef Windows
C("yes"); '如果没有定义Windows，则输出Yes
#else
C("no");
#endif
}
'第三种方式：
#define Win10 0
#define Linux -1
int main(){
#if Win10 '从上往下走 #if/elif XXX，只要XXX {定义define出，且他的值!=0} 就停止
C("Win10"); 'Win10的值是0，不满足； 没有Win7的定义； 有Linux，且!=0，所以输出
#elif Win7
C("Win7");
#elif Linux
C("Linux");
#endif
}
#include "h1.h" // 这一句话 很简单，就是将“整个h1.h"文件的代码 直接copy过来！！！
#include "h2.h"
' 比如，你的"h1.h"中 有#include "h2.h"。
' 那么在这里cpp，你其实有2次的“#include <h2.h>”这个语句！！！
' 那么 代码重复不说，一定会导致： h2里的很多变量 多次的定义 -> 重定义，报错
// 因此， 涉及到书写”header.h"头文件时，要使用规范！！！ #ifndef
// 因为，#include非常容易发生 多重嵌套的情况，根本搞不清楚
#ifndef __H1__
#define __H1__ // 这里我们只定义即可， 给不给值都可以。
' ...写h1.h头文件的代码
#endif
'注意，这个__H1__定义，他在你的cpp文件里 他是可以使用到的！！！
' 其实，他就是定义在你的cpp文件里， 因为#include就是把代码copy到你的cpp里了！！！
/* 在1.cpp里，#include"B.h" 就意味着： 把B文件里的内存 添加到了当前文件中！！！
意味着，当前1.cpp文件里的代码行 会大大增加！！
#include的本质： 就是把要include的文件内容 复制到当前文件中
而且就是”你所写#include"xx.h"的这一行的位置上
<xxx.h> '他只会在“系统目录”下找
"xxx.h" '他首先会在当前cpp源文件目录下寻找，如果找不到 再去系统目录下找 */
typedef int Int_array[105];
Int_array A; '他就相当于： int A[105];
/* C语言的程序在内存的分布，由3个部分组成：
1，程序代码区
2，静态存储区
在程序运行期间，分配“固定”的存储空间。 全局变量，会放在“静态存储区”里，在程序一开始时
就会为全局变量分配内存，在整个程序执行期间，他们占据的内存区域地址 是不变的！！
3，动态存储区
局部变量、函数形参、函数调用的数据。 函数执行时分配内存，执行完毕 释放内存，是动态的过程。 */
/* 函数调用是会“耗费系统资源”的，因为要处理“函数调用，返回”等
需要不断的“压栈，出栈”，开辟内存。
引用inline后，会在“编译”期间，完成对inline的处理，不再有“函数调用”的系统消耗
直接让“函数本体代码”去替换， 但究竟会不会成功 要看编译器。
他类似于“#define宏展开”的过程。
inline成功后，会将该函数的代码 直接覆盖到 源代码里 -> 导致“代码膨胀”
constexpr函数，就是将该函数 写到 常量表达式里， 而且（constexpr函数，要写的简单些）
constexpr函数 他是自带inline性质的。 */
/* 多个cpp文件，他的变量和函数，都是公用1个的！！！
1.cpp里有全局变量A； 在其他cpp文件里，通过extern int A; 来引用它
1.cpp里有函数func(); 在其他cpp文件里，通过void func(); 来引用它
也就是说，多个cpp 你就当做 他们就是“同一个cpp”文件就可以！！！
在.h里，你也是可以“实现函数”的！！！
但一般， h1.h里放的都是“声明” 比如有1个： void func(); 函数声明
那么，你在1.cpp和2.cpp里，都去#include "h1.h"是没有问题的！！！
因为只有声明，没有实现。
但你不可以，让1.cpp去实现了func()，又让2.cpp去实现了func()，这是错误的！！！
对于“所有.h文件”中的某个声明函数f1 ，你只能选择“1个”cpp文件 去实现他。
如果是>=2个cpp，一定是错误的。
一定要牢记： 所有cpp，你就看成是1个cpp！！！！ 而#include的本质，就是简单的代码copy
即在多个cpp和include合并一起之后，其实可以得知：
一个函数是可以多次的声明的（你写100次也没问题）
但他的定义(又称实现)，只能是<=1次！！！
但如果，h1.h里放的是一个“实现”的函数： void func(){ .... }
那么，你在1.cpp和2.cpp里，都有#include "h1.h"，就是错误的！！
因为include的本质，就是代码copy。 而1.cpp和2.cpp，最终会合并一起
意味着： 你定义了多个“已经实现”的函数。 */
/* 1， 在局部变量（函数内） 使用static， 即func(){ static int A; }
该A，仅限于func()函数内部！！！！ 只不过是在静态存储区
2， 在全局变量 使用static， 即static int A;
该A，仅限于该.cpp源文件内 （其他cpp文件，仍可以定义A变量） 变成内部变量
3， 对函数 使用static， 即static void func(){...}
该函数，只能在该cpp文件内 （其他cpp文件，仍可以定义func函数） 变成内部函数 */
/* 1.cpp里有个void func(){...} 那么在2.cpp里 有也有void func(){...}
这是不可以的！！！ 只能有1个， 但如果2.cpp里 是int func(){...}这是可以的。
在2.cpp中，如果要使用1.cpp里的func()函数，则要通过void func(); 来声明出来。
（不管2.cpp里有没有声明<1.cpp里的func函数>，你都不可以重新定义一个void func(){...} */
/* 如果想让：1.cpp里的func函数，仅限于在1.cpp这个源文件区域里。
即，2.cpp里 也可以有完全相同的func()函数， 此时就可以让1.cpp的func函数 变成static类型！！
即在1.cpp里是： static void func(){...}
那么在2.cpp里， 就可以有 void func(){...} 这是正确的
*/
/* 但我们希望，在函数调用完毕后，该局部变量不会消失 而是继续保存他的值。
即，他所占内存不释放。 此时引入“静态局部变量”，但注意 该变量，他的作用域还是该函数内！！ */
void func(){
static int A = 0; '长期占用内存
++ A;
C(A); 'A的值，取决于func函数的调用次数。 有几次调用，A的值就是多少。
}
/* 一个程序，可以包含很多个.cpp源文件，但只能有1个cpp里面是有main函数的！！！
也就是说，其他的cpp文件 和 主cpp文件，写法规则都一样，唯一的区别是“没有main”函数。 */
/* 全局变量的定义（可以有初始化，也可以没有）
只有定义在他下面的函数，可以使用到他。
在多个cpp文件中，如果有多个int A的全局变量，这是不可以的！！
你在1.cpp里，有1个全局变量(int A)，那么就意味着 在所有的cpp文件中 这个A变量都是共享的！！
不可以再次定义，只能声明出来使用
extern int A的意思是： 在该cpp、其他cpp文件里，已经有对全局变量A的定义（注意是定义，即分配内存）
也就是： 单纯extern int A; 他是不会分配内存的！！！
至于A这个全局变量的定义在哪里，不知道， 反正是在某个cpp文件里。
该声明，一般是放在cpp文件的开头（#include的下面）
如果你想要1个全局变量，该全局变量就在当前这个cpp文件中有效，对于其他cpp无效
比如在1.cpp里有个A的全局变量，你还想在2.cpp也有个A的全局变量 （且这两个是完全不同的）
这也是可以的，你可以在1.cpp中 把这A的变量，设置成static int A;
这样，你在2.cpp里（extern int A;这是会报错的！！！） 1里的A，和其他cpp 没有任何关系
也就意味着： 加上“static”后，该变量就成了“内部变量”了，即只在该cpp有效。 */
extern int A; '注意，这个只是“声明” 不是定义！！！ 更不能有初始值，他是不分配内存的！！
void func(){ C(A); } '如果没有上面的extern，是使用不到的！！！
int A = 123;
/* 全局变量，是可以在多个源文件cpp里共用的！！！
比如，你在1.cpp里有一个int A=123的全局变量，如果要在2.cpp里使用它。
则，在2.cpp中 只要有一个声明即可： extern int A;
*/
char s[] = {'a' , 'b' , '\0' , 'd'};
' 他的sizeof为4，就是为这4个数组元素的大小； strlen为2 （遇到\0结束）
' 输出： cout << (s + 3); 是会错误的，因为末尾没有\0
char s[] = "abcd"; '数组就是数组，不是指针！！！ 他的元素 是会被覆盖掉的！！！
' 他的sizeof为5！！ 最后会补\0 所以cout << s是正确的。
char s1[20] = "xx"; ' s1="ABC" 或 s1=s2; 这都是错误的，不能直接赋值！！
char s2[10] = "xx"; ' 只能在初始化时，设置初值="xx"; 不能单独s2 = "xx"！！！
strcpy(s1 , s2); '形象为:s1 = s2， 即s1的原内容 会被覆盖成s2 （连同s2末尾的\0字符）
' 不能通过：s1 == s2来比较！！ 这是在比较地址
s1[0] = 0; '这两种写法的含义是一样的 ， 因为'\0'的ASCII码 等于0
s1[0] = '\0'; '其实你可以理解为： 将s1这个字符数组，“清空”！！！
char s1[] = "hello"; '此时, sizeof(s1) == 6
char s2[] = "world";
strcat(s1 , s2); 's1的sizeof还是6！！， 但strlen已经是10了！！！
'最好的写法是：
char s1[100] = "xxx";
strcat(s1 , s2); '(char* s1 , const char* s2) s2是不变的 提前给s1设置大些
struct/class A{
int data; '如果是class 默认是private！！ 如果是struct 他默认是public！！
}
最经典的将class分类是： string(带有指针pointer) 和 complex(不带有指针)
complex复数： data(实部加虚部) + func(加减乘除,共轭,正弦... 来处理实部虚部)
string： data(其实就是一个指针，指向字符串) + func(拷贝，插入,...)
----------------------------------------------------------------------------------------
class ST{
ST(int a):a(a){} // 写了这个，就没有默认构造了！！！ 此时只有这一个构造，没有默认构造
ST(const ST&) = delete; // 把编译器默认的拷贝构造给delete掉，即ST t1(t2) 禁用
ST(ST&&) = default; // 搬移构造
ST& operator=(const ST&) = default; // 拷贝赋值，使用编译器默认的
ST& operator=(const ST&&) = delete; // 搬移拷贝赋值
virtual ~ST(){} // 虚析构函数
}
-----------------------------------------------------------------------------------------
class ST{
struct STT{
char a;
int b;
};
}; // 此时ST是不占内存的！！！ 他里面没有变量，STT只是个定义，并没有定义他的变量！！
-----------------------------------------------------------------------------------------
struct ST{
ST(){ cout << "???"; }
}t; // t调用的是默认的构造，此时main为空，会输出一个"???"
// 如果是t[100]; 就会输出100个"???"; {ST t}或{ST t = ST()}，都会输出一个"???"
-----------------------------------------------------------------------------------------
struct ST{
int A;
static int B; '这里必须这样写，且不能赋予初值！！！ 而且，你并没有申请一个变量
'也就是：此时ST是没有B这个变量的！！ 你必须在外面 int ST::B; 才是声明变量
'且，static 是不占内存的， 即sizeof(ST)还是4！！
void func1(); '普通函数的声明
static void func2(); '静态函数的声明
}
int ST::B; '这里必须要有！！ 这是static变量的固定写法 （必须这么写，此时初值可有可无）
void ST::func1(){ '普通函数的实现
....
}
void ST::func2(){ '静态函数的实现
他，只能使用“静态变量”！！！
}
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
class A{
A() : data(0){} '无参构造
A(const A& tmp){ '拷贝构造
data = tmp.data;
}
A& operator=(const A& tmp){ '赋值运算符
if(this == &tmp){ '比如，当A中有一个指针（指向某个内存） 当赋值时：如果tmp就是他自己
return *this; '先释放掉原来这个指针的内存。然后memcpy，此时就会报错
}
data = tmp.data;
return *this;
}
}
1 ，. h ( header files) 类声明 、 标准库
2 ，. cpp ( main) 通过include来引用头文件
#ifndef __COMPLEX__ // complex.h -> 通过#include "complex.h" 来引用
#define __COMPLEX__
````````````````````````````````````````````// 正式开始写代码
#include<cmath>
class complex; // 1， 前置声明
complex& __doap1 (complex* ths , const complex& r);
class complex{ // 2，类的声明
....
};
complex::function .... // 3，类的定义
````````````````````````````````````````````
#endif
class complex{
public:
complex (double r = 0 , double i = 0) : re(r) , im(i){}
/* 构造函数： 就是来创建对象的， :re(r)是初始化 {}里面是赋值，两者是不同的 */
complex& operator += (const complex&); // 只是函数的声明，没有实现
double real() const{ return re; /* 编译器会变成: this.re; */ }
/* 但最终是不是inline由编译器决定！！！ 我们决定不了，一般非常复杂的函数 就不是inline
注意const的位置 (函数的后面，{}的前面)，如果不涉及改变对象的data，要加上const
*/
// 不带指针的函数(也就是除了string)，大多都不用写析构函数，因为编译器会自带他的析构
private: // 所有的数据，都要是私有的！
double re , im;
friend complex& __doapl (complex* , const complex&); // do assign plus
/* friend友元(朋友)，朋友可以来拿数据data，其他不可以
*/
}
inline complex& __doapl (complex* ths , const complex& rig){
ths->re += rig.re; // ths是要拿data的 他会改变， r是被取data的 是const
ths->im += rig.im;
return *ths;
}
// 若把构造器放到private里，则外部不可以创建class -> Singleton设计模式
class A{
public:
static A& getInstance();
setup(){ .. }
private:
A();
A(const A& rhs);
.....
};
A& A::getInstance(){
static A a;
return a;
}
// 通过：A::getInstance().setup(); 的方式来获取对象
/* 如果传递参数太大了，就要使用引用传递； 引用的底层就是指针，尽量都用引用传递
*/
T& func1(const T& a, const T& b){
T ans = a + b;
return T的引用;
} // 这样是不可以的，因为ans是在这个函数里的 我们返回ans的指针
// 但func1执行完毕后，他已经死掉了，自然他原来的指针地址也是失效的，此时不可以返回值为引用
/*
当：T t2(t1); 但我们没有定义T(const T& t)的构造方法！！
或 t2 = t3; 我们同样没有重载等于=号
编译器自带：拷贝构造(T)和拷贝赋值(=)！!!! 不用定义或重载 */
/*
运算符重载，有两种方式： 要么设计为成员函数，要么设计为全局函数
两者都可以，没有谁好谁不好，但必须二选一，不可以有两个冲突
*/
// 1: 写为成员函数
a += b; // b是参数，即下面的t ; a是目标 即当前这个类对象 他会传递到下面隐含着的this里
T& operator += (const T& t){ // 所有成员函数，他的参数 其实都隐含着一个this (this , ..)
this->val += t.get(); // 一定要注意，get必须是: get() const{..} 只要不修改，必须加const！！
// 因为此时t传来的是const，也就意味着必须不可以被修改，他调用的get()方法 也必须是const类型的。
return *this; // 注意this是指针，返回的是引用，*this是指针所指向的object数据
} // 返回的是数据value，接收的是引用。 这就是引用的好处
// 传递者 无需知道接收者是不是以引用来接收的，你就直接传递即可。
// a += b; b传过去，有可能接收的是引用 有可能接收的是数据value
T& T::operator += (const T& t){ // 他等价于上面的类里写法
... // 只要是看到： 类名::函数名 ，这就意味着他是成员函数
}
/* 对于简单的: a+=b; 如果返回值不是T& 而是void，值直接修改到this里，也是可以的
但对于： a += b += c; 这样会导致： 先b+=c完后，返回的是void，导致a+=b就为空了
因此使用T&为返回值是最好的。 */
// 2: 不是成员函数
T operator + (const T& a , const T& b){
return T(a.get() + b.get());
}
// 但对于特殊的操作符，只可以是全局函数，而绝不可以是成员函数
// 例如，cout的<<符号，就必须是全局，不可以是成员
ostream& operator << (ostream& os , const T& t){
return os << "value: " << t.get();
} // cout << t1; cout就对应于参数的ostream里的os， t1对应于参数的t
// ostream& os肯定不可以是const，因为把"..."丢到cout里， cout里肯定就改变了
/* 前置和后置， 都是碰到逗号, 就结束了！！ 而不是碰到冒号;
b = 2 * ++a , XX; 即b = 2*(a+1);
b = 2 * a++ , XX; 即b = 2*a;
无论是前置后置， 到XX之前 都运算结束了！！！ */
struct ST{
int a;
ST(int a = 0):a(a){}
ST& operator++(){ // 前置++i; -> 没有参数
++ a; // 等于 ++ (this->a); 前置很简单，因为就是此时做完即可 返回的也是引用 当前对象
return *this;
}
ST operator++(int){ // 后置i++; -> 带有参数int(但没意义)
ST ans = *this; // 不能返回引用 因为ans是临时对象！！！ {}完就消失了，必须是值传递
++ (*this); // 这就是后置的核心也是通用模板，即：后置调用前置！！
return ans; // 之所以后置可以完成暂停， 是因为取指针的值*的底层原理 跟这代码无关
}
};
class Fraction{ // 存分子 和 分母
int num , dem;
Fraction(int num , int dem = 1):num(num) , dem(dem){}
};
Fraction f(1,3);
double ans = 4 + f; // 我们的期望是等于：4.3333...
/* 方式1，我们对Fracion进行操作符重载有用吗？ 那它一定是：Faction + (T) 的形式，即Faction必定在前面
但显然这里Fraction是在后面，因此对Fraction进行操作符重载是没有用的。
方式2，全局操作符重载； 即double operator+ (double a, Fraction b){ return a + b...;}
这是可以的，因为操作符重载 要么是某个类的成员函数里，要么是全局函数
方式3，我们希望在必要的时候，把Fraction给转换成double类型，比如在此时 4+f 我们希望f转换为double
那么这样，4+f就可以运算了，这个转换函数的调用是自动的 编译器做的，关键是这个转换函数如何设计
规定： operator double() const{ return (double)num/dem; }
注意！！ 这个opertor跟运算符重载没有关系！！ 他必须要有空格分开 (运算符重载不需要空格)
double是表示： 我们要将这个Fraction转换成什么类型
()他不是运算符！！ 跟运算符没有关系！！ 这就是来指定参数的， ()自然是没有传参
按说要指定返回值类型，即double，但因为我们转换为了double 这个指定了的，那自然返回值就是double
因此返回值类型不用写，自然就是转换的类型。
*/
/* 一定要区别：运算符重载 和 转换函数！！
转换函数： operator int() const{ ... } 他没有返回值，operator后有空格 空格后是类型(int)
操作符重载： T& operator->() const{...} 他有返回值(void..)， 没有空格
*/
class Fraction{ // 存分子 和 分母
int num , dem;
Fraction(int num , int dem = 1):num(num) , dem(dem){}
Fraction operator+ (const Fracion& t)const{
return Fraction(num+t.num , dem+t.dem);
}
};
Fraction f(1,3);
double ans = f + 4; /* Fraction有+这个运算符重载，但这个4不是Fraction类型！！！
注意，此时编译器会自动的把4转换为Fraciton，为什么呢？ 因为F的构造只有1个参数！！！
F的构造：2个parameter，1个argument； 我们认为就1个参数即可，4自动的变为Fraction！！！！!!!!!!!!!!!
就变成了： (1,3) + (4,1) = (5,4)
*/
/* 此时我们得知： Fraction(int a, int b=1):a(a) , b(b){} 这个构造
不是说只有创建Fraction对象这一个作用！！！ 在必要的时候，编译器会把一个int(1)给转成Fraction！！！
为了避免这种情况 避免编译器自动帮一些类型调用构造函数，我们加入explicit
*/
即： explicit Fraction(int a , int b=1):a(a),b(b){}
这样，只有Fraction(a,..)才会创建对象， 避免其他情况会创建对象的情况
/* 对于上面的Complex类型，编译器会默认提供一个自带的拷贝构造和拷贝赋值 T t1(t2); t1 = t2;
但对于这种class类里带有指针的，我们不要使用编译器自带的拷贝构造和拷贝赋值，因为带有指针 非常危险！！！
如果使用默认编译器的拷贝，他是浅拷贝 只是按bit赋值而已，即两个指针同时指向同一个内存
我们需要做的是深拷贝，即两个指针指向不同的内存。
*/
/* 字符串：char*指针指向头 然后后面一整串，有两种规范形式：
1，C/C++采用的， 最后有一个结束符合'\0'
2，后面没有结束符号'\0'，但最前面多一个整数 来标识该字符串的长度
*/
class Mystring{
private:
char* data;
public:
Mystring(const char* cstr = 0); //构造 ， 传入指针
Mystring(const Mystring& str); //拷贝构造 ， 接收的是自己这个class
Mystring& operator=(const Mystring& str);
~Mystring(); //析构 ， 当该类的对象死亡时，调用析构
char* get_c_str() const { return data; } // 一定要养成习惯，不涉及修改 就加上const
};
inline Mystring::Mystring(const char* cstr){// 注意，原型有cstr=0， 这里不可以有cstr=0!!
if(cstr){
data = new char[strlen(cstr) + 1]; /* 注意这里！！传来的这个cstr，要么是空指针
要么代表一个字符串的头指针，这个cstr的末尾肯定有一个'\0'，比如cstr是“a b \0"
那么他的stlen是2 不包含末尾的\0，这个\0就是cstr的一份子！！！
也就是strcpy肯定是会把这个cstr里的\0给赋值到data里！！！ 即data的内存应该开辟3大小 而不是2
strlen会得到的是2，因此要加1 */
strcpy(data , cstr);
}else{ // 空指针，用户要创建一个空的字符串，注意这里的写法
data = new char[1];
*data = '\0';
}
}
inline Mystring::Mystring(const Mystring& str){
data = new char[ strlen(str.data) + 1 ];
strcpy(data , str.data);
}
inline Mystring::~Mystring(){
delete[] data; // 数组的free，必须带有[]
}
inline Mystring& Mystring::operator=(const Mystring& str){
if(this == &str) // 自我赋值： a = a
return *this;
delete[] data; // 杀掉自己
data = new char[ strlen(str.data) + 1 ];
strcpy(data , str.data);
return *this;
}
ostream& operator<< (ostream& os , const Mystring& s){
os << "(" << s.get_c_str() << ")"; //Mystring不符合cout，但char*是内置 他符合cout
return os;
}
// stack
栈：他是存在于某个作用域(scope)内的一块内存空间(memory space)
比如当我们调用函数，函数本身就会形成一个stack来存放他所要接收的参数，临时对象，返回的地址。
临时对象，又称自动对象(自动清理，析构自动调用)
// heap
堆：由操作系统提供的一块全局global内存空间，程序需要通过`动态new`的方式来获取若干个块(blocks)
// new
new: 先得到一块内存空间，然后调用构造函数
T* t1 = new T(1);
底层过程：
(1) T* t1;
(2) 得到内存： void* memory = operator new( sizeof(T) );
"operator new"是一个函数，其内部调用malloc(n)得到sizeof(T)这么大的一块内存
(3) 把2得到的内存，强转类型： t1 = static_cast<T*>(memory); // memory和t1的指针指向相同
(4) 通过3得到的t1指针，调用构造函数： t1->T::T(1); 其实是(this, 1); this隐含
// delete
: 先调用析构函数，再释放内存空间
delete t1;
底层过程：
(1)调用析构函数： T::~T(t1);
(2)释放内存： operator delete(this);
"operator delete"内部调用free(this);
T t0(0); // 全局变量，也可看成是static，整个程序结束后，才会消失
mian{ // 这个大括号{} ， 就称为一个作用域
T t1(1); // t1所占用的空间是来自于stack 即临时栈对象，{}指向结束，t1自动就死亡了(调用析构)
T* t2 = new T(2); // 他是heap里的 即堆对象，必须我们手动给delete掉
static T t3(3); // 当{}结束，他仍然存在，直到整个程序结束后(析构才会被执行)
delete t2; // 如果不删，就造成内存泄漏(这个new T(2)对象还在内存里，但这个指针t2已经死亡了)
}
// 内存
比如我们T* t1 = new T(1); 这个T所占的是8字节
我们动态得到内存，其实不只是8个字节： 我们会多得到前面[front]32个字节 + 后面[back]4个字节
然后再加个两个cookie，每个是4字节，值为000xxxx1，最后1表示这个内存给用户了
此时是：8 + 32 + 4 + 4*2 = 52
由于每一个内存块，都是16的倍数。 (52 -> 64) 最终占64字节，这就是实际的！！！
最终：[cookie(4)] [front(32)] [我们要的T(8字节)] [back(4)] [为补齐的额外pad(12)] [cookie(4)]
cookie的作用： malloc和free双方规定好：我们在这个内存区域的上面 放一个cookie
cookie就是我们的new/delete对内存操作的根据，是根据cookie的值来执行的
64的16进制是：0000040，因为所有16的倍数的0x进制的最后一位一定是0
因为借用最后一位的0/1： 1表示借出去了 即给用户了，0表示收回来了 即在os手里
如果我们new来得到内存，则这两个cookie的值为00000041
如果我们delete还给os，即这两个cookie的值为00000040
// 动态开辟数组的内存
T* t1 = new T[3];
和上面的new T(1);有一点不同的是，他还会用4个字节 来存3这个数 标识数组元素个数
// 即new中的operator new(siz) , siz = sizeof(T) * 3 + 4, 这个4字节就来记录3这个数
[cookie(4)] [front(32)] [记录3(4字节)] [我们要的数组(8*3字节)] [back(4)] [cookie(4)] = 72
72 补齐-> 80; cookie的值为：00000051
delete[] t1; 一定要带上[]，这是删除数组的写法，delete是根据cookie的值删的
因此即使是delete t1; 这个80的内存，也会被删除，但析构函数 只会调用一次！！！
因此，delete[] t1; 他会调用3次析构
// 如果类不大，就不用开内存 使用栈空间即可。 但如果很大，必须要手动开内存！！！
class T{
int A[1000][1000]; // 这么大的空间，栈空间是放不了的！！！！
}t;
main(){
T t; // 这是不可以的！！！！ 爆栈了！！ 或者是我们把T t; 放到全局里，即别在方法里！！
T* t = new T(); // 必须是这样！！ 最好的方法就是： 直接放到class定义的后面 {...}t;
}
/* 重载： operator new/new[] 和 operator delete/delete[]
注意，我们不是重载的new，而是operator new !!!
因为new： 1，得到内存 void* mem = operator new( sizeof(T) ); 在这里重载
2,指针转型 ptr = static_cast<T*>(mem); 3，构造 ptr->T::T();
*/
void* operator new(size_t siz){ return MyAlloc(siz); }
void operator delete(void* ptr){ return MyFree(ptr); }
void* MyAlloc(size_t siz){ return malloc(siz); }
void MyFree(void* ptr){ return free(ptr); }
// 即T* t = new T(123); 这就会调用我们重载的operator new()函数 来进行内存分配
// 但如果是：T* t = ::new T(123); 这是不会调用我们的重载函数！！！
// 因为::new 会调用的是 ::operator new()代表全局
struct A{
int data = 123123;
A(){ C("A - constructor")E; }
~A(){ C("A - destory")E; }
};
struct B{
static A a; // 静态成员变量的声明（没有定义），他是没有内存空间的！！
int data = 123;
};
B b;
b.data; '这是正确的。 也就是说，此时 只要不使用b.a 程序就是正确的
'只有b.a这是错误的。 因为B里，其实就没有a这个对象，没有定义 没有分配内存
struct A{
A(){ C("A - constructor")E; }
~A(){ C("A - destory")E; }
};
struct B{
static A a; // 静态成员变量的声明（没有定义），他是没有内存空间的！！
};
A B::a; // 对静态变量的定义
/* main是空的。 但他会“调用A的构造，和A的析构” 。
说明：对于类静态变量，只要定义出来（即声明+定义），那么 即使你没有使用到他 但会被分配空间 */
struct B{
inline static A a;
} ' 在c++17之后，可以使用inline (直接把“声明” + “定义”)，此时a是定义出来了的
/* 这里a是一个“类class”类型的静态变量，那么不管程序是否使用到a
编译器，都会为a分配内存！！ 即A a他的构造函数，会直接被调用！！（全局变量也是这个模式）
但如果a，是一个普通的类型（非静态成员变量） 如果程序没使用a，编译器没有为他分配内存 */
void func(){
static A a;
}
/* 在函数里，与在类里不同。 你直接：static A a; 这就是定义。
但如果你没有执行func()函数，那么他和在类里不同。 这里他是不会自动为A分配内存的！！
只要调用func，才会为a分配内存。 且以后执行func，不会重复分配内存 */
只要是在数据data 、 函数func的前面加上static ，就变成了静态函数/ 数据
对于非静态的函数调用，比如t1. func / t2. func ， 他的底层是： func ( & t1) , func ( & t2)
# 注意这里，非常重要，一个对象t1这块内存 他里面肯定有他的data，因为每个对象的data都不一样的
# 但我们知道类里的func是不占这个类的大小，即他不是这个t1对象所特有的
# 即func他对于所有的对象 都是完全一样的，只是不同的data，因此注意！！！ 一个类的func 在内存只有一个！！
# 而不是像data有多个，所有的对象t1, t2... 都公用一个func接口， 通过传入t1所在的内存地址来操作func
# 即t1. func ( ) ，不要想成是调用了t1对象里的func函数！！ 其实是func调用了t1这个对象！！
# 即编译器会把t1. func ( ) 转换为：func ( & t1, . . ) 即我们得到的this 指针 指向t1这个对象地址。
# 也就是类中的普通 ( 非静态) 函数，一定有一个this 指针！！！ 来标识要对哪个对象进行func操作
静态数据：比如银行的"汇率" 所有人的汇率都要是一样的，因此要使用static
静态函数： 我们知道类的func都是带有this 指针 来标识对哪个对象进行func，但静态func是没有this 指针
即静态函数与对象无关！！ 显然得不到对象，那么他只能访问到静态数据 `静态函数只能调用静态data` class T{
public:
static int num; // 不可以在这里设置num的初值(编译错误)，这就是C++的规定
static void setNum(int t);
};
int T::num = 123; // 一定要注意这里，必须前面带有类型int，不可以直接T::... = 123;
// 我们可以不设置num的初值； 即在这里写：int T::num; 必须这样声明出来！！ 在类里不算作声明！！！
void T::setNum(int t){
num = t;
}
/* T t1; // 与java不同，c是使用 :: 来取得static的
cout << T::num << ' ' << t1.num << endl; // 使用t1.num就等于是 T::num
T::setNum(33) // 使用t1.sutNum(33) 就等价于使用 T::setNum(33) */
# 单例
class T {
public :
static T & getObj ( ) ;
} ;
T & T : : getObj ( ) {
static T t;
return t;
}
static const auto io_sync = []{
ios::sync_with_stdio(false);
cin.tie(nullptr); cout.tie(nullptr);
};
int main(){
'只是，全局定义了“io_sync"， 但他是不会自动执行的！！！
io_sync();
}
一个项目里，有多个cpp。 每个cpp 里面都有一些“静态变量”{全局 、类里的静态对象(已定义)}
那么，其实这些变量的 初始化的顺序{谁先分配内存构造的顺序}， 我们是未知的！！！
常量性分为两种： 1，物理常量(每个bit位不变) 2，逻辑常量(表现形式不变)
C++采用物理常量！！
struct ST{
int* p;
};
int a = 123 , b = 456; 'const必须有初始值
const ST t = {&a}; // t.p的值，永远不变 为&a 即t.p = &b这肯定是报错的！！
*t.p = b; // 但，我们修改了他指针的值！！ 即此时a == 456;
'这是违背了逻辑常量性的！！ 即C++的const是物理常量性，通过mutable可以支持部分的逻辑常量性
-----------------------------------------------------------------------------------------
class A{
void func() const{..} // const函数必须是类的成员函数，全局函数是不能加const的
// 非const的对象 肯定所有的函数都可调用； const的对象 只能调用const函数，这必然的；
};
constexpr是C++11引入的，为常量表达式，即在编译器可以求值的表达式。
-----------------------------------------------------------------------------------------
constexpr int b = 43;
constexpr int a = b * 2 + 1; // b必须是const/constexpr类型
const int a = func(); // 返回值为int，这是可以的
constexpr int a = func(); // 返回值必须是：constexpr int func()
class cout : public ostream{ ... }; // 说明cout继承自ostream (o是output的意思，输出流stream)
class ostream : virtual public ios{
ostream& operator<<(char/int/long/.... x){
return (*this) << x;
}
}
string使用了"reference counting"这种技巧，即他可以被共享 (共享：是设计模式的一部分)
比如有4个完全一样的字符串，他们其实是共享同一个内存的
int A[] = {1 , 2 , 3 , .....}; // 让这个数组, copy到vector里
// 1
vector<int> v1(A , A + n);
// 2
vector<int> v2(n); // 需要提前分配好内存！！
copy(A , A + n , v2.begin());
// 3
vector<int> v3; // v3并没有内存！！！
copy(A , A + n , inserter(v3 , v3.begin())); // inserter会在指定位置后，插入元素 他帮开内存
-----------------------------------------------------------------------------------------
'即copy(容器头 , 容器尾 , 指针/迭代器)'
copy(begin(A) , end(A) , v.begin()); // [] -> vector; v必须有空间！！
copy(A.begin() , A.end() , B); // vector -> []; B数组必须有空间！！
Mystring(const char* p){...} // 构造
Mystring(const Mystring& p){...} // 拷贝构造
Mystring& operator=(Mystring& p){...} // 拷贝赋值
Mystring(Mystring&& p) noexcept{...} // move迁移拷贝构造，普通和move版本，差别就多了一个引用&
Mystring& operator=(Mystring&& p) noexcept{...} // move拷贝赋值，只比普通多一个&
// 迁移拷贝(构造/赋值)，都属于浅拷贝，即只是新拷贝了一份指针！然后把原来的指针置为(NULL)
virtual ~Mystring(){
if(data) delete data; // 以前是直接delete，现在有move(指针会置为NULL)，要判断是否为空
}
T t(t1); // 普通的拷贝构造
T t(std::move(t1)); // 你必须保证以后不会再使用到t1这个对象
/* move虽然非常快，但他是浅拷贝，只是指针的拷贝，会把原来的指针置为了NULL
应用1， 比如对应临时对象！！ xx.insert( T(123) ); 这是个右值，即临时对象
编译器会自动的调用他的move版本的copy(如果有)，因为这个对象以后不会再使用到
*/
'宏定义，就是单纯让代码变得简短
#define macro_1(name)\
cout << name << endl; // 在这一行下面写的，不属于宏； 除非这里末尾添加"\"
int main(){
int abc = 123;
macro_1(abc); // 相当于：cout << abc << endl;
}
// default和delete的用途1 -> 应用于 构造/析构/拷贝构造/拷贝赋值
struct ST{
public:
ST() = default / delete;
ST(const ST&) = default / delete;
ST& operator=(const ST&) = default / delete;
~ST() = default / delete;
}
// delete的用途2 -> 应用于 重载的operator new/...
struct ST{
static void* operator new/delete/new[]/delete[](..) = delete;
}'删除的含义是： ST* t = new ST()就不可以使用了！！！
用template< class / typename T > 都可以用来定义函数/ 类模板，在使用上 两者没有区别
只要使用template，调用时，就必须是：XX < > 的形式，即使里面是空，也得有< >
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
template< class T = int>
struct ST {
ST ( T a) { cout << a << endl; }
} ;
ST < int> ( 123 ) ;
ST < > ( 123 ) ;
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
template< typename/ class T >
void func ( T a) {
cout << a << endl;
}
func< int> ( 123 ) ;
'即template里，使用class / typename，则对应为< 类型名int/ double/ ... >
template<typename... types>
struct ST{
};
ST<int, double, long long> s;
template<int t> 里面放具体的量，即传入一个值作为参数，而不是类型。
但注意，这个t 只能是整数{int/ long}，且是const常量！！！
' template<double t> 这是不允许的！！！ <class t = double> 而class放类型是任意的
----------------------------------------------------------------------------------------
template<int var1 , int var2 = 456> // 对于有默认值的，必须放到最后面！！
struct ST{
ST(){ cout << var1 << ' ' << var2 << endl; }
}
ST<1,2>(); // 输出： 1 2
ST<1>(); // 输出： 1 456
ST<a, b>(); // 注意，ab必须是const类型的！！ 即const int a,b;
'即template里，使用具体类型int/long(不能是double)，则对应为<123、const变量>
template<int... vars>
struct ST{
ST(){
int A[] = { vars... }; // 可变长的名字，不是vars，而是vars...
for(int* p = begin(A); p != end(A); ++p)
cout << *p << endl;
}
};
ST<1,2,3,4,5,6>();
template<class T, T a> '一定要注意，T a是一个值 只要是模板传入值，就不可以是double！！！
struct ST{
ST(){ cout << a; }
};
ST<int, 123>(); // 输出: 123
ST<double , 10.33>(); // 这是错的！！！ 模板常量，不可以是double
template<class T>
void func(T t){
...
}
func(123); '按理说，我们应该指定类型，但对于函数模板，他可以根据实参类型 来推断模板的类型
'即我们可以像使用普通函数一般，使用模板函数。 他根据输出的123，推导出T为int
'也就是说： 函数参数是一定要按规矩来的(是几个参数就几个)！！！！
'但函数模板未必一定要带模板参数<..>，甚至模板<>号都可以不写。 他会根据函数参数来推导模板
'但类模板必须要模板参数<>， 类模板没有实参推导...
----------------------------------------------------------------------------------------
template<int... vals> struct ST{}; 'ST的类型，不是ST<int...>！！！ 而是ST<int,...未知>
template<int... vals> '这个函数的模板参数是一个int的可变长， int...
void sort_print( ST<vals...> t ){ '这里的t也可以不写，如果不会使用到的话
/* 注意这里！！！ 我们想让函数参数来接收一个ST类型，但我们知道ST是类模板
(类模板没有实参推导)，他必须要指定模板<>，由于ST是一个模板 我们不知道他是什么类型
他的类型，取决于这个函数的模板。
注意！！！ 此时函数的模板是int...即他是常量 ，不是类型！！！！ 即函数传来的是<1,2,3....常量>
而注意，ST类的模板他是需要的也是常量！！！ 即比如是：ST<1,2,3,..>
我们正好可让函数的模板vals，去作为ST类的模板。 此时这个函数已经构造好了。
当调用时，我们可以不写函数模板 因为可以实参推导； 我们直接让一个ST对象：ST<1,2,3>() 作为函数参数
而不写函数的模板； 那么函数模板int...是什么呢？
注意，不是说我们模板是vals 参数是vals... 两者对应就可以匹配，不是的！！
他是进行的函数模板推演。 即根据ST<1,2,3>() 会推导出，模板vals为(1,2,3) */
template< class Key >
struct hash{ 1111 } ;
template< >
struct hash< char> { 2222 } ;
template< >
struct hash< int> { 3333 } ;
// 参数个数的特化
template<typename T , typename Alloc=...>
class vector{ .... };
template<typename Alloc=...> // 第二个参数Alloc还是使用的泛化
class vector<bool , Alloc>{ .... };
/* vector实际上是有两个参数的<类型 , 分配器> 我们的特化不一定要对两个都特化
也可以只对第一个参数<类型>进行特化， 第二个参数<分配器>不进行特化 还是使用的泛化 */
// 参数类型的特化
template<typename T>
class My{ .... };
template<typename T>
class My<T* >{ ... };
/* 我们是对T类型进行的泛化，按理说特化应该是某个T类型，但我们也可以使用的他的指针
My<string> m这肯定进入的是泛化； My<string*> 这会进行特化 */
void print(){} // 这个可变参数的终止函数，必须在可变函数的上面！！！！
template<typename T , typename... Types> // typename... 就是数据类型，可以是不同的类型们
void print(const T& a , const Types&... params){ // 注意写法：Type&...
cout << a << ' ' << sizeof...(params); // sizeof...()可以知道params到底是几个参数
print(params...); // 注意不是params，要有... params传参后，会分解为1个 + (n-1)个，以此类推
}
print(3 , 5.555 , "abc" , true);
// 先是(3 , ...)输出3，然后是(5.555 , ..)输出5.555，然后后("abc“, ...)输出abc ... 递归下去
// 最后是： (true , ..) 输出true后，是() 注意此时就没有参数了！！！！
// 因此，必须再写一个空参的处理函数，且在可变函数的上面 ！！！
namespace std{
...
}
/* 1：using namepsace std; 本来是std::cout ， 现在直接cout
2：using std::cout; 我们只使用一个cout
*/
class queue{ // queue的底层实现
protected:
deque<T> c; // 底层容器； queue类里，有另一个deque类； 这就叫组合
public:
reference front(){ return c.front(); }
void pop(){ return c.pop_front(); } // queue的功能，都是调用底层deque的
};
class deque{ // deque的底层实现
protected:
Itr<T> start; // 16字节
Itr<T> finish; // 这又是一次"组合composition"
T** map; // 指针的指针，还是个指针 4字节
unsigned int map_size; // 4字节
};
class Itr{
T* cur; // 四个指针，因此Itr的大小是 4*4 = 16
T* first;
T* last;
T** node;
};
/* queue -> deque ;
构造是由内到外的！！ 先调用deque -> queue的构造函数
因此在queue中的构造 其实是这样的：queue::queue():deque(); 这是编译器自动完成的
析构是由外到内的！！ 否则先把内部的析构掉，内部垮掉 整个就垮掉了
因此在queue的析构中： queue::~queue(){ 析构queue....; 最后再~deque(); }
*/
/* 和之前的Compositon有些相似，只不过他用的不是直接一个类，而是这个类的指针！！
因此委托，又可以称为：引用方式的组合； 之前的组合，即queue里有deque，这两者的生命周期是完全一致的
但我们这里用的是指针，只有在真正使用到它时，才会真正创建出来，因此这两者不是完全同时产生的
*/
class MyString{
private:
StringImp* rep; // 之前这里是：char*，这个StringImp是真正的实现类！
// 好处是，我们可以指向不同的实现类; 这个MyString永远不用修改，动的是实现类
};
class StringImp{
friend class MyString;
char* data;
int count;
};
MyString1 -----|
MyString2 -----> StringImp1 -> "hello"
MyString3 -----|
/* 我们此时，有三个字符串(MyString123)共享同一个"hello world"
StringImp里有一个count属性，就是来记录此时引用的个数 (count=3)
这样做的目的是： 对于内容一样的，实现共享，这样很多对象共享同一个数据 节省内存
但当涉及修改时： 比如MyString1要修改，此时StringImp会单独拿一份"hello"给MyString1
然后StringImp1的count值就变成了2， 此时只有MyString23在共享“hello"
叫做：copyByWrite ， 但写的时候 就复制一份 */
/* 上述的"组合和委托"很简单，因为在C的结构体里就可以实现 */
struct Fa{ // 这里就把struct当成class就行，两者区别不大
Fa* prev;
FA* next;
void func1(){
...
func2(); // 注意，这里func2只是个接口，他最终是会调用子类的实现，父类是没有实现的
...
};
virtual void func2() =0;
};
struct Son : public Fa{ // 这个:冒号，就是继承
T data;
virtual void func2(){.....} // 纯虚函数，必须重写
}; // 这就是23个设计模式之一的： Template method
Son s;
s.func1(); /* 底层是： Fa::func1(&s) 因为子类没有func1
第一步：调用父类Fa的func1函数，因为成员函数都有隐含的this，此时func1虽然是父类的函数
但在执行func1函数时，那个this指针 其实是子类s的对象
第二步：在执行父类func1时，遇到func2函数，看func2在子类中 有没有定义，有定义就执行子类的
即会跳到子类的func2执行，然后再跳回完父类的func1函数。 */
/*
父类的数据，会被子类继承下来，(从内存角度看：继承下来的data，也会占内存)
父类的函数，也会被子类继承下来(他不应该从内存角度看，因为函数的继承，继承的是"调用权")
"继承的最大价值是： 和虚函数搭配一起使用"
子类Son： 构造，他会先调用父类的构造，然后再调用自己的构造！！ (构造，是由内到外)
析构，他会先调用自己的析构，然后再调用父类的析构！！ (析构，是由外到内)
注意：父类Fa的析构函数，必须是virtual虚函数 否则不是很好 */
/* 子类Son继承父类Fa，里面又有一个类Fri， 即既继承又组合
1，先调用父类Fa的构造 2，再调用组合Fri的构造 3，最后才调用自己Son的构造
如果Fri是在Fa类里，那么顺序是： 1，调用Fir的构造 2，调用父类Fa的构造 3，调用自己Son的构造
反正是： 构造的方式是，从内到外； 析构从：从外到内 */
class Fa{
int data;
virtual void fun();
};
/* 这样，编译是正确的。 但一旦如果你有：Fa f 这就报错了
*/
/* 子类Son继承父类Fa的函数，其实继承的"调用权" ，从继承的角度看，成员分：
1，非-虚函数： 父类Fa和子类Son中，必须至少有1个 实现该函数； 如果都实现，用子类的
2，虚函数： 它必须在父类中实现！！ 子类可以写也可不写， 子类写了用子类的，否则用父类的
3，纯-虚函数: 他必须不可以在父类中实现！！ 就当做是"抽象方法"，该类就变成了"抽象类" 不可以创对象！！ */
class A{
public:
void func1();
virtual void func2(); // 必须从父类A，即必须要在"此时"实现出来，这就是普通的虚函数！！！
virtual void func3() =0; /* 一旦有纯虚函数(抽象函数)，这个A类就立刻变成了抽象类！！！
即A类不可以创建对象！！ A a;是错的！！ 纯虚函数，必须只是个接口，不可以在此时实现！！
如果没有func3，A a是可以的，即只要没有纯虚函数(抽象函数)，则该类就不是抽象类 */
};
void A::func1(){ // 普通函数，此时可以不实现，但父类和子类中 必须至少有1个实现了
cout << "A -> func1() " << endl;
}
void A::func2(){ // 因为他是普通虚函数，必须在父类里实现出来
cout << "A -> func2() " << endl;
}
// 不可以实现func3， 纯虚函数 必须不可以实现。
class B : public A{
public:
void func1(){ // 普通函数的继承， 父类可以不写 子类可以不写，但父类/子类必须有>=1个实现了
cout << "B -> func1" << endl;
}
void func2(){ // 普通虚函数的继承， 父类一定已经实现了，此时可写可不写，优先使用子类的
cout << "B -> func2" << endl;
}
void func3(){ // 纯虚函数的继承，这个抽象函数一定没有实现，此时必须实现。
cout << "B -> func3" << endl;
}
};
class A{
int data1;
virtual void v_func1();
virtual void v_func2();
void func1();
void func2();
};
/* 如果没有虚函数，即(data + func) 则A的大小是4*2 = 8; (普通非虚函数，不属于类的内存)
只要类里有虚函数(virtual)，这个类就会多一个虚指针(Vptr)，不管多少个虚函数 都是用的这一个指针(8字节)
即，此时A的大小为：2*2 + 8 = 12，但他会凑成8的倍数 -> 此时A占16字节
即只要有虚函数，类里就会有一个Vptr虚指针，这个虚指针 会指向一个虚表(Vtbl)
虚函数表(虚表)： 存放当前这个类的所有可使用的虚函数指针，指向各个虚函数(不包括非虚函数)
他是一块连续内存，每个有虚函数的类 都有一个虚表，且所有该类的对象 都共享这个虚表。
A的内存： {这个虚指针指向一个表格Vtbl(虚表)}
[ Vptr(8字节) ]----------> Vtbl虚表(如下)
[ data1 ] [ 虚函数指针1 ]------指向虚函数----->[ A::v_func1内存 ]
[ 虚函数指针2 ]------指向虚函数----->[ A::v_func2内存 ]
{... 内存的某个角落里，有A::func1 和 A::func2函数，但他是普通函数，我们暂不关注} */
class B : public A{
int data2 , data3;
virtual void v_func1();
void func3();
};
/* 先不看B：A 不管继承，单看B: 4*2 + 虚指针(8) = 16 (满足8倍数)
此时加上了： B继承A -> 所谓继承： 1继承父类的数据 2继承父类的函数(注意，函数也会继承下来)
只不过函数继承的不是内存(况且一个函数所占内存是求不得的)，而是调用权！！
先看继承： 4(A的data) + 8(A的Vptr)； 然后看B： 8(B的data) + 8(B的Vptr)
但注意，Vptr只是一个指针(8字节) 不管有多少虚函数，因此A的Vptr和B的Vptr，会合并一起。
即： 4(继承的data) + 8(此类的data) + 8(Vptr) + <凑8倍数> = 24
即一个类的size = (此类的data) + (父类/爷爷类/..的data) + 8(只要此类/父类/爷爷类存在虚函数)
因为所有的虚函数，不管的定义的 还是继承的 还是覆盖的，都是仅仅对应一个8字节的指针！！！
而究竟是如何调用的呢？ 比如函数的覆盖问题是如何处理的呢？ (暂不关注对于普通的函数的继承覆盖问题)
注意此时：A有虚函数v_func1和v_func2，B自然会把他俩给继承下来(在虚表里) 即有A::v_func1和A::v_func2()
但因为此时B是重写/覆盖了v_func1，即虚表里，指向A::v_func1的指针会被干掉
换成一个：指向B::v_func2的指针。 即最终虚表里的指针指向为：A::v_func2() 和 B::v_func1()
B的内存： {这个虚指针指向一个表格Vtbl(虚表)}
[ Vptr(8字节) ]-----------> Vtbl虚表(如下)
[ A::data1 ] [ 虚函数指针1 ]------指向虚函数----->[ A::v_func2内存(继承) ]
[ B::data2 ] [ 虚函数指针2 ]------指向虚函数----->[ B::v_func1内存(覆盖) ]
[ B::data3 ]
{... 内存的某个角落里，有B::func3函数，但他是普通函数，我们暂不关注} */
class C : public B{
int data4 , data5;
virtual void v_func2();
void func4();
};
/* 已知B类有： 4*3(B和A类的data) + 8(Vptr) ， C类有：4*2(data) + 8(Vptr)
因此C的size = 4*3 + 4*2 + 8(Vptr) + <凑8倍数> = 32
他继承的B的Vtbl里的函数指向有： A::v_func2 和 B::v_func1
注意，此时C有v_func2的虚函数，即他会覆盖掉A::V_func2 ！！！ 即原来虚表里指向A::v_fun2的指向被干掉
C的内存： {这个虚指针指向一个表格Vtbl(虚表)}
[ Vptr(8字节) ]-----------> Vtbl虚表(如下)
[ A::data1 ] [ 虚函数指针1 ]------指向虚函数----->[ C::v_func2内存(覆盖) ]
[ B::data2 ] [ 虚函数指针2 ]------指向虚函数----->[ B::v_func1内存(继承) ]
[ B::data3 ]
[ C::data4 ]
[ C::data5 ]
{... 内存的某个角落里，有C::func4函数，但他是普通函数，我们暂不关注} */
/* 只要是使用虚函数，编译器就会走这条路！！ 即Vptr -> Vtbl -> 虚函数指针 -> 虚函数内存
obj.func();
在C语言中： 会变成call xxx ，xx是目标函数的地址，编译器会跳到那个位置 (这种方式是：静态绑定)
c++调用虚函数： 他不是静态绑定，而是动态绑定！ 即从Vptr指针 -> Vtbl -> 找目标虚函数指针内存
不再是以往，直接跳到目标函数的内存地址 (多态，虚函数，动态绑定；都一个机制)
假如此时有： C* p = new C(); 即一个C对象的指针p
( *(p->vptr)[n] )(p) 等价于 (* p->vptr[n] )(p)
*(p->vptr)
*/
/* 分屏逻辑，一个窗口 有多个可以操作的子窗口 */
class Window{
Vector<Sub*> views;
/* 单看这个Sub*： 这是委托，即类里存放其他类的指针
然后看这个Sub的背后深刻的意义， 到时候这里存放的，可不是Sub这个类，而是Sub这个类的子类实现类！！！
在容器里放的东西，必须是同样的大小size，因此要放指针
*/
public:
func.....
}
class Sub{
virtual void update(Window* win, int value) =0;
};
/* 1, pointer-like class -> 智能指针
智能指针是一个类 一个对象！！ 指针能做的事情，这个类也要能做 */
struct ST{
....
void func1(){ ... };
};
class shared_ptr{
private:
T* px;
long* pn;
public:
T& operator*() const{ // 这是对应原来天然指针的使用方法，即*p 来取值 得到这个对象
return *px; }
T& operator->() const{ // 这还是对应原来天然指针的用法，p->.. 取这个对象里的东西
return px; } // 这里是直接返回px，即返回一个指针， 变成了px->...
shared_ptr(T* p):px(p){} // 构造，即智能指针传入的是一个天然指针
}
shared_prt<ST> p1(new ST); // T* t = new T() 用T*来接收，因此new得到的就是一个指针！！！
// 我们要做的是：把这个new的天然的指针，包装到智能/聪明的指针里
ST t1(*p1); // 拷贝构造， *p1是取值，即取上面(new ST)的这个对象，赋值到t1里
p1->func1(); // p1是智能指针，->返回px，即px->func1() 这是可以的，因为px就是ST*的指针。
/* 这里，不是应该p1->后，变成px 即pxfunc1() 这个->不是消耗掉了吗...
箭头->符号，是特殊的，他和其他符号不同，他不会被消耗掉
*/
/* 2，pointer-like class -> 迭代器
迭代器，也可以看作是一种智能指针，只不过与上面不同的是：
他不仅要处理*和-> 他还要处理++ , -- , == , != 等 */
T& operator*() const{
return (*node).data;
}
T* operator->() const{
return &( operator*() ); // operator*() 就是调用上面的函数
} // 可以看出： operator*()不仅是重载，在类内部 可以当成是函数来使用！！！！
/* 让一个类，像是一个函数 (仿函数) */
struct ST:public unary_function<T,T> { // 虽然是一个类，但其实是函数的作用
const T& operator()(const T& t) const{
..... // 通过操作符()重载的方式， 来实现函数的作用
}
};
struct unary_function{
typedef Arg ..; // 这是不占内存的，理论上这个类的大小就是0 实际(1), 问题不大
typedef Result ..;
}
int cmp(const void* a , const void* b){
return *((int*)a) - *((int*)b);
}
int a = 3 , b = 5;
cout << cmp(&a , &b);
`地址就是一种指针，指针就是一种地址的形式` ST x = 123 ;
LL * p = & x;
LL & y = x;
ListNode* cur = head;
cur- > next = new ListNode ( 123 ) ;
cur = new ListNode ( 123 ) ;
# 从上可以知道！！！ T * cur = head; cur可以操作head内存"里面" 的东西 ， 即cur- > xxx
# 这样，cur修改了，就等于head修改了； 但直接修改cur，是对head无效的！！！
# 比如让cur指向head- > next； 即此时cur== ( 9 , head的儿子) ，但head还是 ( 1 )
# cur可以修改head"里面" 的东西 ( 通过- > ) ，但无法改变head本身所在的内存地址
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
T * t = new T [ 12 ] ;
T * t[ 12 ] ;
for ( int i= 0 ; i< 12 ; ++ i)
t[ i] = new T ( ) ;
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
T * t = new T ( 123 ) ;
cout << t;
cout << & t;
Son son;
Fa fa = (Fa)son;
fa.func(); // 静态绑定(不是指针，肯定是静态) -> 汇编： call xxx(地址)
Fa* p = new Son(); // Son 继承 Fa， 这是向上转型up-cast (Son*转为了Fa*)
p->func(); // 动态绑定(1，p是指针； 2，func是虚函数； 3，向上转型(B->A))
// 他的汇编/底层逻辑是： (*(p->vptr)[n])(p) 根据虚指针找到虚表，取下标得到虚函数地址
p = &son; // 这也是向上转型！！！(&son)是Son*的类型，转为Fa* 即此时p->func() 也是动态绑定！
typedef double D[105]; // 要对double[105]命名： 不可以double[105] D; !!!
D d; // d是个数组！！ D d; 就相当于： double[105] d;
-----------------------------------------------------------------------------------------
继承，父类的typedef也会继承下来！！！
这就是很多类只有typedef，可以让子类少写几个字符~
导入： < typeinfo> 头文件
cout << typeid ( 变量名/ 类型名，都可以) . name ( ) ;
比如已经定好了接口为： func(int a , int b); 也就是他的函数调用必须是：func(12, 45);
可以这样实现： func(int , int b){ ... } // 表示虽然传入了第一参数，但不用他！！
// 注意，函数调用时 第一个参数必须要写，只不过函数实现时 可以不接受
----------------------------------------------------------------------------------------
函数内定义一个递归函数：
auto func = [&](int a , string b){ '如果是普通函数，不用加&； 如果是递归 必须有[&]'
return (double)10/3;
};
'这个auto，就等价于： std::function<double(int, string)>
T = reinterpret_cast<T>(X*); // 将一个X类型的指针，转为T类型。 他是按位bit来强转的
T* head = reinterpret_cast<T*>(new char[512]);
struct ST{
union{
char a; // 整体是8字节，前1个字节 是a
int b; // 前4个字节为b
double c; // 前8个字节是c
}; /* 虽然是3个成员，但其实他们是同一块内存 该内存大小为：max(1, max(4, 8)) = 8
任意时刻，该union只能存储一个成员的值，其他成员就变成"未定义的状态" */
t.a = 'c'; // 此时，只有t.a是正确的，t.b和t.c都是错误的
t.b = 456; // 此时，只有t.b是正确的，t.a和t.c都是错误的
t.c = 3.33333; // 同理，此时只有t.c是正确的
/* 他只能对数组[]操作，beg得到首元素的指针，ed得到某元素的下一个位置的指针
比如有: T arr[] = {....};
如何得到arr的个数呢？ 1，sizeof(arr) / sizeof(T)
2， C++11提供的begin函数 siz = end(arr) - begin(arr) */
int A[] = {1 , 2 , 3};
for(int* it = ::std::begin(A); it != ::std::end(A); ++it)
cout << *it << endl;
扫一扫
4442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
