根据实例复习Cpp

1. 还是这里开始Cpp

#include <iostream> // 一个良好的编程习惯是将using直接跟在include之后 using namespace std; int main() { int number1; int number2; int sum; cout << "Enter the first number :"; cin >> number1; cout << "Enter the second number :"; cin >> number2; sum = number1 + number2; // <<流操作符 cout << "Sum is " << sum << endl; return 0; }

2. 定义第一个类

// 定义第一个类 #include <iostream> using namespace std; class GradeBook { public: // 访问修饰符 // 定义类方法 void displayMessage() { cout << "Welcome to GradeBook" << endl; } }; // 注意这里的分号 int main() { // 声明GradeBook类，区分这里和c#中需要使用new关键字 GradeBook g; g.displayMessage(); return 0; } 

 

3. 使用string对象

// 使用string对象 #include <iostream> #include <string> using namespace std; int main() { // 声明string对象str string str; // 读取一行 getline(cin, str); // 输出 cout << str; return 0; } 

 

4. 类构造函数

// 测试类的构造函数 // // 如果一个类没有提供构造函数的话，编译器将生成一个默认的 // 构造函数，在该构造函数中将调用类中每个数据程序的默认构造函数 #include <iostream> using namespace std; class Student { public: Student() { cout << "Call Student default constructor/n"; this->score = 0.0; } private: double score; }; class GradeBook { public: int getData() { return data; } private: Student stu; int data; }; int main() { // 在类GradeBook中没有构造函数，那么编译器将生成一个默认构造函数 // 将调用Student的默认构造函数，但是data的值是不确定 GradeBook g; cout << g.getData() << endl; return 0; } 

 

5.  Cpp中类定义和实现分文件

// Main.cpp

#include <iostream> // 包含类定义头文件 #include "GradeBook.h" int main() { GradeBook g; g.displayMsg(); return 0; } 

// GradeBook.h

#ifndef _GRADE_BOOK_H_ #define _GRADE_BOOK_H_ // 仅仅是类定义 class GradeBook { private: double data; public: void displayMsg(); GradeBook(); }; #endif 

 

// GradeBook.cpp

#include <iostream> using std::cout; #include "GradeBook.h" // 类实现 GradeBook::GradeBook() { this->data = 0.0; } void GradeBook::displayMsg() { cout << "Welcome to GradeBook !/n"; } 

 

6.else摇摆

// 控制结构：else摇摆 #include <iostream> using namespace std; int main() { int x = 3, y = 6; if (x > 5) if (y > 5) cout << "x and y are > 5" << endl; else // 这里的else匹配的是最近的那个if // 下面的程序将什么也不输出，因为x < 5 cout << "x is <= 5"; return 0; } 

 

7. 存储类别，链接和作用域

这里有介绍，但是需要指明的是存储类别和作用域是相互独立的，不是说一个变量V在程序的整个运行期间都存在，并不代表在任何的作用域中该变量均能使用。

 

8.内联函数

// 内联函数 #include <iostream> using namespace std; // 使用管理之inline表明向编译器提出申请将这个 // 函数内敛 inline int max(int a, int b) { return (a > b) ? a : b; } int main() { return 0; } 

 

9.  cpp中的引用

// cpp中的引用类型 #include <iostream> using namespace std; // 在函数参数中使用引用 void increase(int& a) { a++; } // 使用const表明的是在该函数中不改变a的值 void print(const int& a) { // 将出现错误 a = 1; cout << a << endl; } int main() { int value = 0; // 声明引用，并赋值 int& refValue = value; // refValue和value指向的是同一个对象，所以更改refValue的值将 // 更改value的值 refValue = 5; cout << "the value is :" << value << endl; int a = 0; // 注意这里的函数调用方式，这里和普通的函数调用是相类似的， // 但是却在函数内部改变了a的值 increase(a); cout << "after Increase, a is " << a << endl; return 0; } 

 

10. 默认实参

// cpp默认实参 #include <iostream> using namespace std; // 默认参数，语法的格式是直接在函数的形式参数中写入 // 默认值 int boxVolume(int length = 1, int width = 1, int height = 1) { return (length * width * height); } int main() { // 含有默认参数的函数的调用 cout << "1, 1, 1 is " << boxVolume() << endl; cout << "1, 2, 1 is " << boxVolume(1, 2) << endl; cout << "1, 2, 3 is " << boxVolume(1, 2, 3) << endl; return 0; } 

 

11.一元作用域分辨运算符

// 一元作用域分辨运算符 #include <iostream> using namespace std; // 全局变量 int num = 10; int main() { // 局部变量 int num = 5; cout << "local is " << num << endl; // 使用::来访问全局num变量 cout << "global is " << ::num << endl; return 0; } 

 

12.函数重载

