2.1 C++ note

C++

一、C++语言语法基础

(一)、从C到C++的过渡

1. 背景介绍

   ​ 算盘 - 面向硬件的编程

   ​ 电子计算机

   ​ - 机器语言的编程1010

   ​ - 汇编语言的编程ADD

   ​ - 高级语言的编程Fortran

   ​ printf (“%d”, 12);

   ​ - 结构化程序设计C/PASCL

   ​ - 顺序、分支、循环、函数

​ - 面向对象的程序设计C++/Java/C#

​ - 面向问题的程序设计

​ 1960 - Algol 60，算法语言,远离硬件，不适合进行系统开发

​ 1963 - 剑桥大学，CPL，在Algol 60的基础上增加对系统开发的支持，复杂，不易掌握，不易使用

​ 1970 - MIT，BCPL，CPL的精华版，易学易用，太慢，不实用

​ 1972 - Ken Thomposon，B语言，通过运行时支持优化BCPL的性能，缺少类型

​ 1973 - Dennis Ritchie，C语言，用C重新实现UNIX内核

​ 1978 - 《The C Programming Language》，第一个C语言的事实标准

​ 1989 - ANSI C，C89

​ 1990 - ISO C, C90

​ 1999 - ISO C 修订，C99

​ 197X - Bajarne Stroustrup，simula早期的面向对象语言，性能低下，B语言。

​ 1979 - 贝尔实验室，多核UNIX系统仿真，Cpre，通过扩展宏为C语言增加类似simula的面向对象机制。

​ C with Class:

​ simula - 类

​ Alogo 68 - 操作符重载

​ Ada - 模板、名字空间

​ Smalltalk - 引用、异常

​ C是C++的子集，C++是对C的扩展。

​ 1983 - C++命名

​ 1985 - CFront 1.0，第一款商用C++编译器

​ 1987 - GNU C++

​ 1990 - Borland C++

​ 1992 - Microsoft C++，IBM C++

​ 1998 - ISO C++98

​ 2003 - ISO C++03

​ 2011 - ISO C++2011/C++11/C++0x

1. C++语言的使用领域：

   1.游戏开发：强建模能力，性能高。

   2.科学计算：FORTRAN，C++算法库。

   3.网络和分布式：ACE框架。

   4.桌面应用：VC/MFC，Office，QQ，多媒体

   5.操作系统和设备驱动：优化编译器的发明使C++在底层开发方面可以和C向媲美。

   6.移动终端:既需要性能，同时又要有面向对象的建模。

2. C++比C更丰富

   (1).支持面向对象，将问题域和方法域统一化。宏观面向对象，微观面向过程。

   (2).支持泛型编程。

   int add (int a, int b) { ... }
   template\<typename T>
   T add (T a, T b) { ... }

   (3).支持异常机制。

   int func (void) {
       ...
   }
   int main (void) {
       if (func () == -1) {
           //错误处理;
       }
   }

   (4).操作符重载

