C++语法 复习 （全国高校计算机能力挑战赛）

挑战赛）"/>

C++语法 复习 （全国高校计算机能力挑战赛）

一些概念复习

明天就考试了，赶紧复习一下，选择题好像会涉及到语法和面向对象的一些概念。

下面是一些平时刷OJ不怎么用到，但是在编程中比较重要的概念

const 用法总结
参考：.htm

mutable在C++中，mutable是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，
即使在一个const函数中，甚至结构体变量或者类对象为const，其mutable成员也可以被修改：
class ST { public:int a; mutable int showCount; void Show()const; };void ST::Show()const{ //a=1;//错误，不能在const成员函数中修改普通变量 showCount++;//正确 }

一个派生类继承了所有的基类方法，但下列情况除外：基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。

继承类型
当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种
类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不
同类型的继承时，遵循以下几个规则：公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公
有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类
访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成
为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为
派生类的私有成员。

多继承
多继承即一个子类可以有多个父类，它继承了多个父类的特性。C++ 类可以从多个类继承成员，语法如下：class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 "= 0" 来指定的，如下所示：抽象类不能被用于实例化对象，它只能作为接口使用。因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数

要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 <iostream> 和 <fstream>。

打开文件
在从文件读取信息或者向文件写入信息之前，必须先打开文件。下面是 open() 函数的标准语法，open() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。void open(const char *filename, ios::openmode mode);在这里，open() 成员函数的第一参数指定要打开的文件的名称和位置，第二个参数定义文件被打开的模式。模式标志	描述
ios::app	追加模式。所有写入都追加到文件末尾。
ios::ate	文件打开后定位到文件末尾。
ios::in	打开文件用于读取。
ios::out	打开文件用于写入。
ios::trunc	如果该文件已经存在，其内容将在打开文件之前被截断，即把文件长度设为 0。您可以把以上两种或两种以上的模式结合使用。例如，如果您想要以写入模式打开文件，并希望截断文件，以防文件已存在，那么您可以使用下面的语法：ofstream outfile;
outfile.open("file.dat", ios::out | ios::trunc );关闭文件
当 C++ 程序终止时，它会自动关闭刷新所有流，释放所有分配的内存，并关闭所有打开的文件。但程序员应该养成一个好习惯，在程序终止前关闭所有打开的文件。下面是 close() 函数的标准语法，close() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。void close();写入文件
在 C++ 编程中，我们使用流插入运算符（ << ）向文件写入信息，就像使用该运算符输出信息到屏幕上一样。唯一不同的是，在这里您使用的是 ofstream 或 fstream 对象，而不是 cout 对象。读取文件
在 C++ 编程中，我们使用流提取运算符（ >> ）从文件读取信息，就像使用该运算符从键盘输入信息一样。唯一不同的是，在这里您使用的是 ifstream 或 fstream 对象，而不是 cin 对象。文件位置指针
istream 和 ostream 都提供了用于重新定位文件位置指针的成员函数。这些成员函数包括关于 istream 的 seekg（"seek get"）和关于 ostream 的 seekp（"seek put"）。seekg 和 seekp 的参数通常是一个长整型。第二个参数可以用于指定查找方向。查找方向可以是 ios::beg（默认的，从流的开头开始定位），也可以是 ios::cur（从流的当前位置开始定位），也可以是 ios::end（从流的末尾开始定位）。文件位置指针是一个整数值，指定了从文件的起始位置到指针所在位置的字节数。下面是关于定位 "get" 文件位置指针的实例：// 定位到 fileObject 的第 n 个字节（假设是 ios::beg）
fileObject.seekg( n );// 把文件的读指针从 fileObject 当前位置向后移 n 个字节
fileObject.seekg( n, ios::cur );// 把文件的读指针从 fileObject 末尾往回移 n 个字节
fileObject.seekg( n, ios::end );// 定位到 fileObject 的末尾
fileObject.seekg( 0, ios::end );

栈：在函数内部声明的所有变量都将占用栈内存。
堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。

malloc() 函数在 C 语言中就出现了，在 C++ 中仍然存在，但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。在任何时候，当您觉得某个已经动态分配内存的变量不再需要使用时，您可以使用 delete 操作符释放它所占用的内存

动态数组分配

一维数组
// 动态分配,数组长度为 m
int *array=new int [m];//释放内存
delete [] array;二维数组
int **array
// 假定数组第一维长度为 m， 第二维长度为 n
// 动态分配空间
array = new int *[m];
for( int i=0; i<m; i++ )
{array[i] = new int [n]  ;
}
//释放
for( int i=0; i<m; i++ )
{delete [] array[i];
}
delete [] array;三维数组
int ***array;
// 假定数组第一维为 m， 第二维为 n， 第三维为h
// 动态分配空间
array = new int **[m];
for( int i=0; i<m; i++ )
{array[i] = new int *[n];for( int j=0; j<n; j++ ){array[i][j] = new int [h];}
}
//释放
for( int i=0; i<m; i++ )
{for( int j=0; j<n; j++ ){delete[] array[i][j];}delete[] array[i];
}
delete[] array;

free()和delete的用法:

不连续的命名空间
命名空间可以定义在几个不同的部分中，因此命名空间是由几个单独定义的部分组成的。一个命名空间的各个组成部分可以分散在多个文件中。所以，如果命名空间中的某个组成部分需要请求定义在另一个文件中的名称，则仍然需要声明该名称。下面的命名空间定义可以是定义一个新的命名空间，也可以是为已有的命名空间增加新的元素：namespace namespace_name {// 代码声明
}嵌套的命名空间
命名空间可以嵌套，您可以在一个命名空间中定义另一个命名空间，如下所示：namespace namespace_name1 {// 代码声明namespace namespace_name2 {// 代码声明}
}
您可以通过使用 :: 运算符来访问嵌套的命名空间中的成员：// 访问 namespace_name2 中的成员
using namespace namespace_name1::namespace_name2;// 访问 namespace:name1 中的成员
using namespace namespace_name1;

函数模板
模板函数定义的一般形式如下所示：template <typename type> ret-type func-name(parameter list)
{// 函数的主体
}
例子：
template <typename T>
inline T const& Max (T const& a, T const& b) 
{ return a < b ? b:a; 
} 类模板
正如我们定义函数模板一样，我们也可以定义类模板。泛型类声明的一般形式如下所示：template <class type> class class-name {
.
.
.
}
例子：
template <class T>
class Stack { private: vector<T> elems;     // 元素 public: void push(T const&);  // 入栈void pop();               // 出栈T top() const;            // 返回栈顶元素bool empty() const{       // 如果为空则返回真。return elems.empty(); } 
}; 

#define PI 3.14159
#define MIN(a,b) (a<b ? a : b)条件编译
有几个指令可以用来有选择地对部分程序源代码进行编译。这个过程被称为条件编译。条件预处理器的结构与 if 选择结构很像。请看下面这段预处理器的代码：
#ifdef NULL#define NULL 0
#endif
您可以只在调试时进行编译，调试开关可以使用一个宏来实现，如下所示：#ifdef DEBUGcerr <<"Variable x = " << x << endl;
#endif
如果在指令 #ifdef DEBUG 之前已经定义了符号常量 DEBUG，则会对程序中的 cerr 语句进行编译。您可以使用 #if 0 语句注释掉程序的一部分，如下所示：#if 0不进行编译的代码
#endif实例
#include <iostream>
using namespace std;
#define DEBUG#define MIN(a,b) (((a)<(b)) ? a : b)int main ()
{int i, j;i = 100;j = 30;
#ifdef DEBUGcerr <<"Trace: Inside main function" << endl;
#endif#if 0/* 这是注释部分 */cout << MKSTR(HELLO C++) << endl;
#endifcout <<"The minimum is " << MIN(i, j) << endl;#ifdef DEBUGcerr <<"Trace: Coming out of main function" << endl;
#endifreturn 0;
}# 和 ## 预处理运算符在 C++ 和 ANSI/ISO C 中都是可用的。
# 运算符会把 replacement-text 令牌转换为用引号引起来的字符串。
#define MKSTR( x ) #x
cout << MKSTR(HELLO C++) << endl;
## 运算符用于连接两个令牌。下面是一个实例：
#define CONCAT( x, y )  x ## y
int xy = 100;
cout << concat(x, y);

C++ STL（标准模板库）是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现
多种流行和常用的算法和数据结构，如向量、链表、队列、栈。容器（Containers）	容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
算法（Algorithms）	算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
迭代器（iterators）	迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。

C++ 标准库
C++ 标准库可以分为两部分：标准函数库： 这个库是由通用的、独立的、不属于任何类的函数组成的。函数库继承自 C 语言。
面向对象类库： 这个库是类及其相关函数的集合。C++ 标准库包含了所有的 C 标准库，为了支持类型安全，做了一定的添加和修改。

C++工程结构

简要概述：

类（类中函数的声明），变量和函数的声明一般都放在头文件（.h）中
类的成员函数的定义，函数的定义一般都放在相应头文件同名的cpp文件中(在cpp文件中一开始就要包含相应的头文件)
eg:algorithm.h文件中声明：void sort(T a[],l,r);
那么在algorithm.cpp文件中定义： 
#include<algorithm.h>
void sort(T a[],l,r){...}类名自成一个命名空间，不需要另外在namespace xxx{}

多态

因为继承和虚函数的存在，所以有了多态

我的概括：
基类指针或者引用实际上指向的是派生类的地址，于是可以通过基类指针或应用访问派生类中同名覆盖的成员函数，实现一个基类指针调用同一个函数可能执行不同的功能

虚函数，是指被virtual关键字修饰的成员函数。
在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：
virtual 函数返回类型 函数名（参数表） {函数体}；实现多态性，通过指向派生类的基类指
针或引用，访问派生类中同名覆盖成员函数。
`