C++笔记一复印.docx

C++笔记一复印.docx

《C++笔记一复印.docx》由会员分享，可在线阅读，更多相关《C++笔记一复印.docx（25页珍藏版）》请在冰豆网上搜索。

C++笔记一复印

C++笔记

三：

输出输入函数

1：

std:

:

cout<<"欢迎来到C++\n";std:

:

cin>>x;

2:

\n制表符，相当于按了tab键，在vc中使后输出的数据对齐std:

:

cout<<"内容\t"<<100;

3:

endl与\n区别

a：

endl具备\n的换行功能外，还调用了输出流flush函数，刷新缓冲区，让数据

直接写入文件或者屏幕上

b：

这两种都用，如果需要立即显示，比如输出到显示器的场合，最好用endl。

如果不需要，并且要兼顾代码的执行

效率的时候，可以用\n，但数据没有立即写入设备

4：

std:

:

为名称空间标识符，C++标准库中的函数或对象都是在命名空间std中定义的，

所以我们要用std限定

5：

解决std:

:

繁琐

a：

使用非标准库iostream.h

b：

usingnamespacestd告诉编译器我们要使用名字空间std中的函数对象

c：

usingstd:

:

cout；将std中的cout函数释放出来

四：

头文件的区别

1：

iostream.h为非标准的输入输出流，这个.h的头文件是C语言格式的，由于没有名

字空间这个说法，所以也就不存在std这个名字空间标识符

2：

iostream为标准输入输出流，它是C++规范的带有名称空间的头文件，他包含在std名字空间内，而iostream又包含cin和cout输入输出对象，所以使用cout的时候必须加std

3：

总结：

标准命名空间包括→标准库函数std>iostream>cin/cout

五：

名字空间中变量重名问题

1：

建立一个名字空间namespacea

{b=5;}

namespacec

{b=8;}

intmain

{

intb=5

std:

:

cout<

:

b<

:

b<

}

2：

名字空间中的变量重名时，如果其中有main（）中的变量，那么不会出错，直接输出

main（）中的变量,否则就有错误。

六：

函数

1：

通常把函数声明叫做函数原型，而把函数定义叫函数实现

七：

C++数据类型

1：

广义上划分C++数据类型，常量--变量

2：

布尔型，它可表示两个逻辑值，1和0。

boolcheck（变量名）；true==1false==0

3：

字符型它存放字符，是计算机字符集中的字符（ASCII码）0~255之间，每一个数一

个码

4：

奇偶校验：

a：

奇校验规定：

正确代码一个字节中1的个数必须是奇数，若非奇数，则在在最

高位添1；

b：

偶校验规定：

正确代码一个字节中1的个数必须是偶数，若非偶数，则在最高位添1；

5：

特殊字符

\a铃声（警报声）\b回退\f焕页

\r回车\tTAB键\v垂直制表

\'单引号\"双引号\？

问号

\\反斜杠\000八进制\xhhh十六进制

6：

双字节型

1：

wchar_t，又叫宽字符类型，用来存储汉字，韩文，日文等占两个字节的字符

2：

wchar_twt[]=L"汉"L告诉编译器为“汉”分配两个字节的空间

3：

由于“汉”是个汉字，所以我们需要调用一个函数将语言设置为中文简体

4：

setlocale（LC_ALL表示设置所有的选项，"chs"）;#include

5：

wcout<

7：

整型的范围

1：

int（-2^31）~（2^31-1）2：

short（-2^15）~（2^15-1）3：

long（2^31）~（2^31-1）

4：

uint（0）~（2^32-1）5：

ushort（0）~（2^16-1）6：

ulong（0）~（2^32-1）

7：

float（1.2e-38）~（3.4e38）8：

（2.2e-308）（1.8e308）

8：

浮点型变量

1：

float（2*2^-126）~（2*2^1238）

a：

0000000000000000000000000000000

符号指数位尾数位（23）

结论：

取值范围由指数来定，所以剩余尾数23位，最多可表示2*23个有

效数字

b：

2*2^23=8388608个有效数字，求有效的位数，以10为底数，求次方，

有效数字为6~7位

c：

8388608，也就是23位数值的容量，它占用6到7位

2：

double（2*2^-1022）~（2*2^1024）64位

a：

0000000000000000000000000000000000

符号指数位（11）尾数位（52）

b：

11位指数位0~2*2^11-1-1022~1024

c：

有效数字个数为2*2^52个，10进制中有效数字为15~16位

9：

