c++备考期末必看知识点（一篇就够了）

一.关于C++的常用注释的三种方法

简要：
第一种方法：（两个斜杆）/ /
第二种方法：（）/ * * /
第三种方法：使用预处理形式 #if 0 #endif
详细可以参考该篇
添加链接描述

二.c++中的作用域四类（函数原型作用域，局部作用域，类作用域，命名空间作用域）

简要：
1.函数原型作用域：

此作用域为c++程序中最小的作用域，生存周期最短。
（即函数形参，在函数的原型声明时的括号里面的形参的作用域就是函数原型作用域。）切记是在函数声明中不是定义
例：int func（int i） i为参数，作用域类型为函数原型类型。

2.局部作用域。
3.类的作用域。
4.命名空间作用域。
详细可以参考该篇
添加链接描述

三.在类中友元函数运算符重载函数原型中必须要有一个该类的对象

因为类的友元函数不能通过对象进行调用

四.类型兼容型规则

下面通过题目来展开
1.在需要派生类对象的地方，可以使用基类的对象代替（X)
原因：在需要基类对象的任何地方，都可以用公有派生类的对象来替代。

2.基类对象的地址可以赋值给派生类的指针（X)
原因：
1.基类对象到派生类对象之间的转换是不存在的，编译器时错误，因为基类对象只能是基类对象，它不包含也不能包含派生类的成员，如果允许基类到派生类转换，那么就会试图使用派生类对象访问不存在的成员。

2.基类对象的引用或指针到派生类对象的引用或指针也是不存在的，不被允许的，编译时错误，原因同上。

3.派生类的对象可以作为基类的对象来使用，且可以使用所以成员（X）
原因：派生类对象可以作为基类的对象使用，但只能使用基类继承的成员

4.派生类的对象可以初始化基类的引用（正确）
原因：
1）派生类的对象可以赋值给基类的对象（隐含转化）
2）派生类的对象可以初始化基类的引用（隐含转化）
3）派生类的对象的引用可以初始化基类的引用（隐含转化）
4）派生类对象的地址可以赋给指向基类的指针（这里常用）（隐含转化）

5.把派生类对象的引用或指针转换为基类的引用或指针或，通过基类的引用或指针只能访问派生类继承自基类的数据成员。

5.内联函数