// 函数重载 #include <iostream> using namespace std; // 重载其他比较迷惑特性：默认参数重载，引用类型重载，const类型重载 // 函数重载:c++在进行函数重载时只是根据函数的参数的 // 类型来判断，不根据函数的返回值来区别两个函数，因为在 // 编译器对重载函数进行编译时将根据参数的不同类型重新生成 // 名字，同时忽略函数的返回值 // #1 void overloadFunc() { cout << "Call void overloadFunc()" << endl; } // #2 void overloadFunc(int) { cout << "Call void overloadFunc(int)/n"; } int main() { int a = 0; // #2 overloadFunc(a); return 0; } 

 

13. 函数模板

// 函数模板 #include <iostream> using namespace std; template <typename T> T maxValue(T a, T b) { return (a > b) ? a : b; } int main() { // 注意这里在使用时，不需要指明类型(max<int>) cout << maxValue(1, 2) << endl; cout << maxValue('a', 'b') << endl; // 这句将产生错误，两个参数的类型不一致 // cout << maxValue('a', 10) << endl; return 0; } 

 

14. 函数指针数组

// 函数指针数组 #include <iostream> using namespace std; void func1() { } void func2() { } void func3() { } int main() { // 声明函数指针数组 void (*funcPtr[3])(); funcPtr[0] = func1; funcPtr[1] = func2; funcPtr[2] = func3; return 0; } 

 

15. 何时调用构造函数和析构函数

 

全局变量的初始化是优先于main函数执行，然后开始执行main函数，在main函数中如果遇到自动变量对象，将调用该变量的构造函数，在该变量的作用域完成之后，将指定调用该变量的析构函数，如果是static变量的话，将在main函数结束之后调用析构函数。如果程序中遇到 exit或者是abort的话，将不调用任何对象的析构函数。

 

// 函数指针数组 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; class CreateAndDestroy { public : CreateAndDestroy(int id, string msg) { m_objectId = id; m_message = msg; cout << "Object : " << m_objectId << " Constructor runs " << m_message << endl; } ~CreateAndDestroy() { cout << "Object : " << m_objectId << " Destructor runs " << m_message << endl; } private: int m_objectId; string m_message; }; void create() { cout << "Create function : executuion begins" << endl; CreateAndDestroy fifth (5, "local automic in create"); static CreateAndDestroy sixth (6, "local static in create"); CreateAndDestroy seventh(7, "local automic in create"); cout << "Create function : executuion ends" << endl; } // 全局变量 CreateAndDestroy fist(1, "global before main"); int main() { cout << "Main function execution begins" << endl; CreateAndDestroy second(2, "local automic in main"); static CreateAndDestroy third(3, "local static in main"); create(); cout << "Main function : execution resumes " << endl; CreateAndDestroy fourth(4, "local automic in main"); cout << "Main function : execution ends"<< endl; return 0; }

 

16. const对象和const成员函数

// const成员函数 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; // 定义Time类 class Time { private : int hour; int minute; int second; public: Time(int h = 0, int m = 0, int s = 0) { hour = h; minute = m; second = s; } // set方法 // const函数，非const对象能够调用const函数，但是const // 对象只能调用 const成员函数 void printTime() const { cout << "hour " << hour << " minute " << minute << " second " << second << endl; } }; int main() { // 声明const对象 const Time t(1, 1, 1); t.printTime(); Time t2; t2.printTime(); return 0; }

 

17. const产量初始化

// const产量初始化 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; // 定义Time类 class Time { private : const int CONSTANT; public: // const常量初始化语法，如果是const static产量的话，直接在定义处初始化 Time() : CONSTANT(0) { } }; int main() { Time t; return 0; }

 

18. 友元函数

// 友元函数 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; // 定义Time类 class Time { private : int hour; int minute; int second; public: Time(int h = 0 , int m = 0, int s = 0) { hour = h; minute = m; second = s; } // 定义friend函数。实际上友元函数可以在class的任何位置定义 // 因为友元函数实际上不是该类的成员函数 friend Time add(const Time& t1, const Time& t2); }; // 定义有缘函数，这里不需要使用friend Time add(const Time& t1, const Time& t2) { return Time(t1.hour + t2.hour, t1.minute + t2.minute, t1.second + t2.second); } int main() { Time t1(1, 1, 1); Time t2(2, 2, 2); Time t3 = add(t1, t2); return 0; } 

 

19. 类中的static成员和static函数

// 类中的static成员和static函数 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; // 定义Time类 class Time { private : int hour; int minute; int second; // 定义static成员变量 static int instanceCounts; public: Time(int h = 0 , int m = 0, int s = 0) { hour = h; minute = m; second = s; // 使用类的静态变量 Time::instanceCounts++; } // 定义static成员函数 static int getInstanceCount() { return instanceCounts; } }; // 虽然static成员默认已经进行了初始化为0，但是如果不添加这初始化的话 // 在该文件中将找不到该变量 int Time::instanceCounts = 0; // 文件作用域 int main() { Time t1(1, 1, 1); Time t2(2, 2, 2); // 使用类的静态方法 cout << "Time instance count is " << Time::getInstanceCount() << endl; // 调用类的static方法 return 0; } 

 

