c++从入门到实践

这段时间学习了C++从入门到实践，今天从头到尾过了一遍，总结如下：

C++从入门到实践

第1篇面向过程的C++编程

第一章 C++预备知识

起始于80年代美国贝尔实验室

 

 

第2章数据类型

数据类型：Int整型，实数型，浮点型float，双精度double

逻辑运算:与&，或||，非！，游戏啊你非>与>或

字符和字符串：char var；//8位长计算机保存字符是以ASCII码形式保存的；

转义符：\0表示空，\n表示换行，\r表示回车等

字符串：字符用‘’，而字符串用“”；

双精度64位；

 

 

第3章变量和常量

内存中存储的数据不仅可以读取，还可以修改和写入，称为变量；

静态数据又称为全局数据，在内存中一直存在，动态变量只在运行时侯向内存申领空间，结束后系统自动释放；

常变量：const int var=value；

 

 

第4章运算符

算术运算符：+、-、*、/、%（取余数）、++、--；

逻辑运算符：&&与、或||、非！；

关系运算符：>,<,==,!=,…;

位运算符：按位&、|、~,^异或、<<按位左移、>>按位右移；

赋值：=；

 

 

第5章表达式

分类：算术表达式、关系表达式、条件表达式、赋值表达式、逗号表达式、逻辑表达式；

条件语句结果是bool类型，所以这种表达式结果会转为bool类型；

类型转换：隐式类型转换（int a；float b；b=a+b；return b；）

显示类型转换：（int） a；//强制转为int类型；

 

 

第6章语句

顺序结构；条件；循环。。。。。；

选择：if和switch；

循环：for，while，do…….while；

跳转语句：break，continue，goto；

Switch（）

{

Case1：

。。。。

Break；

Case2：

。。。

Break；

Default：

。。。。

}

 

While（）{}

Do{}while（）；

 

标签语句：

Int num；

READ_NUM:cin>>num;

If(num<0)

Goto READ_NUM;

Cout<<”gagaga”;

空标签语句:lable_name:;

多重标签：label_name1:lable_name2:leble_name3:statemaent;

标签其实就是地址

READ_NUM:cin>>num;

P=&&READ_NUM;//因为标签是无符号的，所以用&&

If（num<0）

goto p;

continue语句，停止执行循环体中剩下的语句，跳到语句头继续执行下轮循环；

do{

cin>>f;

if(f<=0){

cout<<”wrong”<<endl;

continue;

}

I++;

cout<<f<<endl;

if(i>2)

break;

}while(true)

 

Goto 标签名；

 

 

第7章指针

整型占用4个字节，每个字节为8位，即32位；内存单元按字节来算的，如果是4个字节，则由低到高顺序排列；

定义：int *p；

char *pChar；

float *pvoid;

bool *Pbool1,pbool2;//定义了两个指针；

sizeof（int）；//这里int和char都是4个字节，即为4，4*8=32位。

如果指针指向整形数据就是整型指针，如果指向结构体就是结构体指针，如果指向函数就是函数指针，指向数组就是数组指针。

指针数组VS数组指针：

Char *pCharArray2[2];//指针数组；

Char（*pCharArray1）[2];//数组指针；

多级指针：int *p;   int **p;   int ***p;

int    var;

int *p;

const int *p1=&var;//指针所指内容不可变，但是指针指向可变；

int const *p2=&var;//同上

int *const p3=&var;//指针指向不可变，内容可变；

const int *const p4=&var；//同上

指针都要初始化，否则就是野指针！指向随机。初始化：

1）什么都不指：int *p=NULL；int *p=0；如果输出该指针的指向内容则出错！因为，什么都没指；

2）内存地址:

a.用另一个指针地址初始化：

char *p1=p2；//表示用已经定义的指针p2来初始化新定义的指针p1；也可以如此定义，

char *p1；

p1=p2；//这样p1和p2指针的指向相同；

b.用变量的地址初始化：

char var；

char *p=&var；

c.用new分配内存单元

p=new int;

