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.   低耦合： 每个模块 互相依赖性 不强.（就是没给模块互相独立  互不依赖）

 

设计模式: 包含 设计原则.

        举例:  单例 模式