const之后定义的变量为常量，之后不能对它进行修改

10：

enumnum{zero，one，two，stree，four};关键字enum将其后num声明为

枚举型，zero代表1

八：

逻辑运算符

1：

凡是用来计算值的操作都可以看作是表达式，表达式总能返回一个值例1；它返

回了1，只是没有载体。

九：

面向对象程序语言的主要特征

1：

抽象：

a：

面向对象的思想要求程序员将程序的每一个部分都看作一个抽象的对象，即

程序是由一组抽象的对象组成的，更复杂点，这些对象根据他们相同的特征

而又进一步组成了一个类。

b：

打个比方张明是一个人，我们把它看做一个对象，李四也是一个人，我们也

把他看做一个对象，还有王五、赵钱、孙李等等。

他们都是一个个具体的对

象，但我们可以发现他们都具备几个共有的特征，那就是能够直立行走和会使

用工具。

所以我们就可以把他们归纳在一起，并抽象地看做一个类——人类

2：

封装：

a：

早期的软件由于数据和程序混在一起，导致程序可读性很差，而且修改起来也

很困难。

许多数据都混在一块，而这些数据又被多个模块相互调用，因此某个模

块再改动摸个数据的时候常常会对整个程序产生无法预料的错误

b：

面向对象针对这个问题提出了数据的封装，他将每一个数据都封装在各自的

类中，又设置了多种访问权限，别的类可以在允许的情况下访问该类中的数据，

不允许的情况下则无法访问该数据，从而避免了非法操作和出错的可能性

3：

继承：

a：

正如前面所说，我们在发明一个新式发动机的时候不想重新制作一辆汽车，

因此继承这个概念就应运而生了，我们可以将该车定义为一个类，然后在声明

一个类，将该车的所有成员都继承过来，其中自然包括发动机，然后在改造这

个发动机，这样一辆新车就生产出来了。

4：

多态

a：

作为一名足球运动员，他们在射门以后可能会产生多种结果

b：

我们把这种不同的对象（不同的足球运动员）,调用相同名称的函数（射门）却可导

致不同的行为或者结果的现象称为多态性

c：

在这编程中经常使用，比如说你设计个拳击游戏，那么你定义的多个角色在

打出去一拳的时候通常会有多种行为反馈，一拳打空，一拳打倒对方，一拳打

在裁判的牙上，把牙齿打飞。

十：

类、对象、成员、函数

1：

我们上节所说的人类就是一个类，它包含很多对象，比如张三。

；李四。

赵钱孙李等

人都可算作人类的对象。

这些对象都拥有人类共同的功能和数据，比如身高、体重、年龄。

性别。

另外还会说话、吃饭。

睡觉等

*这些功能我们可看做是人类共有的方法或者函数，而具体化人类的身高、臂长的这些数据我们可看作是人类的成员变量

2：

这样我们就可以进一步地了解，类是由若干个变量和相关的函数组成的。

而对象则

可拥有这些变量和函数。

3：

形象例子：

一个硬盘可执行读写操作，这是它的主要功能，又叫方法和函数，他还有型号、容量和转速等数据，我们把它叫做变量。

二硬盘又有好多种品牌，如迈拓硬盘、希捷硬盘、西部数据硬盘等，我们把这些品牌看作电脑这个大类的对象。

这些对象都拥有硬盘类共有的功能和数据，比如希捷硬盘有型、容量和转速等数据，

这是硬盘类的共同数据，又叫成员变量，而且希捷硬盘有读取数据和写入数据的功能，这是硬盘类的共同方法，又叫成员函数

4：

每个对象都可将自己的数据进行封装，以避免别的对象修改。

比如说希捷硬盘某个型号的容量是80G，这个数据只是为希捷硬盘某个型号所拥有的，迈拓硬盘厂商不可能去修改希捷硬盘的容量，因为迈拓硬盘也有自己的容量，它可能是80G，也可能是180G，这是由迈拓硬盘的生产商自己来定义。

总结：

硬盘是个类，希捷硬盘是该硬盘类的一个对象，型号、容量和转速是该类的数据成员，读取数据、写入数据是该类的方法成员，又叫成员函数；数据成员和成员函数统称为该类的成员，对象拥有并且可以封装这些成员

5：

声明一个类

classHuman

{public:

voidGetStature（）;//声明一个函数//英文身高

voidGetWeight（）;

private：

intstature;

intweigth;

};

a：

public：

表示他后面的成员都是公有的，该类的对象可以直接访问这些成员