p=new int[2];//给指针p分配2个单元的int类型内存单元；

delete p;

delete []p;//表示释放单元p的存储；

指针需要在申领空间之后才能赋值，如：

Char* p;

P=new char;

*p=’a’;

Delete p;

d.用malloc分配内存空间

int *p；

p=(int *)malloc(sizeof(int)*n);

free p;//如果申请内存单元成功，则返回所申请内存空间的首地址；

 

a example:

#include”iostream”

Using namespace std;

Int main(){

Int *p1,*p2,*p3,*p4;

Int var=100;

P1=&var;

Cout<<p1<<endl;

Cout<<*p1<<endl;

P3=new int;

*p3=200;

Cout<<p3<<endl;

Cout<<*p3<<endl;

P4=(int *)malloc(sizeof(int));

*p4=300;

Free p4;

Delete p3;

Return 1;

}

指针的加1和减1是指针向下移动一个数据类型！比如，int和char 则移动四个字节，而double则移动8个字节。

引用：不同变量名指向同一内存单元

Int x=100;

Int &ref=x;

 

 

第8章复合类型

由基本数据类型组合成更加复杂的数据类型；

动态数组：数组长度不定的数组，程序运行时，根据用户输入来分配一个动态数组的内存。

字符数组VS字符串数组：字符数组是以字符为数组元素的；而字符串数组则最后一个空字符为\0；

数组名表示数组首地址，所以数组名就是指向该数组第一个元素的指针。

指针数组:数组元素都是指针类型数据的数组称为指针数组。

Char *p[4]={“what”,”is”,”ur”,”name”};定义了数组p[4]，然后类型为指针*；

数组的使用：索引方式和指针方式：通过下标来访问数组元素的方式称为索引方式；

通过指针来访问人数组元素的方式成为指针方式，如*p，*p+1；*(x+i)等价于x[i]；

枚举类型：对象的取值可以一一列举出来，enum weekday{Monday,Tuesday,。。。。}；

结构体：struct box{….}；

Box a；

a.x=…;

a.y=….;

struct [type_name]{…}[var1,var2….varn];//变量的名字；

就类似于：type_name var1;

Var1.x=….;

Var1.y=…;

共用体：就是多个数据共享一块内存空间；

Union a{}[var1];   a   p;

p.x=…;

p.y=….;共用体在内存空间中相互覆盖，所用空间为数据成员占空间最多的决定！

自定义类型：typedef old_type new_type;

Typedef struct tagpoint{int x;

Int y;

}p;//通过自定义把结构体tagpoint定义为p；

P a；//定义p类型的a；

 

 

第9章  函数

定义：返回类型  函数名  (参数){函数体}//如果函数不需要返回任何值，那么返回类型为void；

递归函数：函数直接调用自己或者通过其他语句间接调用自己，称为函数的递归调用。

指向函数的指针：int (*func_pointer)(int,int);//定义了一个函数指针func__pointer，他的两个形参是Int类型，返回值也是int类型；

函数作为参数：需要利用函数指针来作为函数的参数

Int findmax(const double *p,cons tintcount){}

Double Maximum(const double *p,cons tintcount,double (*findmax)(const double *,const int))

 

 

第10章 C++的输入/输出

Iostream库；

 

第11章  面向过程的程序设计案例

面向过程=模块+数据结构=函数+数据结构

其主要思想就是将一个实际的工程案例分为若干模块，然后每一模块有若干函数，最后拼凑为一个完整的函数。包括写一个数据结构的头文件.h和功能函数头文件.h和函数的实现文件.cpp。

 

 

 

 

 

 

 

 

 

 

 

 

 

第2篇  面向对象的C++程序设计

第12章  面向对象

对象是具体的东西，类是一个抽象的东西。表示具体和一般的关系；

类是一组对象的数据结构和操作中相同部分抽象出来的集合，类的形成过程是一个从特殊到一般，从具体到抽象的归纳总结过程。

类可以继承和派生；