3. 第一个C++程序

   (1). 编译器：g++，如果使用gcc需要带上-lstdc++,指定其使用标准c++的运行库。

   (2). 源文件扩展名：.cpp/.cc/.C/.cxx/.c++,最好用.cpp。如果要用，可以在c头文件名前加c：#include \

   (3). 不再使用scanf/printf而是cin/cout。

   (4). 头文件：#include\大多数标准库头文件没有.h后缀。

   (5). 输出：cout – 标准输出对象

   ​ 输入运算符：<<

   ​ 提取输出运算符：>>

   #include <iostream>
   int main (void) {
       std::cout << "Hello, World !" << std::endl;
       int i;
       double d;
       char s[256];
   //    scanf ("%d%lf%s", &i, &d, s);
       std::cin >> i >> d >> s;
   //    printf ("%d %lf %s\n", i, d, s);
       std::cout << i << ' ' << d << ' ' << s << '\n';
       return 0;
   }

   (6). std：所有标准库的函数、对象、类型都位于std名字空间中。

   #include <iostream>
   using namespace std;
   struct Student {
       char name[128];
       int age;
       void who (void) {
           cout << "我叫" << name << "，今年" << age
               << "岁了。" << endl;
       }
   };
   int main (void) {
       Student student = {"张飞", 25}, *ps = &student;
       student.who ();
       ps->who ();
       struct A {};
       cout << sizeof (A) << endl;
       return 0;
   }

   (7). 名字空间：对程序中的标示符（类型、函数、变量）按照某种逻辑规则划分成若干组。

   ​ A. 定义名字空间：namespace 名字空间名 {名字空间成员；}

   ​ B. 使用名字空间：

   ​ a. 作用于限定符：名字空间名：：名字空间成员，表示访问特定名字空间中特定成员。

   ​ b. 名字空间指令：using namespace 名字。空间名；在该条指令之后的代码对指令所有名字空间中的所有成员都可见，无需加“::”（作用域限定） ::为域运算符，在此表明一种限定，一个范围。

   ​ C. 名字空间声明：using 名字空间名::名字空间成员；将指定名字空间中的某个成员引入当前作用域，可直接访问这些成员，无需加“::”。4)匿名名字空间：如果一个标示符没有被显示地定义在任何名字空间中，编译器会将其缺省的置于匿名名字空间中。对匿名名字空间中的成员通过“::名字空间成员”的形式访问。

   ​ D. 名字空间合并

   ​ E. 名字空间嵌套

   #include <iostream>
   using namespace std;
   //namespace {
       void print (int money) {
           cout << money << endl;
       }
   //}
   // 农行名字空间
   namespace abc {
       int balance = 0;
       void save (int money) {
           balance += money;
       }
       void draw (int money) {
           balance -= money;
       }
   }
   namespace abc {
       void salary (int money) {
           balance += money;
       }
       void print (int money) {
           cout << "农行：";
           ::print (money);
       }
   }
   // 建行名字空间
   namespace ccb {
       int balance = 0;
       void save (int money) {
           balance += money;
       }
       void draw (int money) {
           balance -= money;
       }
       void salary (int money) {
           balance += money;
       }
   }
   int main (void) {
       using namespace abc; // 名字空间指令
       save (5000);
       cout << "农行：" << balance << endl;
       draw (3000);
       cout << "农行：" << balance    << endl;
       ccb::save (8000);
       cout << "建行：" << ccb::balance << endl;
       ccb::draw (5000);
       cout << "建行：" << ccb::balance << endl;
       using ccb::salary; // 名字空间声明
   //    using abc::salary;
       salary (6000);
       cout << "建行：" << ccb::balance << endl;
       abc::print (abc::balance);
       return 0;
   }

   (8).C++中的结构、联合、枚举

   ​ A. 结构

   ​ 定义结构型变量时，可以省略struct关键字。

   ​ 1)结构内部可以定义函数——成员函数。

   ​ 2)sizeof(空结构) -> 1

   #include <stdio.h>
   int main (void) {
       struct A {};
       printf ("%d\n", sizeof (struct A));
       struct A a;
       struct A* pa = &a;
       printf ("%p\n", pa);
       return 0;
   }

   ​ B. 联合

   ​ 增加了匿名联合概念。借用联合语法形式，描述一些变量在内存中的布局方式。

   #include <iostream>
   using namespace std;
   int main (void) {
       // 匿名联合
       union {
           int x;
           char c[4] /*= {'A', 'B', 'C', 'D'}*/;
       };
       cout << (void*)&x << ' ' << (void*)c << endl;
       x = 0x12345678;
       for (int i = 0; i < 4; ++i)
           cout << hex << (int)c[i] << ' ';
       cout << endl;
       return 0;
   }

   ​ C. 枚举

   ​ 枚举是一个独立的数据类型

   #include <iostream>
   using namespace std;
   int main (void) {
       enum E {a, b, c};
       E e;
       e = a;
       e = b;
       e = c;
   //    e = 1000;
   //    e = 1;
       return 0;
   }

   (9).C++的布尔类型【7.31/bool.cpp】

   ​ bool b = true; b = false;

   ​ cout<< sizeof (b)<< endl; // 1

   ​ b = 100;

   ​ b = 1.234;

   ​ b = “hello”;

   ​ b = ‘a’;

   ​ 可以将任何值赋值给bool类型的变量，以下四个值为false：0 ‘\0’ NULL false 其他一切值如果赋值给bool类型的变量都视为true。

   #include <iostream>
   using namespace std;
   void print (bool sex) {
       if (sex) 
           cout << "男生" << endl;
       else
           cout << "女生" << endl;
   }
   int main (void) {
       bool b = true;
       cout << sizeof (b) << endl;
       cout << b << endl;
       b = false;
       cout << b << endl;
       b = 3.14;
       cout << b << endl;
       char* p = NULL;
       b = p;
       cout << b << endl;
       cout << boolalpha << b << endl;
       bool sex;
       sex = 3;
       print (sex);
       return 0;
   }

   (10). C++中的运算符别名

   ​ && - and; 如：x>0&&y>0可以改写成x>0 and y>0。

   ​ || - or;

   ​ & - bitand;

   ​ ^ - xor;

   ​ { - <%

   ​ } - %>

   ​ [ - <:

   ​ ] - :>

   (11). C++中的函数

   ​ A. 重载：在同一个作用域中，函数名可以相同，参数表不同的函数，构成重载关系（总之能区分函数就可以了，函数名+数据类型（跟类型顺序也有关哦））。C++编译器会对程序中的函数做换名，将参数表中的类型信息汇合到函数名中，以保证函数名的唯一性。通过extern “c” ,可以要求编译器不做C++换名，以方便在C语言的模块中使用C++编译生成代码。

   #include <iostream>
   using namespace std;
   void foo (int a) {
       cout << "foo(int)" << endl;
   }
   void bar (int a) {}
   //int foo (int a) {}
   int foo (int a, double b) {
       cout << "foo(int,double)" << endl;
   }
   int foo (double a, int b) {
       cout << "foo(double,int)" << endl;
   }
   //int foo (int b, double a) {}
   int main (void) {
       foo (100);
       foo (100, 1.23);
       foo (1.23, 100);
   //    foo (100, 100);
       return 0;
   }

   ​ B. 缺省参数和哑元参数

   ​ a. 如果调用一个函数时，没有提供实参，那么对应形参就取缺省值。

   ​

   #include <iostream>
   using namespace std;
   namespace ns1 {
       int foo (int a) {
           cout << "ns1::foo(int)" << endl;
           return a;
       }
   };
   namespace ns2 {
       double foo (double a) {
           cout << "ns2::foo(double)" << endl;
           return a;
       }
   };
   int main (void) {
       using namespace ns1;
       using namespace ns2;
       cout << foo (10) << endl;
       cout << foo (1.23) << endl;
       using ns1::foo;
       cout << foo (10) << endl;
       cout << foo (1.23) << endl;
       using ns2::foo;
       cout << foo (10) << endl;
       cout << foo (1.23) << endl;
       return 0;
   }

   ​ b. 如果一个参数带缺省值，那么他后边的所有参数必须都带有缺省值。

   ​ c. 如果一个函数声明和定义分开，那么缺省参数只能放在声明中。

   ​ d. 避免和重载发生歧义。

   ​ e. 只有类型没有名字的形参，谓之哑元。

   #include <iostream>
   using namespace std;
   void foo (int a = 10, double b = 0.01, 
       const char* c = "tarena");
   void foo (void) {}
   void bar (int) {
       cout << "bar(int)" << endl;
   }
   void bar (int, double) {
       cout << "bar(int,double)" << endl;
   }
   int main (void) {
       foo (1, 3.14, "hello");
       foo (1, 3.14);
       foo (1);
   //    foo (); // 歧义
       bar (100);
       bar (100, 12.34);
       return 0;
   }
   void foo (int a /* = 10 */, double b /* = 0.01 */,
       const char* c /* = "tarena" */) {
       cout << a << ' ' << b << ' ' << c << endl;
   }

   ​ C. 内联

   ​ a. 编译器用函数的二进制代码替换函数调用语句，减少函数调用的时间开销。这种优化策略成为内联。

   ​ b. 频繁调用的函数适合内联，而稀少调用的复杂函数不适合内联。

   ​ c. 递归函数无法内联。

   ​ d. 通过inline关键字，可以建议编译对指定函数进行内联，但是仅仅是建议而已。inline void foo (int x,int y) {…….}

   (12). C++的动态内存分配

   ​ malloc/calloc/realloc/free

   ​ A. new/delete:对单个变量进行内存分配、释放。

   ​ B. new[]/delete[]:对数组进行内存分配/释放。

   #include <iostream>
   using namespace std;
   int main (void) {
   //    int* pi = (int*)malloc (sizeof (int));
   //    free (pi);
       int* pi = new int;
       *pi = 1000;
       cout << *pi << endl;
       delete pi;
       pi = NULL;
       /*
       *pi = 2000;
       cout << *pi << endl;
       */
       pi = new int[10];
       for (size_t i = 0; i < 10; ++i)
           pi[i] = i;
       for (size_t i = 0; i < 10; ++i)
           cout << pi[i] << ' ';
       cout << endl;
       delete[] pi;
       pi = NULL;
       pi = new int (1234);
       cout << *pi << endl;
       delete pi;
       pi = NULL;
       char buf[4] = {0x12,0x34,0x56,0x78};
       pi = new (buf) int;
       cout << hex << *pi << endl;
   //    delete pi;
       cout << (void*)pi << ' ' << (void*)buf << endl;
       int (*p)[4] = new int[3][4];
       delete[] p;
       int (*q)[4][5] = new int[3][4][5];
       delete[] q;
       return 0;
   }

   (13). 引用

   ​ A. 引用即别名。int a; int& b = a;给a起别名。b=10；cout<<a<<endl;//10

   ​ B. 引用必须初始化。int a; int* p;

   ​ a = 20; p = &a; int& b;//ERROR ! int& b = a; //OK

   ​ D. 引用一旦初始化就不能再引用其它变量。

   ​ int a = 20,c =30;

   ​ int& b = a;

   ​ b = c;//c => b/a

   ​ E. 引用的应用场景

   ​ a.引用型参数

   ​ b. 修改实参

   ​ c. 避免拷贝，通过加const可以防止在函数中意外地修改实参的值，同时还可以接受拥有常属性的实参。

   #include <iostream>
   using namespace std;
   void swap1 (int a, int b) {
       int c = a;
       a = b;
       b = c;
   }
   void swap2 (int* a, int* b) {
       int c = *a;
       *a = *b;
       *b = c;
   }
   void swap3 (int& a, int& b) {
       int c = a;
       a = b;
       b = c;
   }
   void swap4 (const char* x, const char* y) {
       const char* z = x;
       x = y;
       y = z;
   }
   void swap5 (const char** x, const char** y) {
       const char* z = *x;
       *x = *y;
       *y = z;
   }
   void swap6 (const char*& x, const char*& y) {
       const char* z = x;
       x = y;
       y = z;
   }
   struct Student {
       char name[1024];
       int age;
   };
   void print (const struct Student& s) {
       cout << s.name << "，" << s.age << endl;
   //    s.age = -1;
   }
   void foo (const int& x) {
       cout << x << endl;
   }
   int main (void) {
       int a = 100, b = 200;
   //    swap1 (a, b);
   //    swap2 (&a, &b);
       swap3 (a, b);
       cout << a << ' ' << b << endl; // 200 100
       const char* x = "hello", *y = "world";
   //    swap4 (x, y);
   //    swap5 (&x, &y);
       swap6 (x, y);
       cout << x << ' ' << y << endl;
       Student s = {"张飞", 22};
       print (s);
       print (s);
       foo (100);
       return 0;
   }

   ​ d. 引用型返回值从一个函数中返回引用往往是为了将该函数的返回值作为左值使用。但是，一定要保留函数所返回的引用的目标在该函数返回以后依然有定义，否则将导致不确定的后果。不要返回局部变量的引用，可以返回全局、静态、成员变量的引用，也可以返回引用型形参变量本身。

   #include <iostream>
   using namespace std;
   int g_data = 100;
   int& foo (void) {
       return g_data;
   }
   int& bar (void) {
       int a = 100;
       return a;
   }
   int& fun (void) {
       int b = 200;
       return b;
   }
   int& hum (int& a) {
       return a;
   }
   int main (void) {
       int data = foo ();
       cout << data << endl; // 100
       foo () = 200;
       cout << g_data << endl;
       foo () += 100;
       ++foo ();
       cout << g_data << endl; // 301
       int& a = bar ();//引用不能再次赋值
   //    cout << fun () << endl;
       cout << a << endl; // 200,把后面的数放到了a的位置
       return 0;
   }

   ​ F. 引用和指针

   ​ a. 引用的本质就是指针，很多场合下引用和指针可以互换。

   ​ b. 在C++层面上引用和指针存在以下不同：

   ​ (a). 指针是实体变量，但是引用不是实体变量。

   ​ int& a=b;

   ​ sizeof (a);//4

   ​ double& d=f;

   ​ sizeof (d);//8

   ​ (b). 指针可以不初始化，但是引用必须初始化。

   ​ (c). 指针的目标可以修改，但是引用的目标的不能修改。

   ​ (d). 可以定义指针的指针，但是不能定义引用的指针。

   ​ int a;

   ​ int* p = &a;

   ​ int** pp = &p;//ok

   ​ int& r = a;

   ​ int&* pr = &r;//ERROR

   ​ (e). 可以定义指针的引用，但是不能定义引用的引用。

   ​ int a;

   ​ int* p = &a;

   ​ int*& q = p;//ok

   ​ int& r = a;

   ​ int&& s = r;//ERROR

   ​ (f). 可以定义指针的数组，但不能定义引用的数组。

   ​ int a, b, c;

   ​ int* parr[] = {&a,&b,&c};/ok

   ​ int& rarr[] = {a,b,c};//ERROR

   ​ 可以定义数组的引用。

   ​ int arr[] = {1 ,2,3};

   ​ int (&arr_ref)[3] = arr;//ok

   //指针相关 
   1.  int i = 5;
       int* p = &i;
       将p（而不是*P）的值设置为&i；初始化与赋值是完全不同的概念。
   2.  int *p;
       *p = 112233; //错
       对指针解引用之前，必须将指针初始化为一个确定的、适当的值。
   3.  int* p;
       p = (int*)0x8000000;
       将数字做地址使用时，必须强制将数字转换为适当的地址类型。
   4.  int* p = new int; // 未命名内存
       delete p;//销毁，释放空指针也是安全的。  
       new运算符根据类型来分配多大内存并将地址返回。
       int i;
       int* p = i; // 有名内存
   5.  int* p = new int[10]; // 创建动态数组
       delete[] p; //释放动态数组
       指针可以做动态创建的数组名使用：p[0]、p[1] ...
   6.    int p[10]; // 静态创建数组
       p 为首元素地址
       &p 为数组地址 
       p + 1 加一个变量的大小
       &p + 1 加一个数组大小 
       数组大小：sizeof(p) / sizeof( p[0] );

   (14). 显示类型转换运算符

   ​ 目标类型变量 = （目标类型）源类型变量；

   ​ A. 静态类型转换

   ​ static_cast<目标类型>（源类型变量）如果在目标类型和源类型之间某一方向上可以做隐式类型转换，那么在两个方向上都可以做静态类型转换。反之如果在两个方向都不能做类型转换，那么在任意一个方向上也不能做静态类型转换。

   ​ int* p1 = ……;

   ​ void* p1 = p2;

   ​ p1 = static_cast(p2);

   ​ char c;

   ​ int I = c;

   ​ 如果存在从源类型到目标类型的定义转换规则，那么也可以使用静态类型转换。

   #include <iostream>
   using namespace std;
   int main (void) {
       int* p1 = NULL;
       void* p2 = p1;
       p1 = static_cast<int*> (p2);
       return 0;
   }

   ​ B. 动态类型转换

   ​ dynamic_cast<目标类型>（源类型变量）用在具有多态性的父子类指针或引用之间。

   ​ C. 常类型转换

   ​ const_cast<目标类型>（源类型变量）给一个拥有const属性的指针或引用去常。

   ​ int a = 100;

   ​ const int* p1 = &a;

   ​ *p1 = 200;//ERROR

   ​ int p2 = const_cast<int>(p1);

   ​ *p2 = 200;//ok

   #include <iostream>
   using namespace std;
   int main (void) {
       const volatile int a = 100;  //加volatile表示不做常量优化
   //    a = 200;
       const volatile int* p1 = &a;
   //    *p1 = 200;
       int* p2 = const_cast<int*> (p1);//相当于解锁操作;
       *p2 = 200;
       cout << *p2 << endl; // 200
       cout << a << endl; // 200
       // cout << 100 << endl;
       return 0;
   }

   ​ D. 重解释类型转换

   ​ reinterpret_cast<目标类型>（源类型变量）；在不同类型的指针或引用之间做类型转换，以及在指针和整型之间做类型转换(实质是不做常量优化，不成为字面值)。

   #include <iostream>
   using namespace std;
   int main (void) {
       int i = 0x12345678;
       char* p = reinterpret_cast<char*> (&i);
       for (size_t i = 0; i < 4; ++i)
           cout << hex << (int)p[i] << ' ';
       cout << endl;
       float* q = reinterpret_cast<float*> (&i);
       cout << *q << endl;
       void* v = reinterpret_cast<void*> (i);
       cout << v << endl;
       return 0;
   }

   在C中：目标类型变量 = 目标类型（源类型变量）；int a = int (3.14);

