C++学习笔记（草稿版）

1:C++新增数据类型

         Bool类型  真true 假false

2:C++新增一种初始化方法

         传统(复制初始化)：int x =1024;

         新增(直接初始化)：int x (1024);

3:随用随定义

4:输入输出

cout 语法形式（输出）  <<输出流  endl相当于回车；

         cout<< X << endl;            

         cout<< “X +Y =” << x + y;

         cout<< x, y, z << endl  (错误)         cout << x << “,” << y << “,” << z << endl;

cin 语法形式 (输入)       >>输入流

         cin>> x;

         cin>> X >> y;

         不关注占位符， 不关注数据类型 ，不易出现问题

 

5:C++命名空间（namespace）

         namespace 空间名

         using namespace 空间名

         空间名::变量/函数

         using namespace B;

int main()

{

         std::cout << A::x <<std::endl;

         A::fun();

         std::cout << x <<std::endl;

         fun();

         fun2();

         system("pause");

         return 0;

}

6:别名与引用（&引用符号）

         基本数据类型的引用

                   inta =3;

                   int&b = a;        //定义别名

         结构体数据类型引用

                  Typedef struct{

                  int x;

                  int y;

}Coor;

 

int main(){

         Coor c1;

         Coor &c = c1; //定义别名

}

         指针类型的引用

                   类型 *&指针引用别名 = 指针；

                   int a = 10;

int *p = &a;

int *&q = p;      //定义指针别名

*q = 20;

         引用作为函数参数

                  Void fun(int &a, int &b)             //通过别名来实现数值交换

{

                  int c = 0;

                  c= a; a = b; b = c;

}

int main(vodi)

{

int x = 10, y = 20;

fun(x,y);

}

7:C++语言-const（变量变为常量）

const 基本数据类型（略）

                 const int a =10;        a此时为常量；

          const与指针类型

                 const int *p = NULL 与 int const *p = NULL完全等价；

                   上面限定的是*p为常量

                   int*const p = NULL; const限定的是 p;

                   consint *const p = NULL 等价于 int const *const p = NULL;

         const与引用

                   intx = 3; const int &y = x;         //限定的是别名y

                   //x= 10; 正确 // y =10; 错误

 

8:C++函数的新特性

         A：函数参默认值

                  

                 

声名时加默认值，定义时不用加（加的话，某些编译器可能会出错）

         B：函数的重载

                   在相同作用域内

                            用同一个函数名定义多个函数

                            参数个数和参数类型不同

                   getMax(int x, int y, int z)          getMax_int_int_int

                   getMax(double x, double y)     get_double_double

         C：内联函数（inline）

inline int Max(int a, int b, int c);

int main(void){

         *****

         m= max(i, j, k)

         *****

}

 内联函数省去调用过程2，4，适合多次重复调用的结构

         内联编译是建议性的，由编译器决定。

         逻辑简单，调用频繁的函数建议使用内联

         递归函数无法使用内联方式

9:C++内存管理（new/delete）

         申请内存 int *p = new int;

         释放内存 delete p;

         块内存的申请与释放：

                   Int *arr = new int[10];     //申请块内存

                   delete []arr;                        //释放内存块

        

         注意事项：

                   int *p = new int[1000];

                   if(NULL == p)    //是否申请成功

                   {

                            //内存申请失败

  }

delete p;  //delete []p;     //注意区分是否为块内存

p = NULL;                             //释放完要设空（悬空）

10:类（class）&对象（具体的事物）

类的定义：

上述即为一个类的封装（暴露/隐藏）

访问限定符

         public:               公有的

          protected:       受保护的

         private:            私有的

11:对象的实例化

                   从栈实例化对象（直接用类名定义内存空间）

                           

                            使用完后系统自动回收内存空间

                   从堆实例化对象（申请内存空间）

                           

                            使用完需手动释放内存空间

                   对象成员的访问方法

                            栈成员的访问：

                                    

                            堆成员的访问：

                                      

12:初始化string（字符串）

         String 类型：

                   实例：

                  #include<iostream>

                   #include<string>     //字符串头文件

                   using namespace std;

                   int main(void)

{

         string name = “ZhangSan”;

         string hobby (“football”);

         cout<< name << hobby << endl;

         return0;

}