类是对对象的抽象和泛化，对象是类的具体和特列；类本身不携带任何数据，不占用内存空间，但是占据磁盘空间，是一个静态的概念。对象一直等到执行时才占用存储空间；

面向对象的三个重要特征：封装、继承、多态。封装是指属性和行为的信息隐藏；继承是指一种对象类型引申到另外一种对象类型；多态是指不同的对象，收到同意消息可以产生不同的结果。

 

 

第13章  封装

类的声名、属性、方法、构造函数、析构函数、静态成员、友元、修饰符、指向类成员的指针、嵌套类、类的书写、对象的定义、对象的使用、this指针。

Class p{…public:

Private;

……

P();//构造函数

~p();//析构函数，负责对象销毁后的善后工作

}

类有三种成员：公有成员、私有成员、保护成员

私有和被保护成员不能被外面对象直接调用！

Class person {

Int id;

Int age;

Char* name;

Void hi();

}

Void person::hi()

{…}//定义类的函数hi

每当对象被创建时，他是否能够被正确的初始化，在C++中是通过构造函数来解决的。构造函数是一个特殊的类成员函数，其函数名与类名相同。功能是对对象的初始化。

类中一旦定义了静态成员static，那么在声明对象的时候，不会为每个对象都拷贝静态成员，而是类已经共享了，大家都可以用；

友元：函数为一个类的友元，那么该函数可以调用类中的私有成员，除此之外，也可以定义一个类为另外一个类的友元friend；

Class A{

Public:int a;

Int b;

Friend int f();//定义友元函数f，返回类型为int，该函数不属于类A，但是友元函数f可以访问类A的私有成员；

Private：

Float x;

Float y;

Friend classB;//声明友元类B，类B可以访问A的所有成员；

}

 

修饰符：const和mutable，其中const不希望类的对象或类的属性在程序运行中被修改，而mutable表示总是可以修改。

 

指向类成员的指针

a.指向类数据成员的指针：students1;

int student::*p=&student::math;//定义指针p执行类student的数据成员math，其中math为非静态；

s1.*p=100;//设置非静态数据成员的属性

int *p1=&student::Chinese;//指向静态属性

*p1=10；//设置静态属性

b.指向成员函数的指针：

student s1;

float(student::*pf1)()=&student::f1;//指向非静态成员函数的指针

(s1.*pf1)();//调用指向非静态成员函数的指针

Void (*pf2)()=&student::f2;//指向静态成员函数的指针

Pf2();//调用静态成员函数

一个类在另一个类中定义，这样的类称为嵌套类；

对象：

对象名.成员名；//.是运算符，表示普通对象对成员的引用

对象名->成员名；//指针运算符，表示指针对象对成员的引用

先定义类->再定义对象->通过对象对类内数据成员或者函数成员的访问进行初始化赋值。

 

 

第14章  命名空间和作用域

命名空间（namespace）是一种将相关类型进行分组的逻辑命名方案。

为名字分组，这样避免同一名字多次用到。但如果强调在哪一个空间下，即使名字相同也不会出错。

两种方法应用命名空间：

a.使用域限定符：：，该符号一个是对类成员函数定义，如studen::f1();对类成员函数的调用。

如int student ：：*p=&student::f1（）；

B.using namespace name_space;

 

 

第15章  继承和派生

继承和派生是父类和子类的关系；

继承可以继承父类数据成员；继承父类成员函数；增加新的数据成员，增加新的成员函数；重新定义基类已有的成员函数；改变现有成员的属性特征。

构造函数和析构函数不能被继承，需要重新定义。

派生：class 子类：派生方式基类；

其中派生方式有保护，私有。。。。

Class student:protected person{}

//以保护方式继承student基类。

Classname::class name(参数列表){}//定义类的构造函数

Classname::~class name(){}//定义类的析构函数

同名使用：如果父类中的方法是虚拟的，子类可以重新定义它；如果不是虚拟的，则子类的方法将覆盖父类的同名方法。想在子类中访问被覆盖的同名成员，要用域名限定符来指定。

单重继承：从单个基类派生出的子类；

Class 子类：派生方式 基类；