4. C++之父的建议

   (1). 少用宏，多用const，enum和inline。

   ​ #define PAI 3.14159

   ​ const double PAI = 3.14159;

   ​ #define ERORR_FILE -1;

   ​ #defile ERORR_MEM -2;

   ​ enum {

   ​ ERORR_FILE = -1,

   ​ ERORR_MEM = -2

   ​ };

   ​ #define max(a,b) ((a) > (b) ? (a) : (b))

   ​ inline int double max (double a,double b){return a > b ? a : b;}

   (2). 变量随用随时声明同时初始化。

   (3). 少用malloc/free,多用new/delete。

   (4). 少用C风格的强制类型转换，多用类型转换运算符。

   (5). 少用C风格的字符串，多用string。

   #include <iostream>
   #include <cstring>
   #include <cstdio>
   using namespace std;
   int main (void) {
       string s1 ("hello");//字符串的类。
       string s2 = "world";
       (s1 += " ") += s2;//合并s1和s2。
       cout << s1 << endl;
       string s3 = s1;
       cout << s3 << endl;
       cout << (s1 == s3) << endl;
       s3[0] = 'H';//将第一个字符替换掉了；
       cout << s3 << endl;
       cout << (s1 > s3) << endl;
       cout << s1.length () << endl;//计算字符串s1的长度；
       cout << (s1 == s3) << endl;
       cout << (strcasecmp (s1.c_str (),s3.c_str ()) == 0) << endl;//比较字符串大小，strcasecmp不区分大小写
   //    cout << (strcasecmp (s1.c_str (),s3.c_str ())) << endl;//比较字符串大小
       cout << sizeof (s1) << endl;//不能用sizeof计算字符串s1的大小；
       FILE* fp = fopen ("string.txt", "w");//记录的是指针地址而已；
   //    fwrite (&s3, sizeof (s3), 1, fp);
       fwrite (s3.c_str (), sizeof (char),s3.length (), fp);
       fclose (fp);
       return 0;
   }

   (6). 树立面向对象的编程思想。