1 内联函数必须是和函数体定义在一起，才有效。像这样的申明Inline Tablefunction(int I)是没有效果的，编译器只是把函数作为普通的函数申明，我们必须定义函数体。 (当然也可以在声明时放Inline,不过必须在定义前加，声明前加是可有可无的）
Inline tablefunction(int I) {return I*I};
2.可以将定义在类的外部的函数定义为内联函数。

3 在C++中，在类的内部定义了函数体的函数，被默认为是内联函数。而不管你是否有inline关键字。
4.内联函数的定义必须出现在内联函数第一个被调用之前。
原因：在编译时，如果在调用时未出现函数的定义，编译器就无法用内联函数体来替换调用函数的表达式。而普通函数在编译时不需要进行替换，因此也就不需要在调用之前定义。
5.内联函数在调用时，是将调用表达式用内联函数体来替换。
（与宏有区别）

6.输入流与输出流的成员函数

输入流：istream
1.getline() 函数
2.ignore() 函数
3.ignore() 函数
4.peek() 函数
5.putback() 函数
6.read() 函数
(read 不会在读到n-1个字符后停止，也不会在字符串后面自动添加空字符，有乱码，但getline 可以，)
7.gcount 函数
8.open()函数
详细请参考链接：

添加链接描述

输出流：ostream
1：open成员函数。（也可以是输入流函数）

2：close成员函数。

3：put成员函数。

4：write成员函数。

5：seekp和tellp。

6：错误处理函数。

7.抽象类（重要）

概念：包含纯虚函数的类称为抽象类。（不是只有纯虚函数）
注意：
1.抽象类只能用作基类来派生新类，不能用抽象类来声明对象。
原因：因为抽象类中的纯虚函数没有实现相应的功能。
2.但是可以用抽象类声明指针或引用，通过指针或引用来调用派生类对象。
3.纯虚函数在抽象类中只定义不实现。
4.抽象类的指针可以指向不同的派生类。

8.读取带空格的字符串

1.getline()函数：
注意：
cin.getline(str,10);
中的str是char *类型。
getline(cin,str);
中的str是string类型。
2.get()函数

3.不能直接使用read()函数
原因：read(1,2）;有两个形参，第一个是存储字符的空间，第二个是读取的字符长度。

9.C++函数异常说明

异常说明有如下的几种形式：

指定异常

T funNname（ parameterlist ） throw（ T1， T2，····，Tn）；

其中 T 是类型， parameterlist 是参数列表，而类型 T1， T2，····，Tn 是函数会抛出的异常。

不抛出异常

T funNname（ parameterlist ） throw（）；
抛出异常类型列表为空，表示的是该函数不抛出任何类型异常。

抛出任意类型的异常

T funNname（ parameterlist ）；
这表示该函数可以抛出任意类型的异常。

总结：异常说明还是有用的！但更多是写给函数用户看的。让函数用户清楚知道抛出的异常类型，从而更好和正确地在运用此函数时，编写对其的异常检测。
详细请参考：
添加链接描述

10 枚举变量

以题目为例：

enum fun{a,b=6,c,d=9}中 c的值是7，而不是8.
其余详细可以参考：
添加链接描述

11.异常处理

1.抛出异常 throw()
语法格式：throw 表达式；
注意：
其中， throw后面的表达式可以是常量、变量或对象。该表达式的类型比表达式的值更重要，因为catch子句在捕获异常时是根据throw抛出的表达式的类型进行判断的，而不是表达式的值。如果需要通过throw抛出多个异常，应该通过throw后的表达式的不同类型进行区分。

2.2.捕获异常 catch()
基本语法：
catch(异常类型说明符）
{
异常处理语句；
}

有一个比较特殊的可以捕获所有类型的异常
格式如下：
catch(…）
{
异常处理语句；
}
在执行完catch()子句的所有代码后，程序的控制权不会重新跳转回抛出异常的函数中了。

12.重载函数

1.不能用函数返回值类型来区分两个重载函数。
2.形参的名字不能用于区别两个同名函数。
3.普通变量与其引用无法区分。
4.如果形参是指针或引用，带const 与不带const 的可以区分

**
可以用与区分的是：**函数的参数。（包括参数个数，类型及顺序）。

13.虚基类

1.虚基类与虚函数的区别：
虚基类是用来解决继承时出现的二义性，而虚基函数是用来解决动态多态的绑定问题的。

2.虚基类不是在声明基类时声明的，而是在声明派生类，指定继承方式时声明的。

3.虚基类继承中派生类的构造函数：
派生类的构造函数不仅要调用其直接基类的构造函数，还要调用其间接基类的构造函数。

4.虚基函数的构造函数只会调用一次

只由最后定义的派生类来调用。

14.对象数组的初始化

1.类似初始化普通数组的方法；


student str[2]={{1,2},{3,4}};

注意：这种方法需要结合拷贝构造函数


student (const student &);
//const student & 格式固定2.```cpp
student str[2]={student{1,2},student{3,4}};

15.常数据成员（const)

1.必须在声明的同时进行初始化，而且不允许更新。

2.必须通过构造函数的参数列表初始化方式进行初始化。
（也可以在类中初始化常数据成员）

private:
const double pi=3.14;

3.一旦赋值后就不再允许改变，但在初始化常数据成员时可以用变量为其赋值。

16.静态常数据成员(static const)

1.必须在类外定义并同时初始化。
（但，如果类型是整型或枚举类型，则可以在类中定义为其指定初始值）

private:
static const int pi=3;
static const double p;//类外const  double 类名::p;=3.14;

17.常成员函数

类型说明符 函数名 （参数列表）const；

1.在类中声明和类外定义都需要关键字const；
2.在函数内部不能调用非常成员函数。(即不能调用普通成员函数，）
3.常成员函数可以用非常对象来调用，但常对象只能调用常成员函数。
4.常成员函数内部不允许进行数据成员的修改，但是可以在函数内部输出const数据成员与非数据成员！

18. 常对象

const 类名 对象名;

1.常对象不允许修改其任何的数据成员。
2.常对象必须在定义时初始化，不能被更新。
3.常成员函数可以用常对象调用也可以非用常对象调用，
但是常对象只能调用常成员函数，不能调用其他类型的函数。

19.静态数据成员（关键词 static）

用static 声明的数据成员可以被类的所有对象共享。（即，静态数据成员在内存中（像函数一样）只有一个副本）。

静态数据成员的初始化必须在类外部进行。

类型说明符 类名:: 静态数据成员 =初始值；

通常用类名进行访问。，不过也是可以用对象来访问的。
基本格式：
类名:: 静态数据成员；

20.静态成员函数

1.在类外实现时不需要添加static关键词。
3.静态成员函数只能直接访问静态成员变量和静态成员函数；（即不能直接使用普通变量与常变量）
2.可以在静态成员函数中访问非静态成员，不过很麻烦。
因为静态成员函数中没有this指针。

21.指针常量、常量指针

指针常量，意思为指针（指向的地址）是一个常量（不可以修改）。
常量指针，意思是指向常量的指针。

int * const p=&a;//指针常量
const int * p=&a;//常量指针

1、指针常量
数据类型 * const 指针变量=变量名；

修饰符const与指针变量紧邻，说明指针变量不允许修改，既然指针变量的值不能修改，所以一定要在定义的时候给定初值（指向一个确定存在的地方）
p不可以改变，但 *p可以改变

2、常量指针
const 数据类型 *指针变量=变量名；

或者数据类型 const * 指针变量=变量名；

定义一个常量指针后，指针指向的值就不能被改变，即不能通过指针变量直接更改指针指向的值。（*p 不可以改变，但p可以改变）
指针常量与常量指针

22.数组的初始化方式

数组的初始化方式

字符数组

23.构造函数

要求：
1.构造函数名要与类名相同；
2.函数中无返回值类型。
3.没有return 语句。
4.构造函数可以重载。重载时要避免二义性。（如定义了默认构造函数，也定义了不带参数的构造函数， student s；报错）
一：委托构造函数
1.委托构造函数在类内创建和实现。
2.委托构造函数的参数小于或等于被委托的构造函数。
委托构造函数

二.调用的时机
在对象创建时调用；

//test 类
test a;//调用一次
test a[3];//调用三次
test *p=new test;//调用一次
test *p;//因为没有创建对象，所以没有调用

24.继承

1.派生类继承了父类的除构造函数，折构函数和运算符重载函数之外的所有成员。
一.公有继承
基类成员的访问权限在派生类中不变。

二.保护继承
基类的所有公有成员和保护成员都作为派生类的保护成员，并且只能被他的派生类的成员函数或友元函数访问。（保护成员在类外无法访问）

三.私有继承
基类的公有成员和保护成员都作为派生类的私有成员。

继承

25.派生类中构造函数的执行顺序

1.调用基类构造函数，调用顺序按他们继承时声明的顺序。
2.调用内嵌成员对象的构造函数，调用顺序按照他们在类中声明的顺序。
3.派生类的构造函数体中的内容。
折构函数的执行顺序相反。

26.函数调用

1 派生类与基类的函数同名时，派生类会覆盖掉基类的同名函数，但可以通过：：调用基类中的函数。
2.若成员函数与常成员函数同名，常对象会调用常成员函数，普通对象会调用成员函数

27.虚函数与动态多态

1.虚函数是实现动态多态的基础。
2.虚函数所在的类是基类，在派生类中改写基类中的虚成员函数。
ps：
1.继承方式必须是public 继承（不是 virtual public）
2.派生类中函数原型必须与基类中的虚函数的原型完全一致。关键词 virtual 不加也可，都视为虚函数。
3.虚函数只能是类的成员函数，但不能是静态数据成员函数。
4.virtual 只能用来说明类声明中的原型，不能用在函数实现时。

在使用动态多态时两大前提：
1.基类必须用引用或指针来接受派生类。（将根据引用或指针指向的对象类型来选择方法）

// 基类 a ，派生类 b
a a1；
b b1；
a1=b1；//无效
a &a1；
b & b1;
a1=b1;//有用
//指针同理

2.调用的函数在基类中必须是虚函数。

28. 变量的作用域与生命周期

C++中变量的作用域与生命周期

28.函数的声明，定义

函数的声明就是告诉编译器我们想要定义一个函数，并明确规定其返回值（输出）、函数名、参数表（输入）
定义函数的实现功能了，实现函数功能时，函数的名称，返回值，参数表必须要与此函数声明时一致。
ps：
1.函数原型声明不是必须的。（即可以只给出函数定义）
2.函数原型声明是形参名可以省略。
3.函数的定义不可以嵌套。

30.重载，隐藏，覆盖

重载，隐藏，覆盖

31.复制（拷贝）构造函数

以下情况会调用拷贝构造函数：
①当函数的参数为类的对象时；
②函数的返回值是类的对象；
③对象需要通过另外一个对象进行初始化。
ps：
1.形参必须是类对象的引用。
2.当函数的形参为类的对象时，会调用该类的拷贝构造函数生成一个该类的临时对象，函数结束后被折构。

32.友元函数

1.可以是全局函数也可以是其它类的函数。

//全局
friend 类型说明符 友元函数名（）；
//其他类的
friend 类型说明符 其它类名::函数名（）；

2.friend 只在函数声明时使用，在函数定义时不使用。
3.在友元函数内部可以直接访问类的私有成员。

33.异"^"，或（|），与（&）

1.异，相同为0，不同为1；
2|.有一个为1，则为1，否则为0；
3.& 都为1，才为1.

改错

1.const double pi;
pi=3.14;
常量必须初始化且不能修改， const double pi=3.14;2.virtual double area()==0;
应该为 virtual double area()=0;
3.
private:double pi=3.14;不能赋值  double pi;4.namespace std 缺少分号  namespace std ;（在类的花括号后边也要有分号）5.int & a=9;不能将引用指向常量。