b：

private：

表示它后面的成员都是私有的，不能被对象直接访问，必须通过公有的成员函数才能访问

总结：

声明这个类并没有为人类分配内存，他只是告诉编译器：

人类是什么，它包含了那些类型的数据，功能是什么

，并告诉编译器该类有多大，大小=成员变量。

该类的方法不占用内存，因为我们没有为方法（声明的函数）声明类型，他们的返回值是void。

6：

定义一个对象

a：

humaMike；就定义了“huma”类下的一个叫“Mike”的对象

b：

类只是个抽象的名词，而对象则是实际的个体，比如说人类是泛指所有的人，而迈克却是一个具体的人，是一个活生生的人而你绝对不会把迈克和丹妮混淆，因为他们数据有着本质的不同

c：

HumanMike;

Mike.set_weight（50）;

Mike.get_weight（）;

d：

类是个抽象的名词，他不是具体的某个个体，因此我们无法对他进行赋值操作，正如无法对int类型赋值一样，因为int也代表一个类型，而不是某个具体的变量

Human.weight=100→错误HumanTom；Tom.weight=100；→对的；

f：

总结→函数是用来执行一定功能的代码块，成员函数则是只能被类的对象所使用的函数

7：

定义函数

a：

一般来说当我们定义了一个函数后，编译器就会在内存中为其创建一个指令集，当我们调用这和函数时，程序就会跳转到该指令集处，当该函数运行完毕后，程序又会返回到原来执行调用该函数的下一行继续执行。

假如对该函数执行了上百次调用，那么就要来回跳转上百次，和明显这是相当影响程序执行效率的。

b：

关键字“inline”，内联函数，inlineint函数名（）；

int函数名（）{程序语句};

好处：

这样编译器将不会创建真正的函数，而是将这个内联函数的所有代码拷贝到调用函数中，这样程序在执行调用该函数时就不需要来回跳转，自然就提高了程序运行时的效率。

坏处：

无形中增大了程序的体积建议→用于一些小的被调函数

c：

const在函数上的应用，不让某个成员函数修改变量的值例：