(二)、类和对象

1. 什么是对象

   1. 万物皆对象

   2. 程序就是一组对象，对象之间通过消息交换信息

   3. 类就是对对象的描述和抽象，对象就是类的具体化和实例化。

2. 通过类描述对象

   属性：姓名、年龄、学号

   行为：吃饭、睡觉、学习

   类就是从属性和行为两个方面对对象进行抽象。

3. 面向对象程序设计（OOP）

   现实世界 虚拟世界

   对象 -> 抽象 -> 类 -> 对象

   1. 至少掌握一种OOP编程语言
   2. 精通一种面向对象的元语言—UML
   3. 研究设计模式，GOF

4. 类的基本语法

   1. 类的定义

      class 类名 {
      }；
      如
      class Student {
      }；

   2. 成员变量-属性

      class 类名 {
      }；
      如：
      class Student {
          string  m_name;
          int   m_age;
      }；

   3. 成员函数-行为

      class 类名 {
          返回类型 成员函数 （形参表）{
              函数体
          }
      }；
      如：
      class Student {
          string  m_name;
          int   m_age;
          void eat (const string& food){
          ……}
      };

   4. 访问控制属性

      （1） 共有成员：public,谁都可以访问

      （2） 私有成员：private,只有自己可以访问。

      （3） 保护成员：protected,只有自己和自己的子类可以访问。

      （4） 类的成员缺省访控属性为私有，而结构成员缺省访问属性为公有。

      int x = 10; //等号为初始化；

      另种初始化int x(10);

      int x;

      x = 10; //此时的等号为赋值符号；

      #include <iostream>
      using namespace std;
      class Student {
      private://将变量私有化；
          string m_name;
          int m_age;
      public:
          void eat (const string& food) {
              cout << m_age << "岁的" << m_name
                  << "同学正在吃" << food << "。" << endl;
          }
          void setName (const string& name) {
              if (name == "2")
                  cout << "你才" << name << "！" << endl;
              else
                  m_name = name;//不能直接访问私有，可以通过函数访问；
          }
          void setAge (int age) {
              if (age < 0)
                  cout << "无效的年龄！" << endl;
              else
                  m_age = age;
          }
      };
      int main (void) {
          Student student;//student为对象,此操作为定义一个对象；
          student.setName ("2");//通过点来读取对应的成员变量或函数；
          student.setAge (-100);
          student.setName ("张飞");
          student.setAge (20);
          student.eat ("包子");
          return 0;
      }

   5. 构造函数

      class 类名 {
          …
          类名 （形参表）{
              构造函数体；
          }
      }；
      当一个对象被创建时，构造函数会自动被执行，其参数来自构造实参。

   6. 构造函数可以通过构造参数实现重载。

   7. 如果一个类没有定义任何构造函数，那么系统就会缺省的为其提供一个无参构造函数，该构造函数对于基本类型的成员变量不做初始化，对于类类型的成员变量，调用其相应类型的无参构造函数初始化。

      #include <iostream>
      using namespace std;
      class A {
      public:
          A (int a) {}
      };
      class Student {
      private:
          string m_name;
          int m_age;
          A m_a;
      public:
          void eat (const string& food) {
              cout << m_age << "岁的" << m_name<< "同学正在吃" << food << "。" << endl;
          }
      //    void _ZN7Student3eatERKSs (Student* this,
      //        const string& food) {
      //        cout << this->m_age << "岁的"<<this->m_name
      //            << "同学正在吃" << food << "。" << endl;
      //    }
          void setName (const string& name) {
              if (name == "2")
                  cout << "你才" << name << "！" << endl;
              else
                  m_name = name;
          }
          void setAge (int age) {
              if (age < 0)
                  cout << "无效的年龄！" << endl;
              else
                  m_age = age;
          }
          // 构造函数
          Student (const string& name, int age) :   //函数名，参数表
              m_a (100) {
              m_name = name;
              m_age = age;
          }
          // 无参构造
          Student (void) : m_a (100) {
              m_name = "没名";
              m_age = 0;
          }
          // 单参构造
          Student (const string& name) : m_a (100),
              m_name (name),     m_age (0) {
              m_name = "哈哈";
          }
      };
      int main (void) {
          Student s1 ("张飞", 25);             //传参，隐示构造
          s1.eat ("包子");                 //必须按顺序传参，先隐在实；
      //    _ZN7Student3eatERKSs (&s1, "包子");    //
          Student s2 = Student ("赵云", 22);          //显示构造
          s2.eat ("烧饼");              //成员用点调用;
      //    _ZN7Student3eatERKSs (&s2, "烧饼");    
          Student s3;               //不能加小括号,没参就是无参构造；
          s3.eat ("煎饼果子");
          Student* s4    = new Student ("关羽", 30);        //构造实参
          s4->eat ("烤鸭");              //堆的调用，指针，用箭头
          delete s4;
          Student& s5 = *new Student ();       //引用调用
          s5.eat ("面条");          //用点
          delete &s5;
          Student sa1[3] = {s1, s2};         //第三个为0
          sa1[0].eat ("KFC");
          sa1[1].eat ("KFC");
          sa1[2].eat ("KFC");
          Student* sa2 = new Student[3] {s1, s2};       // 2011标准，new创造的数组
          sa2[0].eat ("KFC");
          sa2[1].eat ("KFC");
          sa2[2].eat ("KFC");
          delete[] sa2;            //清除
          Student s6 ("刘备");
          s6.eat ("米饭");
          return 0;
      }

   8. 对象的创建过程

      分配内存 –> 调用构造函数

      ​ ->调用类类型成员的构造函数 -> 构造函数的代码。

   9. 初始化表

      class 类名{
          类名（…） ：初始化表{
          构造函数体；
          }
      }；
      const int x = 100;
      x = 100;
      int& a = b;
      a = b;

      (1) 如果类中含有常量或引用型的成员变量，必须通过初始化表对其初始化。

      #include <iostream>
      using namespace std;
      int g_data = 1000;
      class A {
      public:
          A (void) : m_c (100), m_r (g_data) {  //只能放在初始化表中初始化
      //        m_c = 100;
      ///        m_r = g_data;
          }
          void print (void) {
              cout << m_c << ' ' << m_r << endl;
          }
      private:
          const int m_c;
          int& m_r;
      };
      int main (void) {
          A a;
          a.print ();
          return 0;
      }

      (2) 成员变量的初始化顺序仅于其被声明的顺序有关，而初始化表的顺序无关。

      class A {
          public:
          A (char* psz) : m_str (psz),
          m_len (strlen (psz)) private:
          size_t m_len;
          string m_str;
      };

      main.h

      #ifndef _S_H
      #define _S_H
      #include <string>
      using namespace std;
      // 声明Student类
      class Student {
      public:
          Student (const string& name = "", int age = 0);
          void eat (const string& food);
      private:
          string m_name;
          int m_age;
      };
      #endif // _S_H

      main.c

      #include "main.h"
      // 使用Student类
      int main (void) {
          Student s ("张飞", 25);
          s.eat ("包子");
          return 0;
      }

      练习：实现一个Clock类支持两种工作模式，计时器和电子钟。

      00:01:00

      14:05:37

      include \ 需要包含的头文件

      cout << setw (10) << setfill (‘0’) << 12;

      0000000012

      setw设置输出宽度。setfill设置填充字符。

      Clock

      时、分、秒

      走 - 显示、滴答

      //实现一个CLOCK类支持两中工作模式，计时器和电子钟。
      #include <iostream>
      #include <iomanip>     //io流的格式控制
      using namespace std;
      class Clock {
      public:
          Clock (bool timer = true) :m_hour (0), m_min (0), m_sec (0) {         //构造函数，条件判断，初始化表
              if (! timer) {
                  time_t t = time (NULL);        //1970年到现在走秒
                  tm* local = localtime (&t);         //本地时间        //回去实现一下！
                  m_hour = local->tm_hour;        //赋值
                  m_min = local->tm_min;
                  m_sec = local->tm_sec;
              }
          }
          void run (void) {
              for (;;) {                //死循环
                  show ();
                  tick ();
              }
          }
      private:
          void show (void) {
              cout << '\r' << setfill ('0')       //\r相当于回车，当前行
                  << setw (2) << m_hour << ':'        //setw设置输出宽度
                  << setw (2) << m_min << ':'
                  << setw (2) << m_sec << flush;     //冲到内核里，从缓冲区拿出来
      //        printf ("\r%02d:%02d:%02d", m_hour,    //C的方式
      //            m_min, m_sec);
          }
          void tick (void) {
              sleep (1);//休息1秒
              if (++m_sec == 60) {
                  m_sec = 0;
                  if (++m_min == 60) {
                      m_min = 0;
                      if (++m_hour == 24)
                          m_hour = 0;
                  }
              }
          }
          int m_hour;//定义成员变量，定义为私有；
          int m_min;
          int m_sec;
      };
      int main (void) {
          Clock clock (true);    //这个clock是废物，貌似是传说中的函数重载，与类里面的那个构造函数与之相对应
      //    Clock clock (false);
          clock.run ();
          return 0;
      }