20. 运算符重载

 

运算符重载仅仅是在简化客户端的程序的编程，可以直接调用运算函数：t1.operator==(t2);.

// 运算符重载 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; // 定义Time类 class Time { private : int hour; int minute; int second; public: Time(int h = 0, int m = 0, int s = 0) { hour = h; minute = m; second = s; } // 使用默认构造函数 // 运算符重载== bool operator== (const Time& other) { return (hour == other.hour) && (minute ==other.minute) && (second == other.second); } // != bool operator!= (const Time& other) { return !(*this == other); } // + Time operator+(const Time& other) { return Time(hour + other.hour, minute + other.minute, second + other.second); } // - Time operator-(const Time& other) { int hour = hour - other.hour; int minute = minute - other.minute; int sec = second - other.second; return Time(hour, second, sec); } // * Time operator*(int n) { return Time(hour * n, minute * n, second * n); } // 打印信息 void printTime() { cout << "Hour : " << hour << " Minute : " << minute << " Second : " << second << endl; } }; int main() { Time t1(1, 1, 1); Time t2(2, 2, 2); Time t3 = t1 + t2; t3.printTime(); if (t1 == t2) cout << "t1 == t2" << endl; else cout << "t1 != t2" << endl; return 0; } 

 

21. 类型转换函数

 

在c++中如果构造函数可以用作类型转换函数（如果想要禁止的话，可以使用关键字explicit禁止将该构造函数用作默认的类型转换函数），也可以指定以类的类型转换函数。

 

// 类型转换函数，这里仅仅是为了演示，没有实际意义 // 注意这里的函数格式，没有返回值 operator int() { return 1; } 

 

22. 重载++运算符

 

由于在c++中存在a++和++a的类型，所以编译器需要使用一个所谓的“哑元素”来区分是a++还是++a。

 

// 定义++运算符 // ++a形式 Time& operator++ () { second++; return (*this); } // a++形式 Time operator++(int) { Time tmp = *this; second++; return tmp; } 

 

23.类的继承属性

 

c++中存在三种类型的继承属性，如果不明确知名的话，默认的是private继承。不管是何种类型的继承，子类都是不能访问父类的private成员的，只是private，public，protected继承对于父类的public成员在子类中的行为是不相同的。同时需要注意的是：

1. 构造函数是不能够被继承的

2. 如果子类重写了父类的某个方法 ，但是还想调用覆盖的父类方法时，可以使用父类名::函数的形式调用

 

24 virtual关键字

 

// 父类 class BaseClass { public: BaseClass() { cout << "base class constructor. " << endl; } ~BaseClass() { cout << "baseclass destructor" << endl; } virtual void toOverrideFunc() { cout << "override function in baseclass." << endl; } }; // 这里使用的是public继承 class Subclass : public BaseClass { public: Subclass() { // 这里将首先调用BaseClass的构造函数 cout << "subclass constructor. " << endl; } ~Subclass() { // 这里首先调用该类的析构函数，然后是父类的析构函数 cout << "subclass destructor." << endl; } // 这里仅隐藏父类的该函数toOverrideFunc virtual void toOverrideFunc() { cout << "override function in subclass" << endl; } }; int main() { // 没有使用virtual的话，那么函数调用将取决于调用的句柄 // 如果使用了irtual的话，那么函数调用的将取决于实际的对象类型 BaseClass* basePtr = new Subclass(); // 这里将调用subclass中的函数 basePtr->toOverrideFunc(); Subclass* subPtr = new Subclass(); subPtr->toOverrideFunc(); delete basePtr; delete subPtr; return 0; } 

 

25. 抽象类

 

c++中如果一个类想要成为抽象类的话，只需要将类中的一个成员函数声明为纯虚函数，纯虚函数是不能够有时显得，但是虚函数是能够有函数的时显的。

 

// 纯虚函数 #include <iostream> #include <string> using std::string; using std::cout; using std::endl; using std::ostream; using std::istream; using std::cin; // 父类，抽象类 class BaseClass { public: // 纯虚函数 virtual void pureVirtualFunc()= 0; }; // 这里使用的是public继承 class Subclass : public BaseClass { public: virtual void pureVirtualFunc() { cout << "in the subclass, we override the purevirtualFunc()" << endl; } }; int main() { // 抽象类是无法实例化的 // BaseClass b; // 错误 BaseClass* basePtr = new Subclass(); basePtr->pureVirtualFunc(); delete basePtr; return 0; } 

 

完结