多重继承：一个对象从多个基类派生而来

Class classname：继承方式 baseclass1，继承方式 baseclass2，。。。。。。{}；

多重继承的二义性问题，就是继承多个基类会导致基类中有多个重名成员或者基类与子类重名，至少2个基类继承了同一个祖先类。

虚继承与虚基类：class classname：virtual 继承方式baseclass{}；//需要加；在末尾。

Class base{int x;};

Class A:public base{int y;};//公共继承方式

Class B:public base(int z);//

Class c：public A，public B//多重继承

{in s}；

Int main（）{

C cc；

Cc.x=12;//不对，有歧义

}

但是如果用虚拟继承就不会有歧义，即二重性。

Class base{int x;};

Class A:virtual public base{int y;};//公共继承方式

Class B:virtural public base(int z);//

Class c：virtural public A，public B//多重继承

{in s}；

Int main（）{

C cc；}//没有二重性问题，因为是虚拟继承

 

 

第16章  多态

虚函数、抽象类、运算符重载、函数重载、流重载、覆盖

纯虚函数：virtual int f（）=0；//是为了允许用基类的指针来调用子类的这个函数，并不表示该函数为不被实现的函数。

抽象类：带有纯虚函数的类。

 

 

第17章  模板

类模板、函数模板、模板的实例化、模板的作用、基于模板的元编程

Template class s//定义模板类s

S getmax(s x,s y){return(x>y?x:y);}//定义s类型的函数getmax和s类型的x和y。

类模板定义：

Template(形参)class classname{

//类声明体

}

Template（形参）返回类型classname（）：：成员函数（）{

函数体

}

//这种类模板只是对类的描述，不是具体的类。建立类模板之后，可以通过创建类模板的实例来使用该类的模板。

类模板VS模板类//一个是模板，不是类，另一个是实例化的类。

 

 

第18章  面向对象的程序设计案例

面向对象是以对象为载体，对象间通信为媒介的软件开发思想。

问题定义、需求分析、面向对象分析与设计、编码和测试。

 

 

 

第三篇  高级篇

第19章  string类

String类为字符串，是c++中处理字符串的类。

 

 

第20章  异常处理

异常处理提供一些标准的方法来处理这些异常。如除数为0、数组越界或者内存空间申请失败等。

 

 

第21章  内存管理

内存分三类：堆、栈和静态存储区。堆内存由程序动态申请和释放、栈内存和静态存储区则有系统自动分配和释放。

堆即编程时候用的new和delete；malloc和free；

栈是系统维护的先入后出原则，用来保存函数中的临时变量一级函数调用时的现场；

静态存储区勇于保存全局变量、常量、以及static修饰的静态变量。编译时候就确定了所需内存空间的大小，由系统来管理和释放，不需要用户干预。

栈:void main(){

Int a;//在栈上分配空间

Int b;

a=25;//赋值

b=11;

}

 

 

 

第22章  预处理

常见的预处理指令有文件包含、条件编译、布局控制和宏替换4中。

文件包含是指将特定的文件引入到源程序中；

条件编译是指按照给定的条件编译相应的代码；

布局控制是指设定编译器的状态或者指示编译器完成一些特定的动作；

红替换是指用一个标识符来表示一个字符串。

<>表示引用标准库头文件，编译器只搜索包含标准库的文件目录；

““表示自定义头文件，搜索正在编译的源文件所在目录，找不到时在搜索包含标准头文件目录。

布局控制指令时#pragma，是最为复杂的一条指令。针对所使用的平台和编译器的不同而有所不同。

宏定义就是全局替换；

条件编译：#if、#eif、#ifndef、#ifdef、#endif等。

 

 

第23章 错误与调试

错误又称为bug，二战期间，哈伯中尉制造了马克二计算机，一天死机了，最后发现是70号继电器有个飞蛾被打死了。此后计算机界习惯将异常事件都称为bug。

错误：语法错误、链接错误、运行时错误。

 

 

第4篇

第24章  数据结构案列

 

 

第25章  网络应用案列