5. this指针

   1. 一般而言，在类的构造函数或成员函数中，关键字this表示一个指针，对于构造函数而言，this指向正在被构造的对象，对于成员函数而言，this指向调用该函数的对象。

   2. this指针的用途

      1)在类的内部区分成员变量。

      this实质是个形参

      #include <iostream>
      using namespace std;
      class A {
      public:
          A (int data) : data (data) {//括号外面的就是成员变量
              cout << "构造: " << this << endl;//调用函数的指针this
      //        this->data = data;//加this区分成员变量
          }
          void foo (void) {
              cout << "foo: " << this << endl;
              cout << this->data << endl;//系统可以自己加箭头.通过指针找到变量；
          }
          int data;
      };
      int main (void) {
          A a (1000);
          cout << "main: " << &a << endl;
          a.foo ();
          A* pa = new A (1000);//堆里面情况也一样
          cout << "main: " << pa << endl;
          pa->foo ();
          delete pa;
      }

      2)在成员函数中返回调用对象自身。

      #include <iostream>
      using namespace std;
      class Counter {
      public:
          Counter (void) : m_data (0) {}
      //    Counter inc (void) {       //是克隆版
          Counter& inc (void) {       //去掉引用返回的就是克隆版
              ++m_data;
              return *this;
          }
          void print (void) {
              cout << m_data << endl;
          }
      private:
          int m_data;
      };
      int main (void) {
          Counter c;
      //    c.inc ();
      //    c.inc ();
      //    c.inc ();
          c.inc ().inc ().inc ();
          c.print (); // 3
          return 0;
      }

      3)在成员函数内部通过参数向外界传递调用对象自身，以实现对象间交互。

      老 -问题-> 学

      师 <-答案- 生

      class A {
          B  m_b;
      };
      class B {
          A  m_a;
      };   //ERORR,没法计算大小，指针和引用可以。
      sizeof (A) ?
      class C {
          C m_c;
      };   //ERORR

      //交叉类
      #include <iostream>
      using namespace std;
      class Student;           //短式声明
      class Teacher {
      public:
          void educate (Student* s);    //只是声明不做定义；
      //    {
      //        s -> ask ("什么是指针？",this);
      //        cout << "答案：" << m_answer << endl;
      //    }
          void reply (const string& answer) {
              m_answer = answer;
          }
      private:
          string m_answer;  //定义成员变量；
      };
      class Student {
      public:
          void ask (const string& question, Teacher* t) {   //此时的ask已经被指针所指向；
              cout << "问题：" << question << endl;
              t->reply ("不知道。");
          }
      };
      void Teacher::educate (Student* s) {      //外部定义
          s->ask ("什么是this指针？", this);    //this记录的是t的地址
          cout << "答案：" << m_answer << endl;
      }
      int main (void) {
          Teacher t;
          Student s;
          t.educate (&s);    //交付学生地址
          return 0;
      }