13:数据的封装

                   面向对象的指导思想（以对象为中心）

                            谁做什么？来表达程序逻辑。

  代码体现：将所有对数据的操作，转化为对成员函数的调用。及对象对数据的操作都通过调用自己的函数来完成。

实例-1：

         classStudent            //封装的好出-限定数据的输入

{

         public:

                   voidsetAge(int _age)

                   {

                            If(_age> 0 && _age < 100)

                            {

                                     age= _age;

    }else{

              ……

}

 }

int getAge() { return age };

                 private:

                             stringname;

                             int age;

                              …….

                 }

            实例-2：

                class Car           //封装的好处-数据属性-只读属性

{

         public:

                   int getWheelCount(){return m_iWheelCount;}

         private:

                   int m_iWheelCount;         //只读属性

}

14:类内定义与内联函数/ 类外定义

                  

         类外定义（同文件/分文件）：

                   同文件类外定义：

                           

                   分文件类外定义：（类声名写在头文件内，类的定义写在*.cpp内）

                           

                                     文件结构：

                                               头文件夹/Car.h       (里面只写类的声名)

                                               源文件夹/Car.cpp   (里面具体定义类内的函数)

                                               源文件夹/项目主文件.cpp

                   注意事项：

为区别与标准头文件，自定义头文件引用时用””(“Car.h”)

                            类外定义的函数可以重载

类内定义的函数优先选择编译为内联函数

可以将类的声明与类的定义分成两个文件编写。

15:对象结构

           内存分区：

                 栈  区：int x = 0; int *p= NULL;

                     堆  区：int *p = new int[20]

全局区：存储全局变量及静态变量

常量区：string str =“hello”;  (字符串 / 常量)

                     代码区：存储逻辑代码的二进制（二进制代码）

              对象初始化(有且仅有一次)：

如何避免误操作：（构造函数）

  构造函数的规则和特点：

  1：构造函数在实例化时被自动调用(被调用且仅被调用一次)

2：构造函数与类同名

3：构造函数没有返回值

4：构造函数可有多个重载形式

5：实例化对象时仅用到一个构造函数

6：当用户没有定义构造函数时，编译器自动生成一个构造函数

无参构造函数(实例化时自动调用，无需参数传递)

    class Student

    {

    publice:

           Student(){m_strName = “Jim”;}      //构造函数名为类名

    private:

           string m_strName;

};

       实例化操作：Student st;

                         有参构造函数：(在实例化时需要传入参数)

                          classStudent

                           {

                            public:

                                   Student(string _name)      //构造函数名为类名

                                    {m_strName= _name;}

                            private:

                                    stringm_strName;

                             };

                                  实例化时传入参数：Student st(“Merry”);

                            重载构造函数

                                  

16:构造函数初始化列表（对成员变量初始化）

           默认构造函数：

     

      初始化列表格式：

            构造函数后加“:”，然后对各个成员变量赋值，赋值时只能用“()”

初始化列表特性：

              1：初始化列表先于构造函数执行

              2：初始化列表只能用于构造函数

              3：初始化列表可以同时初始化多个数据成员（效率高、速度快）

      初始化列表的必要性：

         

         

  

17：拷贝构造函数：

拷贝构造函数的引用：

       第一种情况（下图）：

              Student stu1;

              Student stu2 = stu1;

              Student stu3(stu1);

    第二种情况：

        实例化的一个类作为一个函数的参数。

    Void Test(Teacher t){}

    Int main(void){Teacher t1; Test(t1)}

拷贝构造函数的特点：

1：如果没自定义的拷贝构造函数则系统自动生成一个默认的拷贝构造函数

2：当采用直接初始化或复制初始化实例化对象时系统会自动调用拷贝构造函数

3:拷贝构造函数的参数是固定的，故不可以重载。

构造函数总结

18：析构函数：（对象销毁之前，被自动调用，释放系统资源）

          定义格式：~类名(){};

           class Student

  {

          public:

              Student(){m_pName = new char[20]}

              ~Student(){delete []m_pName}      //析构函数

          private:

              char *m_pName;

 };

            特点：

                 1：如果没有自定义的析构函数，则系统自动生成

                 2：析构函数在对象销毁时自动调用

            3：析构函数没有返回值，没有参数也不重载

      对象的生命历程：

  

前三段知识梳理（类、对象）

      类（class）：

        数据成员：

        成员函数：