学习笔记之C++入门到精通（名师教学·手把手教会）【职坐标】_腾讯课堂
C++入门到精通（名师教学·手把手教会）【职坐标】_腾讯课堂java
https://ke.qq.com/course/101465#term_id=100105503ios
https://github.com/haotang923/ke.qq.com.cppc++
内联函数
- 函数调用须要创建栈内存环境，进行参数传递，并产生程序执行转移，这些工做都须要时间开销。
- C++提供inline函数，减小函数调用的成本。编译器看到inline后，为该函数建立一段代码，以便在后面每次碰到该函数的调用都用同一段代码来替换。
- 内联函数能够在一开始仅声明一次。
- 内联函数必须在调用以前被声明或定义，由于它的代码必须在被替换以前已经生成被替换的代码。
- 内联函数中，不能有复杂结构控制语句如swtich/while/for。不然编译将该函数视为普通函数那样产生函数调用代码。
- 递归函数不能做为内联函数。
- 内联函数只适合于1-5行小函数。对于较长的函数，函数调用和返回的开销相对来讲微不足道，也不必用内联函数实现。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 13 14 #define WRONGSQUARE(x) (x * x) 15 #define SQUARE(x) ((x) * (x)) 16 17 inline int max(int a, int b) 18 { 19 return a > b ? a : b; 20 } 21 22 int main() 23 { 24 int a = 55, b = 4; 25 26 int c = max(a ++, b); 27 28 cout << "c = " << c << endl; 29 cout << "a = " << a << endl; 30 31 a = 55; 32 33 int d = MAX(a ++, b); // a ++ > b ? a ++ : b; 34 35 cout << "d = " << d << endl; 36 cout << "a = " << a << endl; 37 38 int e = SQUARE(2 + 3); // ((2 + 3) * (2 + 3)) 39 40 cout << "e = " << e << endl; 41 42 int f = WRONGSQUARE(2 + 3); // (2 + 3 * 2 + 3) 43 44 cout << "f = " << f << endl; 45 46 return 0; 47 }
- 结果能够看出宏使用中出现了不可预期的结果，而内联函数不会。
c = 55 a = 56 d = 56 a = 57 e = 25 f = 11 Program ended with exit code: 0
默认参数的函数
- 若是一个函数有多个默认参数，则行参分布中，默认参数应从右往左逐渐定义。而当调用参数时，只能从右往左匹配参数。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 void foo(int i, int j = 5, int k = 10); 13 //void foo(int, int = 5, int = 10); 14 15 int main() 16 { 17 foo(20); 18 foo(20, 30); 19 foo(20, 30, 40); 20 21 return 0; 22 } 23 24 void foo(int i, int j, int k) 25 { 26 cout << i << " " << j << " " << k << endl; 27 }
- 结果
20 5 10 20 30 10 20 30 40 Program ended with exit code: 0
函数重载
- 相同的函数名，可是行参个数或类型不一样
- 编译器不以行参名，返回值来区分
- 预约义的宏
- https://msdn.microsoft.com/zh-cn/library/b0084kay.aspx
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 int square(int x) 13 { 14 cout << __FILE__ << " " << __LINE__ << " " << __func__ << endl; // File / Line / Function 15 return x * x; 16 } 17 18 double square(double x) 19 { 20 cout << __FILE__ << " " << __LINE__ << " " << __func__ << endl; // File / Line / Function 21 return x * x; 22 } 23 24 int main() 25 { 26 cout << "square(10)\n" << square(10) << endl; 27 cout << "suqare(1.1)\n" << square(1.1) << endl; 28 29 return 0; 30 }
- 结果注意用到预约义宏__FILE__，__LINE__，__func__来输出文件，行数和函数
square(10) /Users/hao/PROJECTS/LeetCode/LeetCode/main.cpp 14 square 100 suqare(1.1) /Users/hao/PROJECTS/LeetCode/LeetCode/main.cpp 20 square 1.21 Program ended with exit code: 0
- C语言头文件中的extern "C"
1 // 2 // Header.h 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/3. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 //常见的C语言头文件格式 10 #ifndef Header_h 11 #define Header_h 12 13 #ifdef __cplusplus 14 extern "C" { 15 #endif 16 17 // C语言的函数在C++中调用 18 void sample(); 19 20 #ifdef __cplusplus 21 } 22 #endif 23 24 #endif /* Header_h */
函数模版
- 对于具备各类参数类型，相同个数，相同顺序的同一函数（重载函数），若是用宏定义来写，则它不能检查数据类型，损害了类型安全性 。
- 用模版能够减小代码量。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 template <typename T> 13 T fAbs(T x) 14 { 15 return x < 0 ? -x : x; 16 } 17 18 int main() 19 { 20 int n = -5; 21 double d = -5.5; 22 23 cout << fAbs(n) << endl; 24 cout << fAbs(d) << endl; 25 26 return 0; 27 }
5 5.5 Program ended with exit code: 0
类、对象和封装
- struct安全性很差，任何人都能访问
- class类不只能够保护数据，还能够提供成员函数操做数据
- 类中定义的成员函数通常位内联函数，即便没有用inline标示
- this指针表明当前对象占用内存空间的地址
- OOP的三大特性封装（encapsulation）、多态（polymorphism）、继承（inheritance）
构造函数与析构函数
- 只要类定义了一个构造函数，C++就再也不提供默认的构造函数。
- 与变量定义相似，在用默认构造函数建立对象时，若是建立的是全局对象或静态对象，则对象的值为0，不然对象值是随机的。
- 构造函数的一个特殊之处是它没有返回类型，函数体中也不容许返回值，但能够有无值返回语句“return；”。
- 若是建立一个5个元素的对象数组，则构造函数会被调用5次。
- 析构函数只有一个，不能重载
1 // 2 // Student.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/11. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef Student_hpp 10 #define Student_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 class Student 16 { 17 public: 18 Student(int id = 0); 19 ~Student(); 20 21 const int getID() const; 22 void setID(int id); 23 const int getScore() const; 24 void setScore(int score); 25 26 private: 27 int m_id; 28 int m_score; 29 }; 30 31 inline const int Student::getID() const 32 { 33 return m_id; 34 } 35 36 inline void Student::setID(int id) 37 { 38 m_id = id; 39 } 40 41 inline const int Student::getScore() const 42 { 43 return m_score; 44 } 45 46 inline void Student::setScore(int score) 47 { 48 m_score = score; 49 } 50 51 #endif /* Student_hpp */
1 // 2 // Student.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/11. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Student.hpp" 10 #include <iostream> 11 using namespace std; 12 13 Student::Student(int id) 14 : m_score(0), m_id(id) 15 { 16 cout << "Student Constructor" << endl; 17 } 18 19 Student::~Student() 20 { 21 cout << "Student destructor" << endl; 22 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include "Student.hpp" 11 using namespace std; 12 13 int main() 14 { 15 // { 16 class Student std(10); 17 18 cout << std.getID() << endl; 19 cout << std.getScore() << endl; 20 // } 21 cout << "return from main()" << endl; 22 23 return 0; 24 }
Student Constructor 10 0 return from main() Student destructor Program ended with exit code: 0
static类成员
- 在static成员函数中不能使用this指针，由于this指针是属于对象的，而static成员函数是属于类的，不属于某一对象。
- 即便没有实例化类的对象，static数据成员和成员函数仍然可使用。
- static成员的名字在类的做用域中，所以能够避免与其余的类的成员或者全局对象名字冲突。
- 能够实施封装，static成员能够是私有成员，而全局对象不能够。
动态内存分配
- C语言的动态内存分配：malloc/free函数
- 内存区域
- data area：全局变量、静态数据、常量
- code area：全部类成员函数和非成员函数代码
- stack area：为运行函数而分配的局部变量、函数参数、返回数据、返回地址等
- heap area：动态内存分配区
- C++的运算符new/delete和malloc/free区别
- 在堆上生成对象，须要自动调用构造函数。new能够作到，而malloc不行。
- 在堆上生成的对象，在释放时须要自动调用析构函数。delete能够，而free不行。
- new[]/delete[]生成和释放动态数组
- new/delete，new[]/delete[]和malloc/free须要配对使用
- new/delete是运算符，而malloc/free是函数调用
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <cstdlib> // malloc/free 11 using namespace std; 12 13 class Test 14 { 15 public: 16 Test(int val = 0) 17 : m_val(val) 18 { 19 cout << "Test" << endl; 20 } 21 22 ~Test() 23 { 24 cout << "~Test" << endl; 25 } 26 27 private: 28 int m_val; 29 }; 30 31 int main () 32 { 33 { 34 Test a; // "Test" 35 } // End of scope : "~Test" 36 cout << "end of }" << endl; 37 38 Test *pVal = new Test(); // "Test" 39 delete pVal; // "~Test" 40 pVal = nullptr; 41 42 int *p = (int *)malloc(sizeof(int)); 43 free(p); 44 p = nullptr; 45 46 Test *pArray = new Test[2]; // twice "Test" 47 48 delete[] pArray; // twice call of destructor "~Test" 49 //delete pArray; // memory leak 50 51 pVal = new Test(10); // "Test" 52 delete pVal; // "~Test" 53 54 return 0; 55 }
Test ~Test end of } Test ~Test Test Test ~Test ~Test Test ~Test Program ended with exit code: 0
拷贝构造函数
- 当将该类型的对象传递给函数或从函数返回该类型的对象时，将隐式的调用拷贝构造函数。
- 若是一个类没有定义拷贝构造函数，编译器会默认提供拷贝构造函数。
- 编译器提供的默认拷贝构造函数的行为
- 执行逐个成员初始化，将新对象初始化为原对象的副本。
- “逐个成员”，指的是编译器将现有对象的每一个非static成员，依次复制到正在建立的对象。
- 为何C++要定义拷贝构造函数浅拷贝：建立对象p2时，对象p1被复制给了p2，但资源并未复制。所以，p1和p2指向同一个资源。
- 两个对象拥有统一资源，引发问题
- 下例演示了浅拷贝带来的问题。使用默认的拷贝构造函数建立的对象p2，只是浅拷贝对象p，因此它们指向同一块内存空间。而程序结束时，依次析构p2，p3，p。因为析构p2时已经将内存空间释放，因此析构p时出错“pointer being freed was not allocated”。
1 // 2 // person.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/26. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef person_hpp 10 #define person_hpp 11 12 class Person 13 { 14 public: 15 Person(char * pName); 16 ~Person(); 17 /* 18 Person(const Person &s); 19 Person& operator=(const Person &other); 20 */ 21 22 void Print(); 23 24 private: 25 char *name; 26 }; 27 28 29 #endif /* person_hpp */
1 // 2 // person.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/26. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "person.hpp" 10 11 #include <iostream> 12 #include <cstring> 13 using namespace std; 14 15 Person::Person(char *pN) 16 { 17 if (pN != nullptr) { 18 cout << "Constructing " << pN << " --->" << endl; 19 20 int len = strlen(pN) + 1; 21 name = new char[len]; 22 cout << "name = " << static_cast<void *>(name) << "\n" << endl; 23 memset(name, 0, len); 24 strcpy(name, pN); 25 } else { 26 name = nullptr; 27 } 28 } 29 30 Person::~Person() 31 { 32 cout << "Destrcuting Person --->" << endl; 33 34 if (name != nullptr) { 35 Print(); 36 delete [] name; 37 name = nullptr; 38 } 39 } 40 41 void Person::Print() 42 { 43 cout << "pName = " << static_cast<void *>(name) << "\n" << endl; 44 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 #include "person.hpp" 13 14 int main () 15 { 16 Person p("Joe"); 17 Person p3("Tom"); 18 19 Person p2 = p; // 浅拷贝：使用编译器提供的默认的拷贝构造函数，指向同一块内存空间。致使析构时出现问题，同一块内存空间被析构两次。 20 21 cout << "Print p --->" << endl; 22 p.Print(); 23 24 cout << "Print p2 --->" << endl; 25 p2.Print(); 26 27 return 0; 28 }
// 构造p Constructing Joe ---> name = 0x100429ab0 // 构造p3 Constructing Tom ---> name = 0x100429d80 Print p ---> pName = 0x100429ab0 Print p2 ---> pName = 0x100429ab0 // 析构p2 Destrcuting Person ---> pName = 0x100429ab0 // 析构p3 Destrcuting Person ---> pName = 0x100429d80 // 析构p Destrcuting Person ---> pName = 0x100429ab0 LeetCode(2399,0x100395340) malloc: *** error for object 0x100429ab0: pointer being freed was not allocated *** set a breakpoint in malloc_error_break to debug (lldb)
- 下例演示了深拷贝。注意到拷贝构造函数和重载赋值运算符里都将对象指向一块新的内存空间，因此析构时没有出现同一块内存空间被释放屡次的问题。
1 // 2 // person.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/26. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef person_hpp 10 #define person_hpp 11 12 class Person 13 { 14 public: 15 Person(char * pName); 16 ~Person(); 17 Person(const Person &s); 18 Person& operator= (const Person &other); 19 20 void Print(); 21 22 private: 23 char *name; 24 }; 25 26 27 #endif /* person_hpp */
1 // 2 // person.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/26. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "person.hpp" 10 11 #include <iostream> 12 #include <cstring> 13 using namespace std; 14 15 Person::Person(char *pN) 16 { 17 if (pN != nullptr) { 18 cout << "Constructing " << pN << " --->" << endl; 19 20 int len = strlen(pN) + 1; 21 name = new char[len]; 22 cout << "name = " << static_cast<void *>(name) << "\n" << endl; 23 memset(name, 0, len); 24 strcpy(name, pN); 25 } else { 26 name = nullptr; 27 } 28 } 29 30 Person::~Person() 31 { 32 cout << "Destrcuting Person --->" << endl; 33 34 if (name != nullptr) { 35 Print(); 36 delete [] name; 37 name = nullptr; 38 } 39 } 40 41 Person::Person(const Person &p) 42 { 43 cout << "Copy Constructor of Person --->" << endl; 44 45 if (p.name != nullptr) { 46 int len = strlen(p.name) + 1; 47 name = new char[len]; 48 cout << "name = " << static_cast<void *>(name) << "\n" << endl; 49 memset(name, 0, len); 50 strcpy(name, p.name); 51 } else { 52 name = nullptr; 53 } 54 } 55 56 // 注意“operator= ()”须要留一个空格，不然出错 57 Person& Person::operator= (const Person &other) 58 { 59 cout << "operator= --->\n" << endl; 60 61 // 防止自赋值 62 if (&other == this) { 63 return *this; 64 } 65 66 if (name != nullptr) { 67 delete [] name; 68 name = nullptr; 69 } 70 71 if (other.name != nullptr) { 72 int len = strlen(other.name) + 1; 73 name = new char[len]; 74 memset(name, 0, len); 75 strcpy(name, other.name); 76 } else { 77 name = nullptr; 78 } 79 80 return *this; 81 } 82 83 void Person::Print() 84 { 85 cout << "pName = " << static_cast<void *>(name) << "\n" << endl; 86 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 #include "person.hpp" 13 14 int main () 15 { 16 Person p("Joe"); 17 Person p3("Tom"); 18 19 Person p2 = p; // 深拷贝：自定义拷贝构造函数，指向不一样内存空间。析构时没有问题。 20 21 cout << "Print p --->" << endl; 22 p.Print(); 23 24 cout << "Print p2 --->" << endl; 25 p2.Print(); 26 27 p2 = p3; // 重载赋值运算符 28 29 cout << "Print p3 --->" << endl; 30 p3.Print(); 31 32 cout << "Print p2 --->" << endl; 33 p2.Print(); 34 35 return 0; 36 }
// 构造p Constructing Joe ---> name = 0x103105370 // 构造p3 Constructing Tom ---> name = 0x1031053f0 // 构造p2 Copy Constructor of Person ---> name = 0x10310a520 Print p ---> pName = 0x103105370 Print p2 ---> pName = 0x10310a520 // 赋值给p2 operator= ---> Print p3 ---> pName = 0x1031053f0 Print p2 ---> pName = 0x100608e20 // 析构p2 Destrcuting Person ---> pName = 0x100608e20 // 析构p3 Destrcuting Person ---> pName = 0x1031053f0 // 析构p Destrcuting Person ---> pName = 0x103105370 Program ended with exit code: 0
- 若是想禁止一个类的拷贝构造，须要将拷贝构造函数声明为private
- 什么时候须要定义拷贝构造函数
- 类数据成员有指针
- 类数据成员管理资源（如打开一个文件）
- 类须要析构函数来释放资源
const关键字
- const限定指针类型const数据成员必须使用成员初始化列表进行初始化
- const出如今*左边，表示被指物是常量
- const出如今*右边，表示指针自身是常量
- const成员函数
- 类接口清晰，肯定哪些函数能够修改数据成员
- 使用const提升函数的健壮性下例演示了const修饰符做用，const数据成员初始化，const成员函数以及引用传递和值传递。
- 用引用传递替代值传递：减小实参为对象时，拷贝构造/析构对象的代价。
- 控制使用指针和引用传递的实参被意外修改
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 class Student 13 { 14 public: 15 Student(int id = 0) 16 : m_id(id) // Must use initialization list to initialize the const member 17 { 18 cout << "Student constructor --->\n" << endl; 19 20 // ERROR : Cannot assign to non-static data member 'm_id' with const-qualified type 'const int' 21 //m_id = id; 22 } 23 24 ~Student() 25 { 26 cout << "Student destructor --->\n" << endl; 27 }; 28 29 Student(Student &other) 30 : m_id(other.m_id) 31 { 32 cout << "Student copy constructor --->\n" << endl; 33 } 34 35 inline int getID() const 36 { 37 return m_id; 38 } 39 40 private: 41 const int m_id; 42 }; 43 44 void foo(Student stu) 45 { 46 cout << __func__ << "\n" << endl; 47 } 48 49 void bar(const Student &stu) 50 { 51 cout << __func__ << "\n" << endl; 52 } 53 54 int main () 55 { 56 const int a = 1; 57 58 // ERROR : Cannot assign to variable 'a' with const-qualified type 'const int' 59 //a = 3; 60 61 int b = 0; 62 63 // const value 64 const int *p = &a; 65 66 p = &b; 67 b = 3; 68 69 cout << "p = " << *p << endl; 70 71 // ERROR : Read-only variable is not assignable 72 //*p = 1; 73 74 // const pointer 75 int * const p2 = &b; 76 77 // ERROR : Cannot assign to variable 'p2' with const-qualified type 'int *const' 78 //p2 = &a; 79 80 *p2 = 2; 81 82 cout << "p2 = " << *p2 << "\n" << endl; 83 84 { 85 Student john(1001); 86 87 cout << "Call foo(Student stu)\n" << endl; 88 89 foo(john); 90 91 cout << "Call bar(const Student &stu)\n" << endl; 92 93 bar(john); 94 } 95 96 cout << "Return from main" << endl; 97 98 return 0; 99 }
p = 3 p2 = 2 // 构造对象 Student constructor ---> Call foo(Student stu) // 值传递时对行参调用拷贝构造函数 Student copy constructor ---> foo // 函数调用完毕，对行参调用析构函数 Student destructor ---> // 引用传递不会调用构造析构行参 Call bar(const Student &stu) bar // 对象生命周期结束，析构对象 Student destructor ---> Return from main Program ended with exit code: 0
友元函数与友元类
- 友元机制容许一个类对其非公有成员对访问授予指定的函数或类。友元关系时授予的，必须显示声明时友元
- 友元的声明以friend开始
- 只能出如今类定义的内部
- 能够出如今类中的任何地方，不受其声明出现部分的访问控制（public/private/protect）影响
- 友元关系是不对称的
- 友元会破坏封装
- 下例演示了如何定义使用友元函数与友元类访问private变量
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 // 类的前置声明 13 class X; 14 15 class Y 16 { 17 public: 18 void f(X *); // 对前置声明的类只能使用指针做为行参，由于在32位系统下，一个指针占4个字节是固定的，编译器可预判的 19 // void b(X); // 用类做为行参则出错，由于编译器没法判断类的类型及大小 20 21 private: 22 X* pX; 23 }; 24 25 /* 26 // ERROR : Variable has incomplete type 'X' 27 void Y::b(X x) 28 { 29 } 30 */ 31 32 class X 33 { 34 public: 35 void initialize(); 36 void print(); 37 friend void fG(X *, int); // Global friend 38 friend void Y::f(X *); // class member friend 39 friend class Z; // Entire class is a friend 40 friend void h(); // Global friend 41 42 private: 43 int i; 44 }; 45 46 void X::initialize() 47 { 48 i = 0; 49 } 50 51 void X::print() 52 { 53 cout << "i = " << i << "\n" << endl; 54 } 55 56 void fG(X *x, int i) 57 { 58 x->i = i; 59 } 60 61 void Y::f(X *x) 62 { 63 x->i = 47; 64 } 65 66 class Z 67 { 68 public: 69 void initialize(); 70 void g(X *x); 71 72 private: 73 int j; 74 }; 75 76 void Z::initialize() 77 { 78 j = 100; 79 } 80 81 void Z::g(X *x) 82 { 83 x->i += j; 84 } 85 86 void h() 87 { 88 X x; 89 90 x.i = 100; // Direct data manipulation 91 x.print(); 92 } 93 94 int main () 95 { 96 X x; 97 98 x.initialize(); 99 x.print(); 100 101 // friend void fG(X *, int); // Global friend 102 fG(&x, 9); 103 x.print(); 104 105 // friend void Y::f(X *); // class member friend 106 Y y; 107 108 y.f(&x); 109 x.print(); 110 111 // friend class Z; // Entire class is a friend 112 Z z; 113 114 z.initialize(); 115 z.g(&x); 116 x.print(); 117 118 // friend void h(); // Global friend 119 h(); 120 121 return 0; 122 }
i = 0 i = 9 i = 47 i = 147 i = 100 Program ended with exit code: 0
Valgrind内存检测工具
- 使用工具检查程序中存在的内存问题
- 使用Valgrind完成相关功能
- Valgrind Home
- http://valgrind.org
- valgrind_百度百科
- https://baike.baidu.com/item/valgrind
运算符重载
- 重载赋值运算符若是一个类提供了拷贝构造函数，那么也要提供一个重载的赋值运算函数
- 若是一个类没有提供赋值运算函数，则默认提供一个。。。可是会存在浅拷贝的问题。
- C++语言规定
- 重载运算符要保持原有运算符的意义
- 只能对已有的运算符重载，不能增长新的运算符
- 重载的运算符不会改变原有的优先级和结合性
- 运算符重载的方式如下四个运算符不能被重载：:: / .* / . / ?
- 成员函数
- 友元函数
- C++规定，参数说明都是内部类型时（e.g. int），不能重载。
- 做为成员的运算符比做为友元的运算符，在声明和定义时，形式上少一个参数。
- C++规定：=，()，[]，-> 这四种运算符必须为成员形式
- 下例演示了自增运算符的重载。能够看到前增量效率更高，由于它不须要拷贝构造来保存原有对象值。还须要注意后增量运算符中的参数int只为了区别前增量与后增量，除此以外没有任何做用。
1 // 2 // Increase.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/28. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef Increase_hpp 10 #define Increase_hpp 11 12 class Increase 13 { 14 public: 15 Increase(int val); 16 ~Increase(); 17 18 Increase& operator++ (); // prefix, return reference 19 Increase operator++ (int val); // postfix, return value 20 21 int getVal() const 22 { 23 return m_val; 24 } 25 26 private: 27 int m_val; 28 }; 29 30 #endif /* Increase_hpp */
1 // 2 // Increase.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/28. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Increase.hpp" 10 11 Increase::Increase(int val) 12 : m_val(val) 13 { 14 } 15 16 Increase::~Increase() 17 { 18 } 19 20 Increase& Increase::operator++ () 21 { 22 ++ m_val; 23 return *this; 24 } 25 26 Increase Increase::operator++ (int) 27 { 28 Increase ret(m_val); 29 ++ m_val; 30 31 return ret; 32 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Increase.hpp" 10 11 #include <iostream> 12 using namespace std; 13 14 int main () 15 { 16 Increase val(100); 17 Increase val2 = ++ val; 18 19 cout << "val = " << val.getVal() << "\n" << endl; 20 cout << "val2 = " << val2.getVal() << "\n" << endl; 21 22 Increase val3 = val ++; 23 24 cout << "val3 = " << val3.getVal() << "\n" << endl; 25 cout << "val = " << val.getVal() << "\n" << endl; 26 27 return 0; 28 }
val = 101 val2 = 101 val3 = 101 val = 102 Program ended with exit code: 0
String类的运算符重载
- 下例演示了如何编写String类的构造函数/析构函数/拷贝构造函数/运算符重载
1 // 2 // TString.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/28. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef TString_hpp 10 #define TString_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 namespace T { 16 17 class String 18 { 19 public: 20 String (const char * = nullptr); 21 ~String (); 22 23 String (const String &); 24 25 // 重载赋值运算符 26 27 // String a; a = b; 28 String& operator= (const String &); 29 // String a; a = "hello"; 30 String& operator= (const char *); 31 32 String& operator+= (const String &); 33 String operator+ (const String &) const; 34 35 String& operator+= (const char *); 36 String operator+ (const char *) const; 37 38 inline const char * data() const 39 { 40 return m_data; 41 } 42 43 private: 44 char *m_data; 45 }; 46 47 } 48 49 50 #endif /* TString_hpp */
1 // 2 // TString.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/28. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "TString.hpp" 10 11 #include <iostream> 12 #include <cstring> 13 using namespace std; 14 15 namespace T 16 { 17 18 String::String(const char *str) 19 { 20 if (nullptr == str) { 21 m_data = new char[1]; 22 *m_data = '\0'; 23 } else { 24 int length = strlen(str); 25 m_data = new char[length + 1]; 26 strcpy(m_data, str); 27 } 28 } 29 30 String::~String() 31 { 32 delete [] m_data; 33 } 34 35 String::String(const String & other) 36 { 37 int length = strlen(other.m_data); 38 39 m_data = new char[length + 1]; 40 strcpy(m_data, other.m_data); 41 } 42 43 String& String::operator= (const String &other) 44 { 45 // 检查自赋值 46 if (this == &other) { 47 return *this; 48 } 49 50 // 释放原有内存资源 51 delete[] m_data; 52 53 int length = strlen(other.m_data); 54 m_data = new char[length + 1]; 55 strcpy(m_data, other.m_data); 56 57 return *this; 58 } 59 60 String& String::operator= (const char *other) 61 { 62 delete[] m_data; 63 64 if (nullptr == other) { 65 m_data = new char[1]; 66 *m_data = '\0'; 67 } else { 68 int length = strlen(other); 69 m_data = new char[length + 1]; 70 strcpy(m_data, other); 71 } 72 73 return *this; 74 } 75 76 String& String::operator+= (const T::String &other) 77 { 78 char *tmp = m_data; 79 int length = strlen(m_data) + strlen(other.m_data); 80 81 m_data = new char[length + 1]; 82 strcpy(m_data, tmp); 83 strcat(m_data, other.m_data); 84 85 delete [] tmp; 86 87 return *this; 88 } 89 90 String String::operator+ (const T::String &other) const 91 { 92 String result; 93 94 result += *this; 95 result += other; 96 97 return result; 98 } 99 100 String& String::operator+= (const char *other) 101 { 102 String tmp(other); 103 104 *this += tmp; 105 106 return *this; 107 } 108 109 String String::operator+ (const char *other) const 110 { 111 String result = *this; 112 113 result += other; 114 115 return result; 116 } 117 118 } // end of namespace T
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "TString.hpp" 10 11 #include <iostream> 12 using namespace std; 13 14 using namespace T; 15 16 int main () 17 { 18 String s1("hello "); 19 20 String s2 = s1; 21 22 String s3 = "world "; 23 24 cout << "s1 = " << s1.data() << "\n" << endl; 25 26 cout << "s2 = " << s2.data() << "\n" << endl; 27 28 cout << "s3 = " << s3.data() << "\n" << endl; 29 30 // String& operator= (const char *); 31 s1 = "hello world "; 32 33 cout << "s1 = " << s1.data() << "\n" << endl; 34 35 // String& operator= (const String &); 36 s3 = s1; 37 38 cout << "s3 = " << s3.data() << "\n" << endl; 39 40 // String& operator+= (const String &); 41 s1 += s3; 42 43 cout << "s1 = " << s1.data() << "\n" << endl; 44 45 // String& operator+= (const char *); 46 s3 += "!"; 47 48 cout << "s3 = " << s3.data() << "\n" << endl; 49 50 // String operator+ (const String &) const; 51 String s4 = s1 + s2; 52 53 cout << "s4 = " << s4.data() << "\n" << endl; 54 55 // String operator+ (const char *) const; 56 s4 = s1 + "hello "; 57 58 cout << "s4 = " << s4.data() << "\n" << endl; 59 60 return 0; 61 }
s1 = hello s2 = hello s3 = world s1 = hello world s3 = hello world s1 = hello world hello world s3 = hello world ! s4 = hello world hello world hello s4 = hello world hello world hello Program ended with exit code: 0
继承
- C++中继承有三种方式：公有继承，私有继承，多重继承（保护继承比较少见）
- 统一建模语言_百度百科
- https://baike.baidu.com/item/统一建模语言/3160571?fromtitle=UML&fromid=446747
- Download Astah Products | Astah.net在构造一个子类时，完成其父类部分的构造由父类的构造函数完成。
- http://astah.net/download
- 子类与父类的构造析构顺序：先构造父类，后构造子类；先析构子类，后析构父类。
- 下例演示了公有继承，以及如何构造子类
1 // 2 // Animal.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/29. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef Animal_hpp 10 #define Animal_hpp 11 12 #include <string> 13 using namespace std; 14 15 namespace T 16 { 17 class Animal 18 { 19 public: 20 Animal(int age, string location); 21 ~Animal(); 22 23 void setAge(int age); 24 int getAge() const; 25 26 string getLocation() const; 27 28 protected: 29 void setLocation(string location); 30 31 string m_location; 32 33 private: 34 int m_age; 35 }; 36 37 class Cat : public Animal 38 { 39 public: 40 Cat(int age, int color, string location); 41 ~Cat(); 42 43 int getColor() const; 44 void setColor(int color); 45 46 void setCatLocation(string location); 47 48 private: 49 int m_color; 50 }; 51 52 class Dog : public Animal 53 { 54 public: 55 Dog(int age, int weight, string location); 56 ~Dog(); 57 58 int getWeight() const; 59 void setWeight(int weight); 60 61 private: 62 int m_weight; 63 }; 64 } 65 66 #endif /* Animal_hpp */
1 // 2 // Animal.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/29. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Animal.hpp" 10 11 #include <iostream> 12 using namespace std; 13 14 namespace T 15 { 16 Animal::Animal(int age, string location) 17 : m_age(age), m_location(location) 18 { 19 cout << "Animal constructing --->\n" << endl; 20 } 21 22 Animal::~Animal() 23 { 24 cout << "Animal destructing --->\n" << endl; 25 } 26 27 int Animal::getAge() const 28 { 29 return m_age; 30 } 31 32 void Animal::setAge(int age) 33 { 34 m_age = age; 35 } 36 37 string Animal::getLocation() const 38 { 39 return m_location; 40 } 41 42 void Animal::setLocation(string location) 43 { 44 cout << __func__ << " --->\n" << endl; 45 } 46 47 Cat::Cat(int age, int color, string location) 48 : Animal(age, location), m_color(color) 49 { 50 cout << "Cat constructing --->\n" << endl; 51 } 52 53 Cat::~Cat() 54 { 55 cout << "Cat destructing --->\n" << endl; 56 } 57 58 int Cat::getColor() const 59 { 60 return m_color; 61 } 62 63 void Cat::setColor(int color) 64 { 65 m_color = color; 66 } 67 68 void Cat::setCatLocation(string location) 69 { 70 Animal::setLocation(location); 71 } 72 73 Dog::Dog(int age, int weight, string location) 74 : Animal(age, location), m_weight(weight) 75 { 76 cout << "Dog constructing --->\n" << endl; 77 } 78 79 Dog::~Dog() 80 { 81 cout << "Dog destructing --->\n" << endl; 82 } 83 84 int Dog::getWeight() const 85 { 86 return m_weight; 87 } 88 89 void Dog::setWeight(int weight) 90 { 91 m_weight = weight; 92 } 93 94 } // end of namespace T
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Animal.hpp" 10 11 using namespace T; 12 13 int main () 14 { 15 { 16 Cat cat(1, 1, "house"); 17 cat.setAge(2); 18 cat.setColor(2); 19 20 cat.setCatLocation("apartment"); 21 } 22 23 { 24 Dog dog(2, 2, "home"); 25 dog.setAge(3); 26 dog.setWeight(3); 27 } 28 29 return 0; 30 }
Animal constructing ---> Cat constructing ---> setLocation ---> Cat destructing ---> Animal destructing ---> Animal constructing ---> Dog constructing ---> Dog destructing ---> Animal destructing ---> Program ended with exit code: 0
- 不一样继承方式的影响主要体如今
- 派生类成员对基类成员的访问权限
- 经过派生类对象对基类成员的访问权限
- 里氏代换原则_百度百科
- https://baike.baidu.com/item/里氏代换原则
- 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类能够出现的地方，子类必定能够出现。 LSP是继承复用的基石，只有当衍生类能够替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也可以在基类的基础上增长新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，因此里氏代换原则是对实现抽象化的具体步骤的规范。
- 在进行设计的时候，尽可能从抽象类继承，而不是从具体类继承。若是从继承等级树来看，全部叶子节点应当是具体类，而全部的树枝节点应当是抽象类或者接口。固然这个只是一个通常性的指导原则，使用的时候还要具体状况具体分析。
- 简单的理解为一个软件实体若是使用的是一个父类，那么必定适用于其子类，并且它察觉不出父类对象和子类对象的区别。也就是说，软件里面，把父类都替换成它的子类，程序的行为没有变化。
- 开闭原则_百度百科
- 公有继承（public）
- 基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。
- 派生类中的成员函数能够直接访问基类中的public和protected成员，但不能直接访问基类的private成员。
- 经过派生类对象只能访问基类的public成员。
- 私有继承（private）
- 基类的public和protected成员都以private身份出如今派生类中，但基类的private成员不可直接访问。
- 派生类中的成员函数能够直接访问基类中的public和protected成员，但不能直接访问基类的private成员。
- 经过派生类的对象不能直接访问基类中的任何成员。
- 多重继承
- 能够为一个派生类指定多个基类，这样的继承结构称为多重继承或多继承
- Java/C#中没有多继承，C++中也应避免使用
- 当两个父类有一样的成员时会带来模糊性，这样致使了名称冲突(name collision)，在编译时将予以拒绝，也称之为菱形继承
- 能够在方法前说明基类，或者用虚继承来解决菱形继承问题
- 虚继承 - 维基百科，自由的百科全书
- https://zh.wikipedia.org/wiki/虚继承
- 虚继承 是面向对象编程中的一种技术，是指一个指定的基类，在继承体系结构中，将其成员数据实例共享给也从这个基类型直接或间接派生的其它类。
- 举例来讲：假如类A和类B各自从类X派生（非虚继承且假设类X包含一些数据成员），且类C同时多继承自类A和B，那么C的对象就会拥有两套X的实例数据（可分别独立访问，通常要用适当的消歧义限定符）。可是若是类A与B各自虚继承了类X，那么C的对象就只包含一套类X的实例数据。对于这一律念典型实现的编程语言是C++。
- 这一特性在多重继承应用中很是有用，可使得虚基类对于由它直接或间接派生的类来讲，拥有一个共同的基类对象实例。避免因为带有歧义的组合而产生的问题（如“菱形继承问题”）。其原理是，间接派生类（C）穿透了其父类（上面例子中的A与B），实质上直接继承了虚基类X。
- 这一律念通常用于“继承”在表现为一个总体，而非几个部分的组合时。在C++中，基类能够经过使用关键字virtual来声明虚继承关系。
- 构造对象的规则须要扩展以控制多重继承。构造函数按下列顺序被调用：
- 任何虚拟基类的构造函数按照它们被继承的顺序调用。
- 任何非虚拟基类的构造函数按照它们被继承的顺序调用。
- 任何成员对象的构造函数按照它们声明的顺序调用。
- 再调用类本身的构造函数
- 下例演示了虚继承以及多重继承的使用。注意使用了虚继承以后类的size大小的不一样。
- 虚函数、虚继承对sizeof的影响 - CSDN博客
- http://blog.csdn.net/acb0y/article/details/8822983
- 虚函数、虚继承对sizeof的影响 - CSDN博客
1 // 2 // Furniture.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/31. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef Furniture_hpp 10 #define Furniture_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 class Furniture 16 { 17 public: 18 Furniture(int weight = 0) 19 : m_weight(weight) 20 { 21 cout << "Furniture constructing --->\n" << endl; 22 } 23 24 void setWeight(int weight) 25 { 26 m_weight = weight; 27 } 28 29 int getWeight() const 30 { 31 return m_weight; 32 } 33 34 private: 35 int m_weight; 36 }; 37 38 // Two classes virtually inheriting Furniture 39 class Sofa : public virtual Furniture 40 { 41 public: 42 Sofa(int weight = 0); 43 44 void watchTV() 45 { 46 cout << __func__ << "\n" << endl; 47 } 48 }; 49 50 class Bed : public virtual Furniture 51 { 52 public: 53 Bed(int weight = 0); 54 55 void sleep() 56 { 57 cout << __func__ << "\n" << endl; 58 } 59 }; 60 61 // 多重继承 62 class SofaBed : public Sofa, public Bed 63 { 64 public: 65 SofaBed(); 66 67 void foldout() 68 { 69 cout << __func__ << "\n" << endl; 70 } 71 }; 72 73 #endif /* Furniture_hpp */
1 // 2 // Furniture.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/31. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Furniture.hpp" 10 11 // Should not set weight = 0, or else ERROR Redefinition of default argument 12 Sofa::Sofa(int weight) 13 : Furniture(weight) 14 { 15 cout << "Sofa constructing --->\n" << endl; 16 } 17 18 Bed::Bed(int weight) 19 : Furniture(weight) 20 { 21 cout << "Bed constructing --->\n" << endl; 22 } 23 24 SofaBed::SofaBed() 25 { 26 cout << "SofaBed constructing --->\n" << endl; 27 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Furniture.hpp" 10 11 int main () 12 { 13 Furniture furniture; 14 Sofa sofa; 15 Bed bed; 16 SofaBed sofabed; 17 18 cout << "sizeof(Furniture) : " << sizeof(Furniture) << "\n" << endl; 19 cout << "sizeof(Sofa) : " << sizeof(Sofa) << "\n" << endl; 20 cout << "sizeof(Bed) : " << sizeof(Bed) << "\n" << endl; 21 cout << "sizeof(SofaBed) : " << sizeof(SofaBed) << "\n" << endl; 22 23 sofabed.watchTV(); 24 25 sofabed.sleep(); 26 27 sofabed.foldout(); 28 29 return 0; 30 }
Furniture constructing ---> Furniture constructing ---> Sofa constructing ---> Furniture constructing ---> Bed constructing ---> Furniture constructing ---> Sofa constructing ---> Bed constructing ---> SofaBed constructing ---> sizeof(Furniture) : 4 sizeof(Sofa) : 16 sizeof(Bed) : 16 sizeof(SofaBed) : 24 watchTV sleep foldout Program ended with exit code: 0
- 下例演示了继承与组合，优先使用组合而不是继承。
1 // 2 // Car.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/3. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef Car_hpp 10 #define Car_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 namespace T { 16 17 class Engine { 18 public: 19 Engine(int id) 20 : m_id(id) 21 { 22 cout << "Engine constructing\n" << endl; 23 } 24 25 ~Engine() 26 { 27 cout << "Engine destructing\n" << endl; 28 } 29 30 void start() 31 { 32 cout << "Engine start\n" << endl; 33 } 34 35 void stop() 36 { 37 cout << "Engine stop\n" << endl; 38 } 39 40 private: 41 int m_id; 42 }; 43 44 class Wheel { 45 public: 46 Wheel(int id) 47 : m_id(id) 48 { 49 cout << "Wheel constructing\n" << endl; 50 } 51 52 ~Wheel() 53 { 54 cout << "Wheel destructing\n" << endl; 55 } 56 57 void roll() 58 { 59 cout << "Wheel rolling\n" << endl; 60 } 61 62 private: 63 int m_id; 64 }; 65 66 // class Car : public Engine, public Wheel // 避免使用多继承 67 class Car { 68 public: 69 Car(Engine *, Wheel *, string, int); 70 71 ~Car() 72 { 73 cout << "Car destructing\n" << endl; 74 }; 75 76 void run(); 77 void stop(); 78 79 private: 80 Car(const Car&); 81 Car& operator= (const Car&); 82 83 Engine *m_engine; 84 Wheel *m_wheel; 85 string m_name; 86 int m_price; 87 }; 88 89 class Stero { 90 public: 91 Stero() 92 { 93 cout << "Stero constructing\n" << endl; 94 } 95 96 ~Stero() 97 { 98 cout << "Stero destructing\n" << endl; 99 } 100 101 void play() 102 { 103 cout << "Stero playing\n" << endl; 104 } 105 }; 106 107 class Benchi : public Car { 108 public: 109 Benchi(Engine *, Wheel *, string, int, Stero *); 110 111 ~Benchi() 112 { 113 cout << "Benchi destructing\n" << endl; 114 } 115 116 void musicOn(); 117 118 private: 119 Stero *m_stero; 120 }; 121 122 class Transformer : public Car { 123 public: 124 Transformer(Engine *, Wheel *, string, int, bool); 125 126 ~Transformer() 127 { 128 cout << "Transformer destructing\n" << endl; 129 } 130 131 void fight(); 132 void transform(); 133 134 private: 135 bool m_val; 136 }; 137 138 } 139 140 #endif /* Car_hpp */
1 // 2 // Car.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/3. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #include "Car.hpp" 10 11 namespace T { 12 Car::Car(Engine *e, Wheel *w, string name, int price) 13 : m_engine(e), m_wheel(w), m_name(name), m_price(price) 14 { 15 cout << "Car constructing\n" << endl; 16 } 17 18 void Car::run() 19 { 20 m_engine->start(); 21 m_wheel->roll(); 22 23 cout << "Car running\n" << endl; 24 } 25 26 void Car::stop() 27 { 28 m_engine->stop(); 29 30 cout << "Car stopping\n" << endl; 31 } 32 33 Benchi::Benchi(Engine *e, Wheel *w, string name, int price, Stero *st) 34 : Car(e, w, name, price), m_stero(st) 35 { 36 cout << "Benchi constructing\n" << endl; 37 } 38 39 void Benchi::musicOn() 40 { 41 Car::run(); 42 m_stero->play(); 43 44 cout << "Music on\n" << endl; 45 } 46 47 Transformer::Transformer(Engine *e, Wheel *w, string name, int price, bool val) 48 :Car(e, w, name, price), m_val(val) 49 { 50 cout << "Transformer constructing\n" << endl; 51 } 52 53 void Transformer::fight() 54 { 55 run(); 56 57 cout << "Transformer fight\n" << endl; 58 } 59 60 void Transformer::transform() 61 { 62 run(); 63 64 cout << "Transformer transform\n" << endl; 65 } 66 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Car.hpp" 10 using namespace T; 11 12 int main () 13 { 14 Engine e1(1); 15 Wheel w1(1); 16 Stero stero; 17 Benchi benchi(&e1, &w1, "benchi", 100, &stero); 18 19 benchi.musicOn(); 20 21 Transformer t(&e1, &w1, "optimusprime", 200, true); 22 23 t.transform(); 24 t.fight(); 25 26 return 0; 27 }
Engine constructing Wheel constructing Stero constructing Car constructing Benchi constructing Engine start Wheel rolling Car running Stero playing Music on Car constructing Transformer constructing Engine start Wheel rolling Car running Transformer transform Engine start Wheel rolling Car running Transformer fight Transformer destructing Car destructing Benchi destructing Car destructing Stero destructing Wheel destructing Engine destructing Program ended with exit code: 0
多态
- 多态性是指“多种行为”
- 一样的方法调用而执行不一样操做、运行不一样代码
- 多态经过分离作什么和怎么作，从另外一个角度将接口和实现进行分离
- “封装”经过合并特征和行为来建立新的数据类型
- “实现隐藏”经过将细节“私有化”把接口和实现进行分离
- “多态”则消除了类型之间的耦合关系
- LSP（Liskov替换原则）：子类型必须可以替换掉它的基类型
- 多态的概念基于对象引用的动态绑定特性，动态绑定是多态现象的根源
- 多态实现过程
- 子类重写父类的方法
- 代码中向父类型变量发出消息（静态绑定）
- 运行时，根据变量实际引用的对象类型决定调用哪一个方法（动态绑定）
- 静态绑定在编译器进行
- 动态绑定在运行期进行
- 虚函数与抽象类
- 虚函数 - 维基百科，自由的百科全书
- https://zh.wikipedia.org/wiki/虚函数_(程序语言)
- 虚函数是面向对象程序设计中的一个重要的概念。只能适用于指针和参考的计算机工程运算。当从父类中继承的时候，虚函数和被继承的函数具备相同的签名。可是在运行过程当中，运行系统将根据对象的类型，自动地选择适当的具体实现运行。虚函数是面向对象编程实现多态的基本手段。
- 虚函数在设计模式方面扮演重要角色。例如，《设计模式》一书中提到的23种设计模式中，仅5个对象建立模式就有4个用到了虚函数（抽象工厂、工厂方法、生成器、原型），只有单例没有用到。
- 在Java语言中, 全部的方法默认都是"虚函数". 只有以关键字 final 标记的方法才是非虚函数.
- 在 C# 语言中, 对基类中的任何虚方法必须用 virtual 修饰, 而派生类中由基类继承而来的重载方法必须用 override 修饰.
- 纯虚函数或纯虚方法是一个须要被非抽象的派生类覆盖（override）的虚函数. 包含纯虚方法的类被称做抽象类; 抽象类不能被直接实例化。 一个抽象基类的一个子类只有在全部的纯虚函数在该类(或其父类)内给出实现时, 才能直接实例化. 纯虚方法一般只有声明(签名)而没有定义(实现)，但有特例情形要求纯虚函数必须给出函数体定义.
- 做为一个例子, 抽象基类"MathSymbol"可能提供一个纯虚函数 doOperation(), 和派生类 "Plus" 和 "Minus" 提供doOperation() 的具体实现. 因为 "MathSymbol" 是一个抽象概念, 为其每一个子类定义了同一的动做, 在 "MathSymbol" 类中执行 doOperation() 没有任何意义. 相似的, 一个给定的 "MathSymbol" 子类若是没有 doOperation() 的具体实现是不彻底的.
- 虽然纯虚方法一般在定义它的类中没有实现, 在 C++ 语言中, 容许纯虚函数在定义它的类中包含其实现, 这为派生类提供了备用或默认的行为. C++的虚基类的虚析构函数必须提供函数体定义，不然连接时（linking）在析构该抽象类的派生实例对象的语句处会报错。
- 在C++语言中, 纯虚函数用一种特别的语法[=0]定义（但 VS 也支持 abstract 关键字：virtual ReturnType Function()abstract;）
- 纯虚函数的定义仅提供方法的原型. 虽然在抽象类中一般不提供纯虚函数的实现, 可是抽象类中能够包含其实现, 并且能够不在声明的同时给出定义[2]. 每一个非抽象子类仍然须要重载该方法
- 抽象类_百度百科
- https://baike.baidu.com/item/抽象类
-
抽象类每每用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不一样，可是本质上相同的具体概念的抽象。一般在编程语句中用 abstract 修饰的类是抽象类。在C++中，含有纯虚拟函数的类称为抽象类，它不能生成对象；在java中，含有抽象方法的类称为抽象类，一样不能生成对象。抽象类是不完整的，它只能用做基类。在 面向对象方法中，抽象类主要用来进行类型隐藏和充当全局变量的角色。
- 与具体类比较
- 抽象类不能直接实例化，而且对抽象类使用new运算符会致使编译时错误。虽然一些变量和值在编译时的类型能够是抽象的，可是这样的变量和值必须或者为null，或者含有对非抽象类的实例的引用（此非抽象类是从抽象类派生的）
- 容许（但不要求）抽象类包含抽象成员。
- 抽象类不能被密封。
- 与接口比较
- 抽象类表示该类中可能已经有一些方法的具体定义，可是接口就仅仅只能定义各个方法的界面（方法名，参数列表，返回类型），并不关心具体细节。
- 接口是引用类型的，和抽象类的类似之处有三点：
- 不能实例化；
- 包含未实现的方法声明；
- 派生类必须实现未实现的方法，抽象类是抽象方法，接口则是全部成员（不只是方法包括其余成员）。
- 抽象类与接口紧密相关。然而接口又比抽象类更抽象，这主要体如今它们的差异上：
- 类能够实现无限个接口，但仅能从一个抽象（或任何其余类型）类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。
- 抽象类当中能够存在非抽象的方法，可接口不能，且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。
- 抽象类中的成员变量能够被不一样的修饰符来修饰，可接口中的成员变量默认的都是静态常量（static final）。
- 抽象类是对象的抽象，然而接口是一种行为规范。
- 标准c++没有abstract关键字，代之使用纯虚类实现相似的功能，详见词条“虚类”。在实现接口时，常写一个抽象类，来实现接口中的某些子类所需的通用方法，接着在编写各个子类时，便可继承该抽象类来使用，省去在每一个都要实现通用的方法的困扰。
-
为了让一个类成为抽象类，至少必须有一个纯虚函数。包含至少一个纯虚函数的类视为抽象类。将函数初始化为0使它们成为纯虚函数，没有0这个初使化器，它们仅仅是虚函数。
- 抽象类对于提供模式、蓝图和后代类遵循的原则有用，若是遵循了蓝图的语义，后代类的行为可能按抽象类提供者和使用者所指望的那样。
- 经过使用抽象类，C++程序员能够提供C++组件的规范，在它的构建中指导组件的实现者。
- 在面向对象方法中，抽象类主要用来进行类型隐藏。构造出一个固定的一组行为的抽象描述，可是这组行为却可以有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为全部可能的派生类。模块能够操做一个抽象体。因为模块依赖于一个固定的抽象体，所以它能够是不容许修改的；同时，经过从这个抽象体派生，也可扩展此模块的行为功能。为了可以实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。
- 虚类_百度百科
- https://baike.baidu.com/item/虚类
- 含有虚函数的类是虚类，虚函数用关键字virtual声明。
- 虚函数代表只有在程序使用到该函数时，才得到与调用对象对应的该函数的实现。
- 含有纯虚函数的类是纯虚类，更多的是叫抽象类。纯虚类能够有成员变量。纯虚类不能实例化。
- 虚函数必须是基类的非静态成员函数，其访问权限能够是protected或public
- 虚函数的做用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数。
- 纯虚函数没有函数体。
- c++虚类至关与java里面的抽象类，与接口的不一样之处以下：
- 一、一个子类只能继承一个抽象类（虚类），但能实现多个接口；
- 二、一个抽象类能够有构造方法，接口没有构造方法；
- 三、一个抽象类中的方法不必定是抽象方法，即其中的方法能够有实现（有方法体），接口中的方法是抽象方法，不能有方法体，只有声明；
- 四、一个抽象类能够是public、private、protected、default, 接口只有public和default；
- 五、一个抽象类中的方法能够是public、private、protected、default， 接口中的方法只能是public。
- 相同之处：都不能实例化。
- 纯虚函数与接口类
- 纯虚函数_百度百科
- https://baike.baidu.com/item/纯虚函数
- 纯虚函数是一种特殊的虚函数，在许多状况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去作。这就是纯虚函数的做用。
- 纯虚函数可让类先具备一个操做名称，而没有操做内容，让派生类在继承时再去具体地给出定义。凡是含有纯虚函数的类叫作抽象类。这种类不能声明对象，只是做为基类为派生类服务。除非在派生类中彻底实现基类中全部的的纯虚函数，不然，派生类也变成了抽象类，不能实例化对象。
- 通常而言纯虚函数的函数体是缺省的，可是也能够给出纯虚函数的函数体（此时纯虚函数变为虚函数），这一点常常被人们忽视，调用纯虚函数的方法为baseclass::virtual function.
- 多态性：指相同对象收到不一样消息或不一样对象收到相同消息时产生不一样的实现动做。C++支持两种多态性：编译时多态性，运行时多态性。
- a.编译时多态性：经过重载函数和运算符重载实现。
- b运行时多态性：经过虚函数和继承实现。
- 虚函数：虚函数是在基类中被声明为virtual，并在派生类中从新定义的成员函数，可实现成员函数的动态重载
- 抽象类：包含纯虚函数的类称为抽象类。因为抽象类包含了没有定义的纯虚函数，因此不能定义抽象类的对象。
- 接口（软件接口）_百度百科
- https://baike.baidu.com/item/接口/15422203#viewPageContent
- 接口（软件类接口）是指对协定进行定义的引用类型。其余类型实现接口，以保证它们支持某些操做。接口指定必须由类提供的成员或实现它的其余接口。与类类似，接口能够包含方法、属性、索引器和事件做为成员。
- 面向对象的接口
- 在C++中，一个类被容许继承多个类。可是在Java之后的语言不被容许。这样，若是想继承多个类时便很是困难。因此开发方想出了新办法：接口。一个接口内，容许包含变量、常量等一个类所包含的基本内容。可是，接口中的函数不容许设定代码，也就意味着不能把程序入口放到接口里。由上能够理解到，接口是专门被继承的。接口存在的意义也是被继承。和C++里的抽象类里的纯虚函数是相同的。不能被实例化。
- 接口类不能实例化，不能生成对象实例
- 必须为多态基类声明virtual析构函数，不然用基类指针定义的派生类对象，在析构时只会调用基类析构函数，而不会调用派生类析构函数，从而形成内存泄漏。
- 针对接口编程，而不是针对实现编程。
- 下例演示了多态以及虚函数，虚析构函数的使用
1 // 2 // Animal.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/4. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef Animal_hpp 10 #define Animal_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 namespace T 16 { 17 class Animal 18 { 19 public: 20 Animal() 21 { 22 cout << "Animal constructing\n" << endl; 23 24 } 25 26 // 为基类声明虚析构函数 27 virtual ~Animal() 28 { 29 cout << "Animal destructing\n" << endl; 30 } 31 32 // Need to add "const" to avoid error Member function 'makeSound' not viable: 'this' argument has type 'const T::Animal', but function is not marked const 33 void makeSound() const 34 { 35 cout << "Animal make sound\n" << endl; 36 } 37 38 // "virtual" 只须要在声明时加上，不须要在定义时加上 39 virtual void smile() const; 40 41 /* 42 virtual void smile() const = 0; // pure virtual function 43 */ 44 45 /* 46 virtual void smile() const 47 { 48 cout << "Animal smile\n" << endl; 49 } 50 */ 51 }; 52 53 class Dog : public Animal 54 { 55 public: 56 Dog() 57 { 58 cout << "Dog constructing\n" << endl; 59 } 60 61 ~Dog() 62 { 63 cout << "Dog destructing\n" << endl; 64 } 65 66 void makeSound() const 67 { 68 cout << "Dog make sound\n" << endl; 69 } 70 71 void smile() const 72 { 73 cout << "Dog smile\n" << endl; 74 } 75 }; 76 77 class Cat : public Animal 78 { 79 public: 80 Cat() 81 { 82 cout << "Cat constructing\n" << endl; 83 } 84 85 ~Cat() 86 { 87 cout << "Cat destructing\n" << endl; 88 } 89 90 void makeSound() const 91 { 92 cout << "Cat make sound\n" << endl; 93 } 94 95 void smile() const 96 { 97 cout << "Cat smile\n" << endl; 98 } 99 }; 100 } 101 102 #endif /* Animal_hpp */
1 // 2 // Animal.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/4. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #include "Animal.hpp" 10 11 // "virtual" 只须要在声明时加上，不须要在定义时加上 12 void T::Animal::smile() const 13 { 14 cout << "Animal smile\n" << endl; 15 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Animal.hpp" 10 using namespace T; 11 12 void func(const Animal & animal) 13 { 14 cout << "Pass by reference ---> \n" << endl; 15 16 animal.makeSound(); 17 animal.smile(); 18 } 19 20 void foo(Animal * pAnimal) 21 { 22 cout << "Pass by pointer ---> \n" << endl; 23 24 pAnimal->makeSound(); 25 pAnimal->smile(); 26 } 27 28 void bar(Animal animal) 29 { 30 cout << "Pass by value ---> \n" << endl; 31 32 animal.makeSound(); 33 animal.smile(); 34 } 35 36 int main () 37 { 38 { 39 Dog dog; 40 Cat cat; 41 42 cout << "sizeof(Animal) : " << sizeof(Animal) << "\n" << endl; 43 cout << "sizeof(Dog) : " << sizeof(Dog) << "\n" << endl; 44 cout << "sizeof(Cat) : " << sizeof(Cat) << "\n" << endl; 45 46 func(dog); 47 48 func(cat); 49 50 foo(&dog); 51 52 foo(&cat); 53 54 bar(dog); 55 56 bar(cat); 57 } 58 59 cout << "为多态基类声明虚析构函数 --->\n" << endl; 60 61 { 62 Animal * pCat = new Cat; 63 64 pCat->makeSound(); 65 pCat->smile(); 66 67 foo(pCat); 68 69 // 若是不声明为虚析构函数，则只会调用基类Animal的析构函数，而不会调用派生类Cat的析构函数，形成内存泄漏 70 delete pCat; 71 } 72 73 return 0; 74 }
Animal constructing Dog constructing Animal constructing Cat constructing sizeof(Animal) : 8 sizeof(Dog) : 8 sizeof(Cat) : 8 Pass by reference ---> Animal make sound Dog smile Pass by reference ---> Animal make sound Cat smile Pass by pointer ---> Animal make sound Dog smile Pass by pointer ---> Animal make sound Cat smile Pass by value ---> Animal make sound Animal smile Animal destructing Pass by value ---> Animal make sound Animal smile Animal destructing Cat destructing Animal destructing Dog destructing Animal destructing 为多态基类声明虚析构函数 ---> Animal constructing Cat constructing Animal make sound Cat smile Pass by pointer ---> Animal make sound Cat smile // 若是不声明为虚析构函数，则只会调用基类Animal的析构函数，而不会调用派生类Cat的析构函数，形成内存泄漏 Cat destructing Animal destructing Program ended with exit code: 0
- 下例笔试题演示了虚函数，虚继承的使用
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "iostream" 10 using namespace std; 11 12 class Base 13 { 14 public: 15 char Value() { return 'A'; } 16 17 virtual char VirtualValue() { return 'X'; } 18 }; 19 20 class Derived : public Base 21 { 22 public: 23 char Value() { return 'U'; } 24 }; 25 26 class VirtualDerived : virtual public Base 27 { 28 public: 29 char Value() { return 'Z'; } 30 31 char VirtualValue() { return 'V'; } 32 }; 33 34 int main () 35 { 36 Base * p1 = new Derived(); 37 38 Base * p2 = new VirtualDerived(); 39 40 cout << p1->Value() << " " << 41 42 p1->VirtualValue() << " " << 43 44 p2->Value() << " " << 45 46 p2->VirtualValue() << " " << endl; 47 48 return 0; 49 }
A X A V Program ended with exit code: 0
类模版
- 模版是泛型编程的基础：经过模版能快速创建具备类型安全的类库集合和函数集合，使用模版操做不一样数据类型，从而避免为每一种数据类型产生一个单独的类或函数。
- 类模版的做用
- 将程序要处理的对象的类型参数化
- 使程序能够处理不一样类型的对象
- 下例演示了模版的使用。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 namespace nsT { 13 template <typename T> 14 15 T min(T a, T b) 16 { 17 return (a < b) ? a : b; 18 } 19 } 20 21 int main () 22 { 23 int a = 10, b = 9; 24 int c = min(a, b); 25 26 cout << c << endl; 27 28 double d = 1.0, e = 2.0; 29 double f = min(d, e); 30 31 cout << f << endl; 32 33 return 0; 34 }
- 下例演示了类模版的使用。
1 // 2 // class_template.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/7. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef class_template_hpp 10 #define class_template_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 namespace nsT { 16 class Test { 17 public: 18 Test() {} 19 20 private: 21 // Error : Calling a private constructor of class 'nsT::Test' 22 /* 23 Test(const Test &); 24 Test& operator= (const Test &); 25 */ 26 }; 27 28 template <typename T> 29 class Example { 30 public: 31 Example(T val) 32 : m_val(val) 33 { 34 cout << "Example constructing\n" << endl; 35 } 36 37 ~Example() 38 { 39 cout << "Example destructing\n" << endl; 40 } 41 42 T get() const 43 { 44 return m_val; 45 } 46 47 void set(T val) 48 { 49 m_val = val; 50 } 51 52 private: 53 T m_val; 54 }; 55 } // end of namespace nsT 56 57 #endif /* class_template_hpp */
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 #include "class_template.hpp" 13 14 using namespace nsT; 15 16 int main () 17 { 18 // Using int as data type 19 Example<int> val(1); 20 21 int data = val.get(); 22 23 cout << "data = " << data << "\n" << endl; 24 25 // Using double as data type 26 Example<double> val2(2.0); 27 28 cout << val2.get() << "\n" << endl; 29 30 Test test; 31 32 // Using class as data type 33 Example<Test> val3(test); 34 35 return 0; 36 }
- 类模版与模版类的区别
- 类模版是模版的定义，不是一个实实在在的类，定义中用到通用类型参数。
- 模版类是实实在在的类定义，是类模版的实例化。类定义中参数被实际类型所代替。
- 下例演示了用类模版来定义一个通用堆栈，此时该通用堆栈还不是一个类定义，只是类定义的一个框架，即类模版。
1 // 2 // Stack.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/8. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef Stack_hpp 10 #define Stack_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 namespace nsT { 16 template<typename T> class StackIterator; // 前置声明 17 18 template<typename T> 19 class Stack 20 { 21 public: 22 Stack() 23 : m_top(0) 24 { 25 cout << "Stack constructing\n" << endl; 26 27 m_array[0] = T(); 28 } 29 30 ~Stack() 31 { 32 cout << "Stack destructing\n" << endl; 33 } 34 35 int size() const 36 { 37 return m_top; 38 } 39 40 void push(const T&); 41 T pop(); 42 friend class StackIterator<T>; // 友元类 43 44 private: 45 enum { SIZE = 100 }; 46 T m_array[SIZE]; 47 int m_top; 48 }; 49 50 template<typename T> 51 void Stack<T>::push(const T& val) 52 { 53 if (m_top < SIZE) { 54 m_array[m_top ++] = val; 55 } 56 } 57 58 template<typename T> 59 T Stack<T>::pop() 60 { 61 if (m_top > 0) 62 return m_array[-- m_top]; 63 else 64 return m_array[0]; 65 } 66 67 template<typename T> 68 class StackIterator { 69 public: 70 StackIterator(Stack<T>& val) 71 : m_stack(val), m_index(0) 72 { 73 cout << "StackIterator constructing\n" << endl; 74 } 75 76 ~StackIterator() 77 { 78 cout << "StackIterator destructing\n" << endl; 79 } 80 81 T& operator++ (int) // post 82 { 83 int ret = m_index; 84 85 if (m_index < m_stack.m_top - 1) 86 m_index ++; 87 88 return m_stack.m_array[ret]; 89 } 90 91 private: 92 Stack<T>& m_stack; 93 int m_index; 94 }; 95 } 96 #endif /* Stack_hpp */
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 using namespace std; 11 12 #include "Stack.hpp" 13 14 using namespace nsT; 15 16 int main () 17 { 18 Stack<int> stack; 19 20 stack.push(1); 21 stack.push(2); 22 stack.push(3); 23 24 auto size = stack.size(); 25 26 cout << "size of stack : " << size << "\n" << endl; 27 28 StackIterator<int> iter(stack); 29 30 for (auto i = 0; i < size; i ++) 31 cout << iter ++ << "\n" << endl; 32 33 cout << "pop : " << stack.pop() << "\n" << endl; 34 35 return 0; 36 }
STL
- 将算法从特定的数据结构中抽象出来
- C++的模版为泛型程序设计奠基了关键的基础
- STL是泛型程序设计的一个范例，由一些可适应不一样需求的集合类以及在这些数据集合上操做的算法构成
- STL（模板库）_百度百科
- https://baike.baidu.com/item/STL/70103?fr=aladdin
- 容器的类别
- 序列式容器：排列次序取决于插入时机和位置
- 关联式容器：排列顺序取决于特定准则（平衡二叉树）
- 向量（vector）属于序列式容器，用于容纳不定长的线性序列，提供对序列的快速随机访问（直接访问）。
- 向量是动态结构，模拟动态数组，它的大小不固定，能够在程序运行时增长或减小。
- vector的元素能够是任意类型，但必须具有赋值和拷贝能力，具备public的拷贝构造函数和重载的赋值运算符。
- vector的大小（size）和容量（capacity）一般是不一样的，capacity返回vector实际能容纳的元素数量。若是超过这个数量须要从新配置内部存储器。
- vector（Java与C++语言中的对象）_百度百科
- https://baike.baidu.com/item/vector/3330482?fr=aladdin
- 下例演示了vector的使用
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <vector> 11 using namespace std; 12 13 int main() 14 { 15 vector<int> coll; 16 17 cout << "capacity : " << coll.capacity() << "\n" << endl; 18 cout << "size : " << coll.size() << "\n" << endl; 19 20 for (auto i = 0; i < 10; i ++) 21 coll.push_back(i); 22 23 cout << "capacity : " << coll.capacity() << "\n" << endl; 24 cout << "size : " << coll.size() << "\n" << endl; 25 26 cout << coll[9] << endl; 27 28 return 0; 29 }
capacity : 0 size : 0 capacity : 16 size : 10 9 Program ended with exit code: 0
- 迭代器是面向对象版本的指针
- 指针能够指向内存中的一个地址
- 迭代器能够指向容器中的一个位置，用来遍历STL容器的所有或部分元素
- STL中的每个容器类模版中，都定义了一组对应的迭代器类。
- 因此容器都提供两种迭代器
- Container::iterator以“读写”模式遍历元素
- Container::const_iterator以“只读”模式遍历元素
- 由end操做返回的迭代指向vector的“末端元素的下一个”。一般称为超出末端迭代器（off-the-end iterator）。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <vector> 11 using namespace std; 12 13 void print_array(const vector<int> & array) 14 { 15 vector<int>::const_iterator iter; 16 17 cout << "array["; 18 19 for (iter = array.begin(); iter != array.end(); ++ iter) 20 cout << *iter << " , "; 21 22 cout << "]\n" << endl; 23 } 24 25 int main() 26 { 27 vector<int> array; 28 vector<int>::iterator iter; 29 vector<int>::const_iterator citer; 30 31 array.push_back(42); 32 array.push_back(1); 33 array.push_back(100); 34 35 array.pop_back(); 36 37 iter = array.begin(); 38 39 cout << *iter << "\n" << endl; 40 41 *iter = 109; 42 43 citer = array.begin(); 44 45 cout << *citer << "\n" << endl; 46 47 // *citer = 20; // Error : Cannot assign to return value because function 'operator*' returns a const value 48 49 print_array(array); 50 51 return 0; 52 }
42 109 array[109 , 1 , ] Program ended with exit code: 0
- STL中的排序算法sort模版有两种：一种以升序排列，另外一种用自定义的_compare函数代替operator<(x,y)。
- 下例演示了sort函数的使用。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <vector> 11 using namespace std; 12 13 bool compare(const int & a, const int & b) 14 { 15 return a > b; 16 } 17 18 void print_array(const vector<int> & array) 19 { 20 vector<int>::const_iterator iter; 21 22 cout << "array["; 23 24 for (iter = array.begin(); iter != array.end(); ++ iter) 25 cout << *iter << " , "; 26 27 cout << "]\n" << endl; 28 } 29 30 int main() 31 { 32 vector<int> array; 33 vector<int>::iterator iter; 34 vector<int>::const_iterator citer; 35 36 array.push_back(42); 37 array.push_back(1); 38 array.push_back(100); 39 40 print_array(array); 41 42 sort(array.begin(), array.end()); 43 44 cout << "After sort(array.begin(), array.end())\n" << endl; 45 46 print_array(array); 47 48 sort(array.begin(), array.end(), compare); 49 50 cout << "After sort(array.begin(), array.end(), compare)\n" << endl; 51 52 print_array(array); 53 54 return 0; 55 }
array[42 , 1 , 100 , ] After sort(array.begin(), array.end()) array[1 , 42 , 100 , ] After sort(array.begin(), array.end(), compare) array[100 , 42 , 1 , ] Program ended with exit code: 0
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <vector> 11 #include <string> 12 using namespace std; 13 14 class ID 15 { 16 public: 17 ID() : m_name(""), m_score(0) {} 18 ID(string name, int score) : m_name(name), m_score(score){} 19 20 string m_name; 21 int m_score; 22 }; 23 24 bool operator== (const ID & x, const ID & y) 25 { 26 return (x.m_name == y.m_name) && (x.m_score == y.m_score); 27 } 28 29 bool operator< (const ID & x, const ID & y) 30 { 31 return x.m_score < y.m_score; 32 } 33 34 bool compare(const ID & x, const ID & y) 35 { 36 return x.m_score > y.m_score; 37 } 38 39 int main() 40 { 41 vector<ID> ids; 42 vector<ID>::iterator iter; 43 44 ids.push_back(ID("Tom", 5)); 45 ids.push_back(ID("John", 1)); 46 ids.push_back(ID("Alex", 2)); 47 48 // By default 49 sort(ids.begin(), ids.end()); 50 51 cout << "After sort(ids.begin(), ids.end())\n" << endl; 52 53 for (iter = ids.begin(); iter != ids.end(); ++ iter) 54 { 55 cout << (*iter).m_name << " : " << (*iter).m_score << endl; 56 } 57 58 cout << endl; 59 60 // With compare function 61 sort(ids.begin(), ids.end(), compare); 62 63 cout << "After sort(ids.begin(), ids.end(), compare)\n" << endl; 64 65 for (iter = ids.begin(); iter != ids.end(); ++ iter) 66 { 67 cout << (*iter).m_name << " : " << (*iter).m_score << endl; 68 } 69 70 return 0; 71 }
After sort(ids.begin(), ids.end()) John : 1 Alex : 2 Tom : 5 After sort(ids.begin(), ids.end(), compare) Tom : 5 Alex : 2 John : 1 Program ended with exit code: 0
- 列表list使用双向链表管理元素
- List的元素能够是任意类型，但必须具有赋值和拷贝能力
- List不支持随机存取，不提供下表操做符
- 在任何位置上指向元素的插入和删除效率高
- list - C++ Reference
- list是顺序访问的容器
- list也有insert函数，它不会使任何迭代子或引用变得无效。
- 链式结构最大的优势是序列便于重组，插入或删除链表中对象时无需移动其余对象的存储位置。
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <list> 11 using namespace std; 12 13 bool compare(const int & a, const int & b) 14 { 15 return a > b; 16 } 17 18 void show_list(const list<int> & coll) 19 { 20 list<int>::const_iterator citer; 21 22 for (citer = coll.begin(); citer != coll.end(); ++ citer) 23 cout << *citer << endl; 24 } 25 26 int main() 27 { 28 list<int> coll; 29 30 coll.push_back(10); // 10 31 coll.push_back(11); // 10, 11 32 coll.push_front(12); // 12, 10, 11 33 coll.push_front(9); // 9, 12, 10, 11 34 35 list<int>::iterator iter = coll.begin(); // 9 36 37 coll.erase(iter); // 12, 10, 11 38 39 iter ++; // 12 40 41 coll.erase(iter); // 10, 11 42 43 coll.push_back(2); // 10, 11, 2 44 coll.push_back(1); // 10, 11, 2, 1 45 46 // Sort in ascending order 47 coll.sort(); 48 49 cout << "After coll.sort() : \n" << endl; 50 51 show_list(coll); 52 53 cout << endl; 54 55 // Sort in descending order 56 coll.sort(compare); 57 58 cout << "After coll.sort(compare) : \n" << endl; 59 60 show_list(coll); 61 62 return 0; 63 }
After coll.sort() : 1 2 10 11 After coll.sort(compare) : 11 10 2 1 Program ended with exit code: 0
- 集合set与映射map是两种主要的非线性容器类
- 内部实现通常为平衡二叉树（balanced binary tree）
- set - C++ Reference
- http://www.cplusplus.com/reference/set/set/
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <set> 11 using namespace std; 12 13 int main() 14 { 15 set<int> coll; 16 set<int>::iterator iter; 17 18 coll.insert(1); 19 coll.insert(100); 20 coll.insert(90); 21 coll.insert(-1); 22 coll.insert(80); 23 24 for (iter = coll.begin(); iter != coll.end(); ++ iter) { 25 cout << *iter << endl; 26 } 27 28 return 0; 29 }
-1 1 80 90 100 Program ended with exit code: 0
- map是STL的一个关联容器，它提供一对一的数据处理能力，为键值对。
- 其中第一个为关键字key，每一个key只能在map中出现一次
- 第二个为该关键字的值value
- map - C++ Reference
- http://www.cplusplus.com/reference/map/map/
- map数据的插入
- 用insert函数插入pair数据
- 用insert函数插入value_type数据
- 用insert函数插入make_pair数据
- make_pair - C++ Reference
- http://www.cplusplus.com/reference/utility/make_pair/
- make_pair - C++ Reference
- 直接用下标访问赋值
- map的大小：size()函数
- 数据的遍历：迭代器iterator
- unordered_map内部实现使用hash表，效率更高
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include <iostream> 10 #include <map> 11 #include <string> 12 using namespace std; 13 14 class Compare 15 { 16 public: 17 // Overload operator(), must be wtih "const" 18 bool operator() (const int & a, const int & b) const 19 { 20 return a > b; 21 } 22 }; 23 24 int main() 25 { 26 map<int, string> coll; 27 map<int, string>::iterator iter; 28 29 coll.insert(pair<int, string>(9, "Nine")); 30 coll.insert(map<int, string>::value_type(1, "One")); 31 coll.insert(make_pair(2, "Two")); 32 coll[0] = "Zero"; 33 34 cout << "Sort in default ascending order\n" << endl; 35 36 for (iter = coll.begin(); iter != coll.end(); ++ iter) 37 cout << iter->first << " : " << iter->second << endl; 38 39 cout << endl; 40 41 // Sort with overloaded Compare 42 map<int, string, Compare> coll_cmp; 43 map<int, string, Compare>::iterator iter_cmp; 44 45 coll_cmp.insert(pair<int, string>(9, "Nine")); 46 coll_cmp.insert(map<int, string>::value_type(1, "One")); 47 coll_cmp.insert(make_pair(2, "Two")); 48 coll_cmp[0] = "Zero"; 49 50 cout << "Sort in descending order with overloaded Compare operator\n" << endl; 51 52 for (iter_cmp = coll_cmp.begin(); iter_cmp != coll_cmp.end(); ++ iter_cmp) 53 cout << iter_cmp->first << " : " << iter_cmp->second << endl; 54 55 return 0; 56 }
Sort in default ascending order 0 : Zero 1 : One 2 : Two 9 : Nine Sort in descending order with overloaded Compare operator 9 : Nine 2 : Two 1 : One 0 : Zero Program ended with exit code: 0
智能指针
- 使用类模版来管理指针，建立模版类管理指针，实现资源的管理。
- 下例实现了智能指针。注意它不是线程安全的。
- #pragma once_百度百科
- https://baike.baidu.com/item/%23pragma%20once
-
#pragma once是 编译器相关的，有的编译器支持，有的编译器不支持，具体状况请查看编译器API文档，不过如今大部分编译器都有这个杂注了。
-
#ifndef，#define，#endif是C/C++语言中的宏定义，经过宏定义避免文件屡次编译。因此在全部支持C++语言的编译器上都是有效的，若是写的程序要跨平台，最好使用这种方式。
1 // 2 // RefCount.h 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/14. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef RefCount_h 10 #define RefCount_h 11 12 //#pragma once 13 14 #include <stdio.h> 15 16 #define TRACE printf 17 18 class RefCount 19 { 20 public: 21 RefCount(void) 22 { 23 TRACE("RefCount constructing\n\n"); 24 crefs = 0; 25 } 26 27 virtual ~RefCount(void) 28 { 29 TRACE("RefCount destructing\n\n"); 30 } 31 32 void upcount(void) 33 { 34 ++ crefs; 35 TRACE("up to %d\n\n", crefs); 36 } 37 38 void downcount(void) 39 { 40 if (-- crefs == 0) { 41 TRACE("down to %d\n\n", crefs); 42 delete this; 43 } else { 44 TRACE("down to %d\n\n", crefs); 45 } 46 } 47 48 private: 49 int crefs; 50 }; 51 52 class Sample : public RefCount 53 { 54 public: 55 Sample() 56 { 57 TRACE("Sample constructing\n\n"); 58 } 59 60 ~Sample() 61 { 62 TRACE("Sample destructing\n\n"); 63 } 64 65 void doSomething(void) 66 { 67 printf("Did something\n\n"); 68 } 69 }; 70 71 #endif /* RefCount_h */
1 // 2 // SmartPtr.h 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/14. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef SmartPtr_h 10 #define SmartPtr_h 11 12 #include <stdio.h> 13 14 #define TRACE printf 15 16 /* 17 //Compiler switch 18 #ifdef TRACE_SMPTR 19 #define TRACE printf 20 #else 21 #define TRACE 22 #endif 23 */ 24 25 template <typename T> 26 class SmartPtr 27 { 28 public: 29 SmartPtr(T* p_) : m_p(p_) 30 { 31 TRACE("SmartPtr constructing\n\n"); 32 m_p->upcount(); 33 } 34 35 ~SmartPtr(void) 36 { 37 TRACE("SmartPtr destructing\n\n"); 38 m_p->downcount(); 39 } 40 41 operator T* (void) 42 { 43 TRACE("%s, %d\n\n", __func__, __LINE__); 44 return m_p; 45 } 46 47 T& operator* (void) 48 { 49 TRACE("%s, %d\n\n", __func__, __LINE__); 50 return *m_p; 51 } 52 53 T* operator-> (void) 54 { 55 TRACE("%s, %d\n\n", __func__, __LINE__); 56 return m_p; 57 } 58 59 SmartPtr& operator= (SmartPtr<T> &p_) 60 { 61 TRACE("%s, %d\n\n", __func__, __LINE__); 62 return operator= ((T*)p_); 63 } 64 65 SmartPtr& operator= (T* p_) 66 { 67 TRACE("%s, %d\n\n", __func__, __LINE__); 68 p_->upcount(); 69 m_p->downcount(); 70 m_p = p_; 71 72 return *this; 73 } 74 75 SmartPtr(const SmartPtr<T> &p_) 76 { 77 TRACE("%s, %d\n\n", __func__, __LINE__); 78 m_p = p_.m_p; 79 m_p->upcount(); 80 } 81 82 private: 83 T* m_p; 84 }; 85 86 #endif /* SmartPtr_h */
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "RefCount.h" 10 #include "SmartPtr.h" 11 #include <iostream> 12 using namespace std; 13 14 int main(int argc, char* argv[]) 15 { 16 cout << "SmartPtr<Sample> p = new Sample; --->\n" << endl; 17 18 SmartPtr<Sample> p = new Sample; // Sample* 19 20 cout << "SmartPtr<Sample> p2 = new Sample; --->\n" << endl; 21 22 SmartPtr<Sample> p2 = new Sample; 23 24 cout << "p = p2; --->\n" << endl; 25 26 p = p2; 27 28 cout << "p->doSomething(); --->\n" << endl; 29 30 p->doSomething(); 31 32 cout << "(*p).doSomething(); --->\n" << endl; 33 34 (*p).doSomething(); 35 36 return 0; 37 }
SmartPtr<Sample> p = new Sample; ---> RefCount constructing Sample constructing SmartPtr constructing up to 1 SmartPtr<Sample> p2 = new Sample; ---> RefCount constructing Sample constructing SmartPtr constructing up to 1 p = p2; ---> operator=, 61 operator Sample *, 43 operator=, 67 up to 2 down to 0 Sample destructing RefCount destructing p->doSomething(); ---> operator->, 55 Did something (*p).doSomething(); ---> operator*, 49 Did something SmartPtr destructing down to 1 SmartPtr destructing down to 0 Sample destructing RefCount destructing Program ended with exit code: 0
设计模式
设计模式简介
- 设计模式实际上讨论的是在解决面向对象设计的某类问题时，应该设计哪些类，这些类之间如何通讯。
- 设计模式能够帮助设计者更快更好的完成系统设计。
单例设计模式
- 保证在应用程序中，一个类只有一个对象
- 将构造函数设置为私有，在类的实现中确保生成对象的个数
- 下例演示了singleton的实现，须要把构造函数/析构函数/拷贝构造函数/赋值运算符重载都声明为私有，再使用public函数来控制类的构造和析构，从而实现一个类只有一个对象
1 // 2 // Singleton.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/27. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #ifndef Singleton_hpp 10 #define Singleton_hpp 11 12 class Singleton 13 { 14 public: 15 static Singleton* getInstance(); 16 void doSomething(); 17 void destroy(); 18 19 private: 20 Singleton(); 21 ~Singleton(); 22 Singleton(const Singleton &); 23 Singleton& operator=(const Singleton &); 24 25 static Singleton *instance; 26 }; 27 28 #endif /* Singleton_hpp */
1 // 2 // Singleton.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/12/27. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Singleton.hpp" 10 11 #include <iostream> 12 using namespace std; 13 14 // 静态成员变量须要在类外初始化 15 Singleton* Singleton::instance = nullptr; 16 17 Singleton::Singleton() 18 { 19 cout << "Constructing Singleton instance --->\n" << endl; 20 } 21 22 Singleton::~Singleton() 23 { 24 cout << "Destructing Singleton instance --->\n" << endl; 25 } 26 27 // Not thread safe, 28 // Need to use pthread_mutex_lock/unlock 29 Singleton* Singleton::getInstance() 30 { 31 Singleton* ret = instance; 32 33 if (instance == nullptr) { 34 instance = new Singleton(); 35 ret = instance; 36 } 37 38 return ret; 39 } 40 41 void Singleton::doSomething() 42 { 43 cout << __func__ << " , LINE " << __LINE__ << "\n" << endl; 44 } 45 46 void Singleton::destroy() 47 { 48 delete this; 49 instance = nullptr; 50 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Singleton.hpp" 10 11 #include <iostream> 12 using namespace std; 13 14 int main () 15 { 16 /* 17 Singleton* val = new Singleton(); // ERROR : Calling a private constructor of class 'Singleton' 18 delete val; // ERROR : Calling a private destructor of class 'Singleton' 19 val = nullptr; 20 */ 21 22 Singleton::getInstance()->doSomething(); 23 24 Singleton::getInstance()->destroy(); 25 26 return 0; 27 }
Constructing Singleton instance ---> doSomething , LINE 43 Destructing Singleton instance ---> Program ended with exit code: 0
简单工厂模式
- 使用简单工厂模式实现开闭原则
- 简单工厂模式_百度百科
- https://baike.baidu.com/item/简单工厂模式
- 简单工厂模式是属于建立型模式，又叫作静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定建立出哪种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，能够理解为是不一样工厂模式的一个特殊实现。
- 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该建立哪个产品类（这些产品类继承自一个父类或接口）的实例。
- 该模式中包含的角色及其职责
- 工厂（Creator）角色：简单工厂模式的核心，它负责实现建立全部实例的内部逻辑。工厂类的建立产品类的方法能够被外界直接调用，建立所需的产品对象。
- 抽象产品（Product）角色：简单工厂模式所建立的全部对象的父类，它负责描述全部实例所共有的公共接口。
- 具体产品（Concrete Product）角色：是简单工厂模式的建立目标，全部建立的对象都是充当这个角色的某个具体类的实例。
- 使用场景
- 工厂类负责建立的对象比较少；
- 客户只知道传入工厂类的参数，对于如何建立对象（逻辑）不关心；
- 因为简单工厂很容易违反高内聚责任分配原则，所以通常只在很简单的状况下应用。
- 下例演示了简单工厂模式应用。注意接口类纯虚函数的析构函数须要定义，类的前置声明。
1 // 2 // Fruit.hpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/5. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #ifndef Fruit_hpp 10 #define Fruit_hpp 11 12 #include <iostream> 13 using namespace std; 14 15 class Fruit 16 { 17 public: 18 virtual ~Fruit() = 0; // 接口类纯虚函数的析构函数须要定义 19 virtual void plant() = 0; 20 virtual void grow() = 0; 21 virtual void harvest() = 0; 22 }; 23 24 class Apple : public Fruit 25 { 26 public: 27 Apple(); 28 ~Apple(); 29 30 void plant(); 31 void grow(); 32 void harvest(); 33 }; 34 35 class Grape : public Fruit 36 { 37 public: 38 Grape(); 39 ~Grape(); 40 41 void plant(); 42 void grow(); 43 void harvest(); 44 }; 45 46 enum { 47 APPLE = 0, 48 GRAPE = 1, 49 ORANGE = 2 50 }; 51 52 // 前置声明 53 class Orange; 54 55 class Gardener 56 { 57 public: 58 Gardener(); 59 ~Gardener(); 60 61 // 0 apple, 1 grape, orange 62 Fruit * getFruit(int); 63 64 private: 65 Apple * m_apple; 66 Grape * m_grape; 67 Orange * m_orange; 68 }; 69 70 class Orange : public Fruit 71 { 72 public: 73 Orange(); 74 ~Orange(); 75 76 void plant(); 77 void grow(); 78 void harvest(); 79 }; 80 81 #endif /* Fruit_hpp */
1 // 2 // Fruit.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2018/1/5. 6 // Copyright © 2018年 Hao. All rights reserved. 7 // 8 9 #include "Fruit.hpp" 10 #include <iostream> 11 using namespace std; 12 13 Fruit::~Fruit() 14 { 15 cout << "Fruit destructing\n" << endl; 16 } 17 18 Apple::Apple() 19 { 20 cout << "Apple constructing\n" << endl; 21 } 22 23 Apple::~Apple() 24 { 25 cout << "Apple destructing\n" << endl; 26 } 27 28 void Apple::plant() 29 { 30 cout << "Apple planting\n" << endl; 31 } 32 33 void Apple::grow() 34 { 35 cout << "Apple growing\n" << endl; 36 } 37 38 void Apple::harvest() 39 { 40 cout << "Apple harvesting\n" << endl; 41 } 42 43 Grape::Grape() 44 { 45 cout << "Grape constructing\n" << endl; 46 } 47 48 Grape::~Grape() 49 { 50 cout << "Grape destructing\n" << endl; 51 } 52 53 void Grape::plant() 54 { 55 cout << "Grape planting\n" << endl; 56 } 57 58 void Grape::grow() 59 { 60 cout << "Grape growing\n" << endl; 61 } 62 63 void Grape::harvest() 64 { 65 cout << "Grape harvesting\n" << endl; 66 } 67 68 Orange::Orange() 69 { 70 cout << "Orange constructing\n" << endl; 71 } 72 73 Orange::~Orange() 74 { 75 cout << "Orange destructing\n" << endl; 76 } 77 78 void Orange::plant() 79 { 80 cout << "Orange planting\n" << endl; 81 } 82 83 void Orange::grow() 84 { 85 cout << "Orange growing\n" << endl; 86 } 87 88 void Orange::harvest() 89 { 90 cout << "Orange harvesting\n" << endl; 91 } 92 93 Gardener::Gardener() 94 { 95 cout << "Gardener constructing\n" << endl; 96 97 m_apple = nullptr; 98 m_grape = nullptr; 99 m_orange = nullptr; 100 } 101 102 Gardener::~Gardener() 103 { 104 cout << "Gardener destructing\n" << endl; 105 106 if (m_apple != nullptr) { 107 delete m_apple; 108 m_apple = nullptr; 109 } 110 111 if (m_grape != nullptr) { 112 delete m_grape; 113 m_grape = nullptr; 114 } 115 116 if (m_orange != nullptr) { 117 delete m_orange; 118 m_orange = nullptr; 119 } 120 } 121 122 Fruit * Gardener::getFruit(int type) 123 { 124 Fruit * fruit = nullptr; 125 126 if (APPLE == type) { 127 if (nullptr == m_apple) 128 m_apple = new Apple(); 129 130 fruit = m_apple; 131 } else if (GRAPE == type) { 132 if (nullptr == m_grape) 133 m_grape = new Grape(); 134 135 fruit = m_grape; 136 } else if (ORANGE == type) { 137 if (nullptr == m_orange) 138 m_orange = new Orange(); 139 140 fruit = m_orange; 141 } 142 143 return fruit; 144 }
1 // 2 // main.cpp 3 // LeetCode 4 // 5 // Created by Hao on 2017/3/16. 6 // Copyright © 2017年 Hao. All rights reserved. 7 // 8 9 #include "Fruit.hpp" 10 11 int main () 12 { 13 Gardener Tom; 14 15 Fruit * fruit = Tom.getFruit(APPLE); 16 17 fruit->plant(); 18 fruit->grow(); 19 fruit->harvest(); 20 21 cout << "------New request for ORANGE------\n" << endl; 22 23 fruit = Tom.getFruit(ORANGE); 24 25 fruit->plant(); 26 fruit->grow(); 27 fruit->harvest(); 28 29 return 0; 30 }
Gardener constructing Apple constructing Apple planting Apple growing Apple harvesting ------New request for ORANGE------ Orange constructing Orange planting Orange growing Orange harvesting Gardener destructing Apple destructing Fruit destructing Orange destructing Fruit destructing Program ended with exit code: 0
相关文章
- 1. 手把手教你机器学习之入门（1）（吴恩达听课笔记）
- 2. GAN入门教程｜从0开始，手把手教你学会最火的神经网络（学习笔记）
- 3. 《手把手教你学C语言》学习笔记（1）---C语言的特色
- 4. 视频教程-Word从入门到精美排版教程：手把手学习Word2019精美排版-Office/WPS
- 5. 手把手教你学会用Spring AOP
- 6. C语言学习入们到精通之学习笔记（一）
- 7. 【建站】手把手教你域名注册（腾讯云）
- 8. 手把手教你求职进入BAT
- 9. 手把手教你学会深度学习框架 — PyTorch
- 10. 手把手教你学SVN
- 更多相关文章...
- • Memcached入门教程 - NoSQL教程
- • Neo4j数据库入门教程 - NoSQL教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • YAML 入门教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