6. 常函数与常对象

   1. 如果在一个类的成员函数的参数表后面加上const关键字，那么这个成员函数就被称为常函数，常函数的this指针是一个常指针。在常函数内部无法修改成员变量，除非该变量具有mutable属性。而且在常函数内部也无法调用非常函数。

   2. 常对象：拥有const属性的对象，对象引用或指针。

      常对象只能调用常函数。

      同型的常函数和非常函数可以构成重载关系。常对象调用常版本，非常对象调用非常版本(相互对应)。如果没有非常版本，非常对象也可以调用常版本。

      const XXX 函数名 (const YYY yyy) const {
          ...
      }

      const对应修饰：返回值、参数、this指针

      只用成员函数才有this指针，全局函数就没有。

      #include <iostream>
      using namespace std;
      class A {
      public:
      //    void bar (void) {
      //        cout << "非常bar" << endl;
      //    }
          void bar (void) const {    //将this指针变成常数
              cout << "常bar" << endl;
          }
      //  void XXXbarYYY (A* this) {}
          void foo (void) const {
      //        m_i = 100;         //前面加一个mutable就可以了
              const_cast<A*>(this)->m_i = 100;  //可以自己去常；
          }
          void print (void) const {
              cout << m_i << endl;
          }
      //    _ZNK1A3fooEv (const A* this) {        //k表明常函数，
      //        const_cast<A*>(this)->m_i = 100;    //  去常
      //    }
          int m_i;
      };
      void func (void) /*const*/ {}
      int main (void) {
          A a;
          a.foo ();
          a.print ();
          const A& r = a;     //常引用
          r.bar ();   //必须为常函数
      //    XXXbarYYY (&r); // const A*
          a.bar ();    //也可以调用非常
      //    XXXbarYYY (&a); // A*
          return 0;
      }