voidprint（）const{cout<<"a="<

8：

构造函数

**使用原因：

在创建某个类的对象时，由于对该对象的状态（数据）不是很明确，因此需要对其进行初始化。

比如说我们要在长方形这个类中创建一个对象，或者说新建一个长方形，那么我们首先要确定它的长和宽，假如我们无法确定它的长和宽，那么我们是无法造出一个长方形来的。

我们要创建这个长方形，就必须使用这个长方形类中一个用来构造该类所有的对象的函数--构造函数，由于该函数要在创建一个新对象时使用，因此他不可能存在于对象之后，那么我们就必须在类中对它进行声明和定义。

a：

定义的函数名和类名一样classHuman

{

public:

Human（charx,inty）

{

cout<<"正在构造一个人...."<

xb=x;

age=y;

}

voidshow（）const{cout<<"是"<

private:

charxb;

intage;

};

b：

假如没有构造函数，那么系统会为我们自动创建一个构造函数，该函数什么参数也没有，而且也不执行任何功能，它的作用只是构造一个对象

就好像rectangel（）{}

c：

可以有多个构造函数，同时有不带参数的和带参数的

9：

析构函数

a：

析构函数用于在对象被销毁后清除他所占用的内存空间，比如说他可以清除由构造函数创建的内存

b：

public：

~A（）{}注意：

1.析构函数跟构造函数一样不能有返回值

2.析构函数不能有参数

3.只能有一个析构函数

c：

每个对象在创建时都会自动调用该类的构造函数，这里调用了我们自定义的构造函数，程序结束时，对象a的生命也自然终止，编译器会自动调用该类的默认析构函数来释放掉

该对象所占的内存，如果用户自定义了，那就执行自定义的析构函数

d:

示例：

~Human（）{cout<<"这个人已经死了...."<

10：

数组对象：

Humana[2];

十一：

指针

1：

typeddfunsignedshortintut;相当于#define

2：

为什么使用指针：

a.处理堆中存放的大型数据

b.快速访问类的成员数据和函数

c.以别名的方式向函数传递参数

3：

栈和堆：

一般来说，程序就是与数据打交道，在执行某一功能的时候，将该功能所需要的数据加载到内存中，然后在执行完毕的时候释放掉该内存

数据在内存中的存放共分为以下几个形式：

a.栈区（stack）--由编译器自动分配并且释放，该区域一般存放函数的参数值、局部变量的值等.

b.堆区（heap）--一般由程序员分配释放，若程序员不释放，程序结束时可能被操作系统回收.

c.寄存器--用来保存栈顶指针和指令指针.

d.全局区（静态区）（static）--全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域.程序结束后由系统释放.

e.文字常量区--常量字符串就是放在这里的，程序结束后由系统释放

f.程序代码区--存放函数的二进制代码

4：

为什么使用堆：

函数参数和局部变量存放在栈中，当函数运行结束并且返回时，所有的局部变量和参数就都被系统自动清除了，

为的是释放掉他们所占用的内存空间.全局变量可以解决这个问题，但是全局变量永远不会被释放，而且由于全局变量

被所有的类成员和函数所共享，所以它的值很容易被修改.使用堆可以一举解决这两个问题.

优点：

堆是采用匿名的方式来保存数据的，只能通过指针才能访问到这些匿名的数据，因此它的安全形势最好的，

同时由于堆区中的内存是由程序员来分配和释放的，所以它的自由度也是最高的.

5：

堆与栈内存申请方式的不同

栈：

由系统自动分配，例如我们在函数中声明一个局部变量inta，那么系统就会自动在栈中为变量a开辟空间.

堆：

需要程序员自己申请，因此也需要指明变量大小

6：

堆与栈系统响应的不同

栈：

只要栈的剩余空间大于所申请空间，系统为程序提供内存，否则将提示overflow，也就是栈溢出

堆：

系统收到程序申请空间的要求后，会遍历一个操作系统用于记录内存空闲地址的链表，当找到一个空间大于所申请空间的堆结点后，

就会将该结点从记录内存空闲地址的链表中删除，并将该节点的内存分配给程序，然后在这块内存区域的首地址处记录分配的大小，

这样我们在使用delete来释放内存的时候，delete才能正确地识别并删除该内存区域的所有变量，另外，我们申请的内存空间与堆结点

上的内存空间不一定相等，这时系统就会自动将堆结点上多出来的那一部分内存空间回收到空闲链表中.

7：

堆与栈空间大小的不同

栈：

在windows下，栈是一块连续的内存区域，它的大小是2M，也有的说是1M，总之该数值是一个编译时就确定的常数.是由系统预先根据栈顶

的地址和栈的最大容量定义好的.假如你的数据申请的内存空间超过栈的空间，那么就会提示overflow.因此，别指望栈能存储比较大的数据

堆：

堆是不连续的内存区域.各块区域由链表将它们串联起来，关于链表的知识将在后面的章节中讲解，这里只需要知道链表将各个不连续的内存区域

连接起来，这里串联起来的内存空间叫做堆，它的上限是由系统中有效的虚拟内存来定的.因此获得的空间比较大，而且获得空间的方式也比较灵活.

8：

堆与栈执行效率的不同

栈：

栈由系统自动分配，因此速度较快.但是程序员不能对其进行操作

堆：

堆是由程序员分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来很方便

9：

堆与栈执行函数是不同

栈：

a.在函数调用时，第一个进栈的是被调用函数下一行的内存地址，其次是函数的参数，假如参数多于一个，那么次序是从右往左，最后才是函数的局部变量

b.由于栈的先进后出的原则，函数结束时正好与其相反，首先是局部变量先出栈，然后是参数，次序是从左到右，这时所有的变量都已出栈，指针自然地指到

第一个进栈的那行内存地址，也就是被调函数的下一行内存地址.程序根据该地址跳转到被调函数的下一行自动执行

c.由于栈的先进后出原则，所以它永远都不可能产生内存碎片，因为上面的盘子没有拿完之前，下面的盘子是不可能抽出的，他们排列的是如此有序，

弹出时也非常有序，碎片想要产生也是非常艰难的.

堆：

堆是一大堆不连续的内存区域，在系统中由链表将它们串接起来，因此在使用的时候必须由程序员来安排.它的机制是很复杂的，有时候为了分配一块合适的内存，

程序员需要按照一定的算法在堆内存中搜索可用的足够大小的空间，如果没有满足条件的空间，那么就要向系统发出申请增加一部分内存空间，这样就才有机会分

到足够大小的内存，然后将计算后的数值返回.显然，堆运行效率比栈要低得多，而且也容易产生碎片，但是好处是堆可以存储相当大的数据，并且一些细节也可以由程序员来安排.

10：

堆的使用

a.堆是一大堆不连续的内存区域，在系统中由链表将它们串接起来，它不像栈，你可以为他其中的某个内存单元命名，为了数据隐秘起见，堆中的每个内存单元都是匿名的，因此你必须先在堆中申请

一个内存单元的地址，然而把它保存在一个指针中.这样你只要使用该指针才可以访问到该内存单元的数据.

b.采用这种匿名的内存方式，而不是使用公开的全局变量，好处是只有使用特定的指针才能访问特定的数据.这样就避免了任何试图修改它的非法操作.

11：

创建堆

a.首先创建一个堆，然后定义一个指向该堆的指针.这样就只能通过该指针才能访问堆中数据

b.在C++中使用关键字new创建一个堆并分配内存，在new后面跟一个要分配的对象类型，编译器根据这个类型来分配内存.

c.例子：

int*p;

p=newint（会返回一个地址）;在堆中创建了4个字节内存

12：

用指针删除堆中的空间

a.由于使用new创建的内存空间不会被系统自动释放，因此假如你不去释放它，那么该区域的内存将始终不能为其他数据所使用，

为指向该内存的指针是个局部变量，当定义该指针的函数结束并返回时，指针也就消失了，计算机就再也找不到该区域的内存了，就好像丢失了一样，

我们把这种情况叫做内存泄露.所以就必须用delete（deletep）最好给它清零（p=0）

b.内存泄漏：

int*p=newint;

//deletep;

int*p=newint;

13：

在堆中创建对象Human*p=newHuman;

第二行使用new创建一块内存空间，同时有调用了Human类的默认构造函数来构造一个对象，他所占用的内存大小根据Human类对象的成员变量来决定，假如该类有两个int型成员变量，那么该对象占用

为2乘以4等于8个字节.构造函数一般都是在创建对象时被自动调用，它的作用就是初始化该对象的成员数据.本行的右半部分创建一个对象完毕后，跟着将该对象的内存地址赋给左边的指针变量p.

注意：

在堆只创建对象是匿名的，它没有名字，我们无法直接访问它，只能通过指针来访问它.

14：

在堆中删除对象

直接删除指向该对象的指针，这样会自动调用对象的析构函数来销毁该对象同时释放内存.

15：

访问堆中的数据成员

a.我们要访问对象的数据成员和函数，我们使用成员运算符"."

b.（*p）.get（）;使用括号是为了保证先使用*号独缺p的内存地址中的值，即堆中对象，然后再使用成员运算符"."

来访问成员函数get（）.

c.成员指针运算符"->".p->.get（）该符号可以实现读取对象的内存地址并且访问该对象的成员的作用.

16：

在构造函数中开辟内存空间

a.我们可以将类的数据成员定义为一个指针，然后在析构函数中开辟新空间，将该空间的地址赋给指针.而在析构函数中释放该内存.

b.private:

int*p;Human（）{p=newint（999）}

c.一个在堆中创建的对象通过成员指针在创建新的空间用来保存数据并没有什么意义.因为在堆中创建对象时已经为它的所有数据成员提供了保存空间.

17：

this指针

a.对象要在属于自己的每个成员身上写下自己的名字，以证明该成员是自己的成员，而不是别的对象的成员.

this变量帮助对象做到这一点，this变量记录每个对象的内存地址，然后通过间接访问运算符->访问该对象的成员.

b.这说明this变量记录每个单独的对象的内存地址，而this指针则指向每个单独的对象.因此不同的对象输出的this变量的内存地址也不同.

c.由于this指针保存了对象的地址，因此你可通过该指针直接读取某个对象的数据，它的作用将会在后面的重载运算符中得到演示，现在我们只需要知道

this变量保存的是对象的地址，那么this指针就是指向对象的指针.另外this指针的创建与删除由编译器来完成.

d.需要注意的地方：

因此在删除一个指针后，我们一定要将其赋为空.虽然使用空指针是非法的，容易使程序崩溃，但是我们宁愿程序崩溃，也不愿意调试起来困难.

由于这程序运行以后立即崩溃了，而空指针使用不当又会导致程序崩溃，因此我们立即明白是哪里出了错，从而迅速纠正它.

18：

指针的各种常量

a.int*constp;常量指针，他自身的值是不可改变的，但是它指向的目标却是可以改变的.

b.constHuman*p指向常量的指针，只是限制我们修改它指向的目标，他自身是可以被修改的.

c.constHuman*constp;指向常量的常指针，都不可修改.

十二：

引用

1：

什么是引用