C++ 基本语法

对比 C 语言 ，C++做的一些语法定义。

新增了 sting 类型  （注意 string 是一个类）。

构造函数：
新增 构造函数 和 析构函数  还有初始化参数列表。对象被销毁的时候 调用 析构函数。
复制构造函数 --------->  容易出现操作非法内存，容易出现 段错误。

Stu（Stu & stu）{
// this 是一个对象   stu能取出一个对象
    this.age = stu.age;
    this.age = stu.no;
}
class 类：
    可以类中定义方法。也可以类外定义 类中的函数、方法。

对象：
可以在栈中定义 对象。 Stu s； 堆中创建对象的方法时 Stu *stu = new Stu（）； 用 delete stu 来释放在队中分配的对象的内存。 如果用 mallco函数来给对象分配空间 来创建对象 是不会调用 构造函数的。
    对象赋值：
            对象1 = 对象 2；  Stu stu(1,2)  Stu stu1(1,9);   stu = stu1;(对象的赋值)
    对象复制：
            对象 1（对象2） Stu stu（1.，1）  Stu stu2 = stu  对象的复制。

c++中的成员变量在分配空间是在 对象被创建的时候，刚开始 是存在代码段的。所以 成员变量是属于对象的，成员方法时属于对象公用的方法。方法属于公共的内存空间的。

c++中类中的函数指针是 成员函数返回值类型（类名：：函数名）（参数列表） =  & 类名：：函数名；
调用的函数指针： （类名 . * 函数指针）（传递参数）；

常成员变量  初始化  1.构造函数的初始化列表   必须初始化并且只能通过 构造函数初始化参数列表来赋值。
              
常成员函数   void show（） const；  1.  常成员函数不能改变成员变量的值 2. 常成员函数 只能调用常成员函数。 3. 普通函数可以调用 常成员函数。 4. 常成员函数 不能修改对象的值（成员变量的值）

常对象    定义 ： Time const time；  1.   常对象的成员变量 在对象创建的时候 在构造函数 中必须 初始化。
                                                        2. 常对象中成员变量的值可以的在 构造函数中修改 常对象只能访问常成员函数。
                                                        3. 常成员函数 的变量值只能在 构造函数 中修改。
静态的变量：
        1. 类中定义的static定义的 成员的静态的变量 -------------> 创建对象 时 静态的变量存放在 静态区 且静态的成员的变量在内存中只有一份，多个对象共享这个数据。静态的变量在 类加载的时候 已经产生了，对象销毁时不会
释放 该静态的变量，只会在整个程序运行完成了，才会被释放。
        静态变量的访问的方式： stu.a  Stu ：： a
        静态的成员方法： 访问 与静态的变量访问是一样的。
    静态的成员变量的 不能出现this ，因为  静态的不属于对象 本身（对象本身在创建时初始化时，不包含 静态的初始化） 注意：静态的存放的位置 在静态区。
        静态的函数中 不能会出现 this 关键字的 引用，因为静态 不是通过 对象来访问的。
多个对象共用静态的资源。
 

访问权限修饰符：
        权限修饰符：private public protected。
        只会改变作用域，不会改变内存的分配。限制 其 访问的 权限。
public 成员函数在任何位子 能够被访问。
private 只能在当前类中访问。

protected 只能在当前类中访问，和其子类中访问中（派生类中访问）。（main  函数 不属于任何类 的空间）
函数是代码段只读区，在函数调用的时候生效，其他普通的变量 在堆栈区。
  
友元函数：
    友元打破访问函数访问权限的限制，让权限不生效。
    关键字： friend 修饰。
    friend 修饰  一个 class时 表示该类中的所有的方法 都是友元函数。

继承与派生： 
    继承是为解决代码的重用的问题。
    继承： 公共的属性部分提取出来，通过继承的方式去添加自己私有的属性，私有的方法。 
    多继承: 就是解决了 同类中属性的继承关系。

不写权限的继承，默认为 private的继承方式。

多继承 ：
    用逗号 隔开,访问属性成员的时候。

1.相同基类继承时 的 二义性： 
        Class A extends B,C 
                A.B : : a
                A.C : : a 

2.不同基类中 多继承的二义性：
虚 基 继承   virtual 关键字， 虚基派生，虚基继承。
class B1 ： virtual A
class B2  ： virtual A
class C   ： B1，B2
相同的基类中多继承时，会自动加上标记标记相同只会存在一份值。

3.派生类对象 可以向 基类的对象 赋值。（子类可以向 父类对象 赋值）
        父类对象 可以 引用子类的对象。
父类引用子类的对象时，只能访问 父类中定义的属性，不能访问子类中特有的属性。

私有的属性（private） 必须通过 公有的方法进行访问。

公有继承： class B ： public A
私有继承： class B ： private A
保护继承： class B ： protected A





     派生类中对象创建的时候先会创建 基类的 对象。
        销毁时，先销毁 派生类的对象，在销毁基类的对象。

组合：  注意 ：  C 类并没有去继承 A  B 类。
    class C {
    public：
        A a； // 这里的顺序决定了是否 先创建了  A类的对象 ，还是B类中对象。
        B b ；
}
c 类中 包含了 A 类的对象， B类的对象。------------组合 概念。
创建 C类的对象的时候，会创建 A类 的对象，在创建 B类的对象。
 C类对象创建的时候，的初始化列表 对 A，B对象进行 初始化。
    C：：C( )： A（）,B( ) {//    初始化 列表 调用了 A类中无参的构造函数,B类 中 无参构造函数。

}
组合： C 类有自己的功能，A类有自己的功能，B类也有自己功能。
            类似java 中接口： 对某些功能 进行 补充，可有可无。
            特点：
设计原则:
1.    可扩展 可维护
2.   符合面向对象的思想
3.   低耦合： 每个模块 互相依赖性 不强.（就是没给模块互相独立  互不依赖）

设计模式: 包含 设计原则.
        举例:  单例 模式