7. 析构函数

   class 类名 {
       ~类名 (void) {  //必须没有参数
           析构函数体;
       }
   };

   当一个对象被销毁时自动执行析构函数。

   局部对象离开作用域时被销毁，堆对象被delete时被销毁。

   如果一个类没有定义任何析构函数，那么系统会提供一个缺省析构函数。缺省析构函数对基本类型的成员变量什么也不干，对类类型的成员变量，调用相应类型的析构函数。

   一般情况下，在析构函数中释放各种动态分配的资源。

   构造：基类->成员->子类

   析构：子类->成员->基类

   #include <iostream>
   using namespace std;
   class Double {
   public:
       Double (double data) :
           m_data (new double (data)) {    //开辟的是堆的地址
           cout << "构造" << endl;
       }
       ~Double (void) {     //析构函数，无参；自动释放内存；
           cout << "析构" << endl;
           delete m_data;
       }
       void print (void) const {
           cout << *m_data << endl;
       }
   private:
       double* m_data;
       string m_lable;
   };
   int main (void) {
   //    {
           Double d1 (3.14);
           d1.print ();
   //    }
       Double* d2 = new Double (1.23);
       delete d2;   //还可以调用析构函数
       cout << "再见！" << endl;
       return 0;

8. 拷贝构造函数和拷贝赋值运算符

   1. 拷贝构造：用一个已有的对象，构造和它同类型的副本对象——克隆。

      #include <iostream>
      using namespace std;
      class Integer {
      public:
          Integer (int data = 0) : m_data (data) {}    //构造函数
          void print (void) const {
              cout << m_data << endl;
          }
      //    /*
          Integer (const Integer& that) :  //拷贝构造函数,编译器可以自己生成；
              m_data (that.m_data) {
              cout << "拷贝构造" << endl;
          }
      //    */
      private:
          int m_data;
      };
      void foo (Integer i) {
          i.print ();
      }
      Integer bar (void) {
          Integer i;
          return i;        //36行。优化策略，直接传的是i，不是匿名
      }
      int main (void) {
          Integer i1 (10);
          i1.print ();
          Integer i2 (i1); // 拷贝构造
          i2.print ();
          Integer i3 = i1; // 拷贝构造，  非赋值，这是初始化；
          i3.print ();
      //    Integer i4 (10, 20);
          cout << "调用foo()函数" << endl;
          foo (i1);
          cout << "调用bar()函数" << endl;
          Integer i4 (bar ());
          return 0;
      }

   2. 形如

      class X {
      X (const X& that) { ... }
      };

      的构造函数成为拷贝构造函数。如果一个类没有定义拷贝构造函数，系统会提供一个缺省拷贝构造函数。缺省拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型的成员变量，调用相应类型的拷贝构造函数。

   3. 在某些情况就下，缺省拷贝构造函数只能实现浅拷贝，如果需要获得深拷贝的复制效果，就需要自己定义拷贝构造函数。

      #include <iostream>
      using namespace std;
      class Integer {
      public:
          Integer (int data) : m_data (new int (data)) {}
          ~Integer (void) {
              if (m_data) {
                  delete m_data;
                  m_data = NULL;
              }
          }
          void print (void) const {
              cout << *m_data << endl;
          }
          Integer (const Integer& that) :  //拷贝构造
              m_data (new int (*that.m_data)) {}
          void set (int data) {
              *m_data = data;
          }
          Integer& operator= (const Integer& that) {
              // 防止自赋值
              if (&that != this) {
                  // 释放旧资源
                  delete m_data;
                  // 分配新资源
                  m_data = new int (*that.m_data);//实现深拷贝
                  // 拷贝新数据
              }
              // 返回自引用
              return *this;//
          }
      private:
          int* m_data;
      };
      int main (void) {
          Integer i1 (10);
          i1.print ();
          Integer i2 (i1);
          i2.print ();
          i2.set (20);
          i2.print ();
          i1.print ();
          Integer i3 (30);
          i3.print (); // 30
          i3 = i1; // 拷贝赋值,非拷贝构造，发生了浅拷贝
          // i3.operator= (i1);
          i3.print (); // 10
          i3.set (40);
          i3.print (); // 40
          i1.print (); // 10
          /*
          int a = 10, b = 20, c = 30;
          (a = b) = c;
          cout << a << endl;  //30
          */
          (i3 = i1) = i2;
      //    i3.operator=(i1).operator=(i2);
          i3.print ();
          i3 = i3;
          i3.print ();
          return 0;
      }

   4. 形如

      class X {
          X& operator= (const X& that) {
              ...
          }
      };

      的成员函数称为拷贝赋值运算符函数。如果一个类没有定义拷贝赋值运算符函数，系统会提供一个缺省拷贝赋值运算符函数。缺省拷贝赋值运算符函数对于基本类型的成员变量，按字节复制，对于类类型的成员变量，调用相应类型的拷贝赋值运算符函数。

      #include <iostream>
      using namespace std;
      class Nocopy {
      public:
          Nocopy (void) {}
      private:
          Nocopy (const Nocopy&);
          Nocopy& operator= (const Nocopy&);
      };
      void foo (ostream os) {
          os << "Hello, World !" << endl;
      }
      int main (void) {
          Nocopy n1;
          Nocopy n2 = n1;
          Nocopy n3;
          n3 = n1;
          foo (cout);
          return 0;
      }

   5. 在某些情况就下，缺省拷贝赋值运算符函数只能实现浅拷贝，如果需要获得深拷贝的复制效果，就需要自己定义拷贝赋值运算符函数。

      练习：实现一个简化版的字符串类String支持：

      1.用字符指针形式的字符串构造

      2.拷贝构造和拷贝赋值

      3.获取字符指针形式字符串的成员函数，类似string::c_str

      说明：不得使用std::string！

      //简化版的字符串类string；
      #include <iostream>
      #include <cstring>   // c的东东
      using namespace std;
      class String {
      public:
          String (const char* str = NULL) {   //给个指针
              m_str = new char[strlen(str?str:"")+1];   //开辟空间，加一放\0；判断一下防止strlen蹦掉
              strcpy (m_str, str ? str : "");     // 拷贝字符串到缓冲区，
          }
          ~String (void) {        //析构函数
              if (m_str) {
                  delete[] m_str;
                  m_str = NULL;
              }
          }
          String (const String& that) :
              m_str (strcpy (
                  new char[strlen(that.m_str)+1],
                  that.m_str)) {}
          /* 菜鸟
          void operator= (const String& that) {         //内存泄露
              m_str = new char[strlen(that.m_str)+1];
              strcpy (m_str, that.m_str);
          }*/
          String& operator= (const String& that) {
              if (&that != this) {
                  /* 小鸟
                  delete[] m_str;
                  m_str = new char[strlen(that.m_str)+1];    //可能自赋值，就会出错必须加if判断
                  strcpy (m_str, that.m_str);
                  */
                  /* 大鸟
                  char* str = 
                      new char[strlen(that.m_str)+1];
                  delete[] m_str;
                  m_str = strcpy (str, that.m_str);
                  */
                  // 老鸟
                  String temp (that);  //
                  swap (m_str, temp.m_str);// 交换两个参数
              }
              return *this;
          }
          const char* c_str (void) const {
              return m_str;
          }
      private:
          char* m_str;
      };
      int main (void) {
          String s1 ("Hello, World !");
          cout << s1.c_str () << endl;
          String s2 = s1;
          cout << s2.c_str () << endl;
          String s3 ("Hello, Linux !");
          try {
              s1 = s3;
          }
          catch (exception& ex) {
              cout << ex.what () << endl;
          }
          cout << s1.c_str () << endl;
          return 0;
      }

9. 静态成员

   1. 静态成员变量和静态成员函数是属于类的而非属于对象。

   2. 静态成员变量，为多个对象所共享，只有一份实例，可以通过对象访问也可以通过类访问，必须在类的外部定义并初始化。静态成员变量本质上与全局变量并没有区别，只是多了类作用域的约束，和访控属性的限制。

      class Account {
          private:
          string m_name;
          double m_balance;
          static double m_rate;
      };

      #include <iostream>
      using namespace std;
      class A {
      public:
          static int m_i;
          static void foo (void) {
              cout << "foo：" << m_i << endl;
      //        m_d = 3.14;      //静态的不能访问普通的，因为没this指针；
      //        bar ();
          }
          double m_d;
          void bar (void) {
              m_i = 1000;
              foo ();
          }
      };
      int A::m_i = 1;    //作用域限定，必须在外面声明全局变量；
      int main (void) {
          A::m_i = 10;
          A a1, a2;
          cout << ++a1.m_i << endl;   //对象访问
          cout << a2.m_i << endl;
          A::foo ();
          a1.foo ();
          a1.bar ();
          return 0;
      }

   3. 静态成员函数，没有this指针，无法访问非静态成员。

   4. 单例模式

      懒汉式：

      懒汉式是指，在第一次获取这个类的实例的时候才new这个对象。即可以延迟加载该对象实例。

      懒汉式单例设计模式在多线程同时初始化实例的时候有线程安全问题， 解决的方案是，加同步锁，使用同步方法和同步代码块都能解决问题。 然而多线程每次都访问锁，导致效率低下，所以使用同步代码块，然后以双重判断的形式来解决每次都判断同步锁导致的效率低下问题。

      #include <iostream>
      using namespace std;
      // 懒汉方式
      class Singleton {
      public:
          static Singleton& getInst (void) {
              if (! m_inst)
                  m_inst = new Singleton;
              ++m_cn;
              return *m_inst;
          }
          void releaseInst (void) {    //释放实例
              if (m_cn && --m_cn == 0)
                  delete this;
          }
      private:
          Singleton (void) {
              cout << "构造：" << this << endl;
          }
          Singleton (const Singleton&);
          ~Singleton (void) {
              cout << "析构：" << this << endl;
              m_inst = NULL;
          }
          static Singleton* m_inst;
          static unsigned int m_cn;
      };
      Singleton* Singleton::m_inst = NULL;
      unsigned int Singleton::m_cn = 0;
      int main (void) {
          Singleton& s1 = Singleton::getInst ();
          Singleton& s2 = Singleton::getInst ();
          Singleton& s3 = Singleton::getInst ();
          cout << &s1 << ' ' << &s2 << ' ' << &s3 << endl;
       s3.releaseInst ();
          s2.releaseInst ();
          s1.releaseInst ();
          return 0;
      }

      饿汉式： 饿汉式是指，在类加载的时候即new出该类对象。 饿汉式单例模式在类加载时就创建了单例对象，它是线程安全的。

      //单例模式
      #include <iostream>
      using namespace std;
      // 饿汉方式
      class Singleton {
      public:
          static Singleton& getInst (void) {
              return s_inst;
          }
      private:
          Singleton (void) {}
          Singleton (const Singleton&);  //拷贝私有化
          static Singleton s_inst;
      };
      Singleton Singleton::s_inst; //静态成员变量//始终仅存在一个对象
      int main (void) {
          Singleton& s1 = Singleton::getInst ();
          Singleton& s2 = Singleton::getInst ();
          Singleton& s3 = Singleton::getInst ();
          cout << &s1 << ' ' << &s2 << ' ' << &s3 << endl;
          return 0;
      }

10. 成员指针

    Student s;
    string* p = &s.m_name; // 不是
    Student s2;

    (一)成员变量指针

    1. 定义

       成员变量类型 类名::*指针变量名;

       string Student::*pname;
       int Student::*page;0

    2. 初始化/赋值

       指针变量名 = &类名::成员变量名

       pname = &Student::m_name;
       page = &Student::m_age;

    3. 解引用

       对象.*指针变量名(.*为引用型)

       对象指针->*指针变量名(->*为指针型)

       Student s, *p = &s;
       s.*pname = "张飞";
       cout << p->*page << endl;