C++基础入门-上

第一章 初识C++

1.第一个C++程序

/*include:引入库文件并替换
	namespace:命名空间 
	main:主函数 程序的入口
	():函数固定写法，可以放参数 
	int:函数的返回值类型
	{}：函数主体
	；程序语句的分割
	cout:输出语句
	endl:换行语句
	return:函数返回结果 
*/ 
#include
using namespace std;
int main(){
	cout<<"hello world"<<endl;
	return 0; 
}

2.C++程序编译过程及原理

• 编译过程
• 预编译
  展开头文件、宏定义；#define #ifdef #include;若有.h文件，也会包含进来。
• 编译
  已经预编译的文件编译成汇编代码的过程，整个过程包括语法、词法的分析，和一些优化操作。
• 汇编
  变成目标代码，二进制文件。
• 链接
  将单个编译后的文件链接成一个可运行文件。
• 过程框图
  

3.C++能做什么

• 设备驱动程序
• 操作系统领域
• 科学计算
• 嵌入式领域
• 游戏开发领域
• 虚拟现实
• 网络软件

第二章 C++基础语法

1.注释的好处

被注释的代码不会被执行，编译器也不会进行编译

• 提高代码的可读性
• 方便调试代码
• 禁止无关程序执行

单行注释

//我是单行注释

多行注释

/*
我是注释不会被编译
多行注释
*/

2.C++基础梳理

• 表达式
  某个动作称之为表达式
  比如：int a=10; int b=20; int c=a+b
• 语句
  以分号结尾的表达式称之为语句
  int a=10;
  int b=20;
  int c=a+b;
• 标识符
  上面的a、b、c称之为标识符。它定义了计算机内存的一块区域，与名称相关联。10、20为常量
• 赋值
  int a=10；其中a=10为赋值语句，把10赋值给a相关的区域。
• 入口函数
  C++程序从main()函数的第一条语句开始执行
• 函数
  函数由四部分组成 返回类型 函数名 参数表 以及函数体 前三部分合起来称为函数原型。参数表由小括号括起来 包含一个或多个由逗号分开的参数 函数体由一对花括号括起来，由程序语句序列构成。
• 输出函数
  输出内容，cout<<""<

3.C++必知必会

• void
  无值型，void类型其实是一种用于语法性的类型，而不是数据类型，主要用于作为函数的参数或返回值，或者定义void指针，表示一种未知类型。
  func(void);
  在c++中如果参数列表为空，默认的参数类型即为void,但建议没有参数时使用void以提高程序的可读性。

#include
using namespace std;
int main(void){
	cout<<"hello world"<<endl;
	return 0; 
}

• 头文件
  abc.h 可以声明变量和函数，让多个.cpp文件引用代码
• 源文件
  abc.cpp 写业务逻辑的文件
• #include
  #include 是预处理器指示符它把iostream的内容读入我们的文本文件中。iostream是输入输出流库标准文件，包含cout的信息，它对我们的程序是必需的。预处理指示符用#号标识。
• namespace
  命名空间，减少和避免命名冲突，指的是标识符的可见范围。using namespace std;using指示符告诉编译器要使用在命名空间std中声明的名字。

4.C++头文件的作用

• 一般在头文件中，只声明函数和变量，而不进行定义
• 声明： extern int a;和int f();
• 定义：如果写上int a；或者int f(){}
  例子如下：

//abc.h
#include
using namespace std;
/*
声明工作能力
*/
int work();
 

//work.cpp 
#include "abc.h"
int work(){
	cout<<"在学校";
	return 0;
}

//main.cpp
#include "abc.h"
#include
using namespace std;
int main(void){
	work();
	cout<<"学习"; 
	return 0;
}

5.输入输出初探

C++的输入/输出功能由输入/输出流iostream 库提供，所以要使用输入输出必须添加头文件#include< iostream >

• 输出 cout
  输出操作符：<<
  语法：cout<<表达式1<<表达式2<<表达式3…表达式n;
• 换行符 endl
• 输入 cin
  输入操作符：>>
  语法：cin>>变量1>>变量2…变量n;
  示例：

#include
using namespace std;
/* 
endl为换行符 
*/
int main(void){
	cout<<"hello 你好"<<endl; 
	
	//声明一个变量存储空间 
	int x; 
	
	cout<<"请输入内容："<<endl;
	
	//输入内容存储到x中去 
	cin>>x;
	
	//取出存好的数据 
	cout<<"取到x:"<<x<<endl;
	return 0;
	}

第三章 C++数据类型

1.进制基本介绍

进制就是进位计数制，对于任何一种进制X进制，就表示每一位置上的数运算时都是逢X进一位。十进制就是逢十进一，十六进制就是逢十六进一，以此类推，X进制就是逢X进位。
常见进制

• 二进制
  由两个数码0、1组成，二进制数运算规律是逢二进一。
  
• 八进制
  一种以8为基数的计数法，逢八进一。O代表八进制
  
• 十进制
  满十进一
• 十六进制
  十六进制在数学中是一种逢16进1的进位制。一般由数字0到9和字母A到F（a~ f）表示，其中：A~F表示10 ~15，这些称作十六进制数字。
  例：0x5A3 其中“x”则代表十六进制

2.原码反码补码

• 原码
  ⑴原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值，比如8位二进制：
  [+1]原=00000001
  [-1]原=10000001
  ⑵原码是人脑最容易理解和计算的表示方式

• 反码
  ⑴ 正数的反码是其本身
  ⑵ 负数的反码是在其原码的基础上，符号位不变，其余各个位取反。
  [+1]=[00000001]原=[00000001]反
  [-1]=[10000001]原=[11111110]反
  ⑶ 可见如果一个反码表示的是负数，人脑无法直观的看出来它的数值，通常要将其转换成原码再计算。

• 补码
  ⑴ 正数的补码就是其本身
  ⑵ 负数的补码是在其原码的基础上，符号位不变，其余各位取反，最后+1。（即在反码的基础上+1）
  [+1]=[00000001]原=[00000001]反=[00000001]补
  [-1]=[10000001]原=[11111110]反=[11111111]补
  ⑶ 对于负数，补码表示方式也是人脑无法直观看出其数值的，通常也需要转换成原码再计算其数值

• 转换
  ⑴ 已知原码求补码
  X为负数。求其反码时，符号位不变，数值部分按位取反；求其补码时，再在其反码的末位加1.
  X的原码为10110100B
  [X]反=11001011B，[X]补=11001100B
  ⑵ 已知补码，求原码
  对 二进制数来说，先减1后取反和先取反后加1得到的结果是一样的，故仍可采用取反加1的方法。
  已知[X]补=11101100，求[X]原。[X]原=10010100

3.基本数据类型之整型

即整数类型

• 分类
  按符号分有符号和无符号
  按长度分普通整型、短整型、长整型
• 整型类别
  
• 代码显示

#include
using namespace std;
int main(void){
	cout<<"int:"<<sizeof(int)<<endl;
	cout<<"unsigned int:"<<sizeof(unsigned int)<<endl;
	cout<<"short int:"<<sizeof(short int)<<endl;
	cout<<"unsigned short int:"<<sizeof(unsigned short int)<<endl;
	cout<<"long int:"<<sizeof(long int)<<endl;
	cout<<"unsigned long int:"<<sizeof(unsigned long int)<<endl;
	return 0;
}

4.基本数据类型之单浮点型

• 浮点型
  单精度
  双精度
  长双精度
• 单精度
  float x=2.59f
  使用关键字float，后面要添加f，内存占4个字节。
  注意：一定要在后面添加f否则默认是双精度
• 代码显示

#include
using namespace std;
int main(void){
	float x=2.59f;
	cout<<"float:"<<sizeof(float)<<",x:"<<x<<endl;
	return 0;	
}

• 单精度存储方式
  存储方式遵从IEEE的规范
  
  在存储中都分为三个部分：符号位、指数位、尾数部分
  符号位：0代表正，1代表负
  指数位：用于存储科学计数法中的指数数据，并且采用移位存储
  尾数部分：尾数部分
• 算出对应的十进制数
  0 10000010 01000100000000000000000
  第一步：符号位为0，表示正数；
  第二步：指数位为10000010，换算成十进制130，所以指数为130-127=3；
  第三步：尾数位为01000100000000000000000，换算成十进制为（1+1/4+1/64），尾数部分都要加1；
  十进制数值为：2^3*(1+1/4+1/64)=8+2+1/8=10.125

5.基本数据类型之双浮点型

• 双浮点型
  使用关键字double，内存中占8个字节
• 声明一个双浮点数
  double a=5.63
• 代码显示

#include
using namespace std;
int main(void){
	double a=5.63;
	cout<<"double:"<<sizeof(double)<<",a:"<<a<<endl;
	return 0;
}

• 双精度的存储方式
  
  在存储中都分为三个部分：符号位、指数位、尾数部分
  符号位：0代表正，1代表负
  指数位：用于存储科学计数法中的指数数据，并且采用移位存储
  尾数部分：尾数部分

6.基本数据类型之字符型

采用关键字char，字符数据使用单引号包围，占用一个字节，取值范围-128~127。

• 定义一个字符
  char ch1=‘a’;

#include
using namespace std;
int main(void){
	char ch1='a';
	cout<<"char:"<<sizeof(char)<<",ch1:"<<ch1<<endl;	
	return 0;
}

• 代码显示
  
  字符数据在内存中存储的是字符的ASCII码，即一个无符号整数，所以可以直接把整数赋值给字符变量。
  比如：
  char ch1=‘a’;
  char ch2=97;
• 代码显示

#include
using namespace std;
int main(void){
	char ch1='a';
	char ch2=97;
	cout<<"char:"<<sizeof(char)<<",ch1:"<<ch1<<endl;
	cout<<"char:"<<sizeof(char)<<",ch2:"<<ch2<<endl;
	return 0;
}

7.基本数据类型之宽字符型

• 宽字符型
  关键字wchar_t，占用2个字节。一种扩展的存储方式。
  char是8位字符类型，最多只能包含256中字符，许多外文字符集所含的字符数目超过256个，char型无法表示。
  wchar_t数据类型一般为16位或32位，但不同的C或C++有不同的规定。
• 代码显示

#include
using namespace std;
int main(void){
	wchar_t ch3='b';
	cout<<"wchar_t:"<<sizeof(wchar_t)<<",ch3:"<<ch3<<endl;
	return 0;
}

8.基本数据类型之布尔型

bool类型用来表示真假，也即是1、0，占用1个字节。

• 代码显示

#include
using namespace std;
int main(void){
	bool a=true;
	bool b=1;
	bool c=false;
	bool d=0;
	cout<<"bool:"<<sizeof(bool)<<",a:"<<a<<endl;
	cout<<"bool:"<<sizeof(bool)<<",b:"<<b<<endl;
	cout<<"bool:"<<sizeof(bool)<<",c:"<<c<<endl;
	cout<<"bool:"<<sizeof(bool)<<",d:"<<d<<endl;
	return 0; 
}

9.派生数据类型

• 指针类型
  通常所说的指针就是指针变量，它是一个专门存储地址的变量，变量的指针主要指变量在内存中的地址。int a=10; int* p; p=&a;

• 枚举类型
  枚举就是取有限个值，确定列举出来的几个值。
  比如周一到周六 enum Week{Monday,Tuesday,.....Sunday};

• 数组类型
  将同一类型的数据按照一定的形式有序的组织起来，这些有序数据的集合就称之为数组。

• 结构体类型
  由各种数据类型组合起来的数据集合

struct man{
	int age;
	char name[20];
	short sex;
}

• 共同体类型
  将不同数据项组成一个整体，和结构体有点类似，但是在内存中占用首地址相同的一段存储单元。注意：每个瞬间只能存储一种数据类型

union myClass{
	int a;
	char b;
	float c;	
};

• 类类型
  万物皆是类型，皆是对象。

10.typedef关键字使用

可以用typedef为一个已有的类型取一个新的名字。
语法: typedef type newname;
例: typedef int abc;

• 代码显示

#include
using namespace std;
int main(void){
	typedef int myint;
	myint a=23;
	cout<<"myint:"<<sizeof(myint)<<",a:"<<a<<endl;
	
	typedef float myfloat;
	myfloat b=2.33f;
	cout<<"myfoat:"<<sizeof(myfloat)<<",b:"<<b<<endl;
	
	typedef double mydouble;
	mydouble c=2.33;
	cout<<"mydouble:"<<sizeof(mydouble)<<",c:"<<c<<endl;
	
	typedef char mychar;
	mychar d='u';
	cout<<"mychar:"<<sizeof(mychar)<<",d:"<<d<<endl;
	
	typedef bool mybool;
	mybool e=false;
	cout<<"mybool:"<<sizeof(mybool)<<",e:"<<e<<endl;
	return 0; 
}

11.数字型常量

• 定义
  程序运行中不可改变的值

• 常量的类型
  

• 整型常量
  比如 0 3 100 -2

• 进制表示
  二进制
  int i=0b1101;//13
  需要在常数前面加0b来代表二进制
  八进制
  int k=012;//10
  需要在常数前面加0来代表八进制
  十六进制
  int h=0x1a;//26
  需要在常数前面加0x来代表十六进制

• 浮点型常量
  由整数和小数组成
  小数方式
  double a=23.56;
  指数方式
  double b=2.14e2;//214

• 布尔型常量
  bool ,真和假。bool a=true;

• 宏定义常量
  例：#define PI 3.1415926

#include
using namespace std;
//宏定义
#define PI 3.14 
int main(void){
	cout<<"PI:"<<PI<<endl;
	return 0; 
}

12.字符常量

字符常量是用单引号括起来的一个字符。例：char c=‘a’; 其中a就是一个常量。

• 转义字符
  转义字符是特殊的字符常量，用\代表转义开始
  
  代码显示

#include
using namespace std;
int main(void){
	//警报铃声 
	cout<<"\a"<<endl; 
	// \n为换行符 
	cout<<"hello\n"; 
	return 0; 
} 

• 字符串常量
  字符串常量是用双引号括起来的字符序列。例：“abc”
  字符串常量存储
  系统会在字符串的末尾添加一个\0作为结束标志
  

13.字符常量和字符串常量的区别

using namespace std;
int main(void){
	cout<<"字符常量A："<

• 区别总结
  1.字符常量使用的单引号，字符串常量使用的双引号
  2.长度不同。字符常量只能用单引号括起来，也即是用1个长度，字符串长度可以为0，但是需要注意即使字符串常量只有一个字符，它的长度也是2因为还有一个\0。
  3.存储的方式不同。字符常量存储的是ASCII，而字符串常量 存储的是有效字符还要存储\0。

14.变量是什么

在程序运行中可以改变的量。

• 标识符
  也就是变量的名字
  命名规则：
  (1) 由字母、数字、下划线组成，不能以数字开头。
  (2) 大小写字母代表不同的含义。
  (3) 不能使用内置关键字。
  (4) 尽量语义化的名字通过变量名字可以知道是做什么的。

#include
using namespace std;
int main(void){
	//驼峰命名法：第一个字母小写其他首字母大写 
	int wangSiYuAge=23;
	
	cout<<wangSiYuAge<<endl;
	return 0; 
} 

• 关键字
  
• 变量的声明
  语法： [修饰符] 类型 标识符;
  (1) 修饰符是可选的，可以没有
  (2) 变量类型是数据类型
  (3) 标识符是变量名字
  (4) 例如 int a;
  (5) 可以一次声明多个变量
  (6) int a,b,c;
• 变量赋值

 int a;
 a=4;

变量赋初值

int a=4;

可以多个一起赋值

int a=2,b=3,c=4;

15.变量的类型

整型变量、浮点型变量、字符型变量

#include
using namespace std;
int main(void){
	int a1=1;
	unsigned int a2=2;
	short a3=3;
	unsigned short a4=4;
	long a5=5L;
	unsigned long a6=6;
	
	float a7=7.12f;
	double a8=8.12;
	long double a9=9.36L;
	
	char ch1='a';//97
	cout<<"a:"<<ch1<<endl;
	char ch2=ch1-32;//65
	cout<<"A:"<<ch2<<endl;
	return 0; 
} 

16.C++格式化输出

• 输出不同数据类型

cout<<22<<2.14<<true<<'A'<<"ABC"<<endl;

• 输出不同格式的数据

#include
#include 
using namespace std;
int main(void){
	//输出类型
	cout<<22<<2.14<<true<<'A'<<"ABC"<<endl;
	//输出格式
	int c1=685;
	cout<<"c1:"<<showbase<<c1<<endl;//显示进制前缀
	cout<<"c1:"<<dec<<setw(20)<<setfill('#')<<c1<<endl;//输出宽度为20的十进制，默认靠右
	cout<<"c1:"<<dec<<setw(20)<<setiosflags(ios::left)<<setfill('*')<<c1<<endl;//输出宽度为20的十进制，靠左
	
	cout<<"c1:"<<oct<<c1<<endl;//输出八进制
	cout<<"c1:"<<hex<<c1<<endl;//输出十六进制
	cout<<"c1:"<<hex<<setiosflags(ios::uppercase) <<c1<<endl;//输出大写十六进制
	
	cout<<"c1:"<<dec<<showpos<<c1<<endl;//在非负数值中显示 + 
	cout<<"c1:"<<dec<<noshowpos<<c1<<endl;//在非负数值中不显示 +
	
	double c2=123.456789123;
	cout<<"c2:"<<c2<<endl;//默认输出
	//cout<<"c2:"<
	//cout<<"c2:"<
	//cout<<"c2:"<
	return 0; 
}

17.数据类型总结

第四章 C++运算符表达式

1.运算符的介绍

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号，指的是可以进行运算操作的符号。运算符又称之为操作符。提供给运算符进行操作的数值称为操作数。

• 表达式
  凡是用于计算值的操作都可以看做是表达式，表达式总能返回一个值。
  例如：int c=2+3;
  int b=8/2;
  表达式的计算是指执行一个或多个操作最后产生一个结果。

• 一元二元操作符
  作用在一个操作数上的操作符被称为一元操作符比如取地址操作符&。
  作用在两个操作数上的操作符比如加法操作符、减法操作符被称为二元操作符。

• 运算符分类
  

2.算术运算符

指的是最基本的加减乘除求模运算符

#include
using namespace std;
int main(void){
	cout<<"算数运算符："<<endl;
	int a=2;
	int b=3;
	int result=0;
	cout<<"a="<<a<<",b="<<b<<endl;
	result=a+b;
	cout<<"a+b="<<result<<endl;
	result=a-b;
	cout<<"a-b="<<result<<endl;
	result=a*b;
	cout<<"a*b="<<result<<endl;
	result=a|b;
	cout<<"a|b="<<result<<endl;
	result=a/b;
	cout<<"a/b="<<result<<endl;
	result=a%b;
	cout<<"a%b="<<result<<endl;
	return 0; 
}

3.C++自增自减运算

• 自增
  作用使得变量的值增加1

• 前置自增
  ++a;先自增后取值

• 后置自增
  a++;先取值后自增

• 前置自减
  –c;先自减后取值

• 后置自减
  c–;先取值后自减

#include
using namespace std;
int main(void){
	cout<<"自增自减"<<endl;
	int result=0;
	int c=5;
	result=c+1;
	cout<<"自增："<<result<<endl; 
	cout<<"c:"<<++c<<endl;//前置自增，先自增后取值
	cout<<"c:"<<c++<<endl;//后置自增，先取值后自增
	cout<<"c:"<<c<<endl; 
	cout<<"自减："<<endl;
	cout<<"c:"<<--c<<endl;//前置自减 
	cout<<"c:"<<c--<<endl; //后置自减
	cout<<"c:"<<c<<endl; 
	return 0; 
}

4.关系运算符

主要用来判断两个操作数的大小。

#include
using namespace std;
int main(void){
	cout<<"关系运算符"<<endl;
	int d1=2;
	int d2=5;
	bool d=(d1!=d2);
	cout<<"d1==d2:"<<(d1==d2)<<endl;//0
	cout<<"d1!=d2:"<<(d1!=d2)<<endl;//1
	cout<<"d1>d2:"<<(d1>d2)<<endl;//0 
	cout<<"d1<<(d1<d2)<<endl;//1
	cout<<"d1>=d2:"<<(d1>=d2)<<endl;//0
	cout<<"d1<=d2:"<<(d1<=d2)<<endl;//1
	cout<<"3<=3:"<<(3<=3)<<endl;//1
	cout<<"字节数："<<sizeof(d1!=d2)<<endl;	
	return 0; 
}

5.逻辑运算符

是对真和假这两种逻辑运算值进行运算。

• 逻辑表达式
  (a||b)&&(c||d) 逻辑表达式嵌套也是允许的和常见的。

#include
using namespace std;
int main(void){
	cout<<"逻辑运算符"<<endl;
	cout<<(1&&1)<<endl;//1
	cout<<(1&&0)<<endl;//0
	cout<<(0&&1)<<endl;//0
	cout<<(0&&0)<<endl;//0
	cout<<(1||0)<<endl;//1
	cout<<(!1)<<endl;//0 
	return 0; 
}

6.位运算符

位运算符作用于位，并逐位进行操作。

• 案例
  假设如果A=60，且B=13，现在以二进制格式表示，它们如下：
  A=0011 1100
  B=0000 1101
  A&B=0000 1100
  A|B=0011 1101
  A^B=0011 0001
  ~A=1100 0011

• 优先级
  在双目运算中，位逻辑与的优先级最高，位逻辑或次之，位逻辑异或最低。

7.移位运算

对操作数的二进制数据进行移位操作。
假设如果A=60，且B=13，现在以二进制格式表示，它们如下：
A=0011 1100
B=0000 1101

• 案例

#include
using namespace std;
int main(void){
	cout<<"移位运算"<<endl;
	unsigned int a=60;//60=0011 1100
	unsigned int b=13;//13=0000 1101
	int c=0;
	
	c=a<<2;//240=1111 0000
	cout<<"c的值是"<<c<<endl;
	
	c=a>>2;//15=0000 1111
	cout<<"c的值是"<<c<<endl; 
	return 0; 
}

8.赋值运算符

将右边表达式的值给左边变量的过程称为赋值。

• 案例

#include
using namespace std;
int main(void){
	cout<<"赋值运算"<<endl;
	int g=8;
	g<<=2;//g=g<<2
	cout<<"g<<=2:"<<g<<endl;//32
	
	int a=8;
	a&=2;//a=a&2;
	cout<<"a&=2:"<<a<<endl;//0
	
	int c=8;
	c|=2;//c=c|2;
	cout<<"c|=2；"<<c<<endl;//10
	
	int d=8;
	d^=2;//c=c^2;
	cout<<"d^=2:"<<d<<endl;//10
	return 0; 
}

9.条件运算符

语法规则：
表达式1 ? 表达式2 : 表达式3
解析：如果表达式1为真则结果是表达式2，如果表达式1为假则结果为表达式3。

• 案例

#include
using namespace std;
int main(void){
	//条件运算符 
	bool exp1=3>2;//1
	int exp2=3+2;
	int exp3=3*2;
	int exp=exp1?exp2:exp3;
	cout<<"exp1?exp2:exp3 结果为 "<<exp<<endl;//5 
	
	cout<<(3<2?3+2:3*2); //6
	return 0; 
}

10.逗号运算符

• 形式
  表达式1，表达式2…表达式n
  求解过程：先求表达式1再求表达式2，整个表达式的值是表达式2的值。
  例如 3+5,6+8 结果是14

#include
using namespace std;
int main(void){
	//逗号运算符 
	int h=(3+6,9+8);
	cout<<(3+6,9+8)<<endl;
	cout<<"3+6,9+8="<<h<<endl;
	return 0; 
}

逗号运算符的优先级最低

11.其他运算符

• sizeof
  返回指定数据类型或者表达式值得数据类型在内存中占用的字节数。

• 指针运算符 *
  指针运算符,*p代表指针变量指向p的地址

• 引用和地址运算符 &
  int a=10;
  int &b=aa;
  b=3;//a=3

• 强制类型转换运算符

• 对象的成员运算符 .

• 指向成员的运算符 ->

• 下标运算符 []

• 函数调用运算符 ()

12.运算符优先级

运算符是分优先级的，高优先级要比低优先级的运算符先进行运算的。相同优先级则从做到右执行。比如a+b+e*(c+d) 则先算小括号内的然后算乘法然后是加法。

• 结合性
  分为两种，左结合运算符优先与其左边的标识符结合进行运算，例如加法。右结合表示运算符优先与其右边的标识符结合，例如-15。
  下表的运算符优先级从高到低
  

13. 表达式的种类

• 算数表达式

int v=3+4*6/2-7;

• 关系表达式
  用关系运算符将两个表达式连接起来的式子称为关系表达式，c>a+b; 优先级：算术运算符>关系运算符>赋值运算符

int p2=9-1>6+1;

• 逻辑表达式
  例：a>b&&c>d; a>b||c>d;

int p3=4>2&&3>6;

• 条件表达式

int p4=3>2?2-6:7+9;

• 赋值表达式

int p5=34;

14.表达式的类型转换

• 隐式转换
  在表达式中经常遇到不同数据类型之间的运算，例如 9+‘a’+1.8-23.114*‘b’;在进行运算时候不同数据类型需要先转换成同一个类型然后进行运算。隐式转换是自动完成的。

#include
using namespace std;
int main(void){
	cout<<" 9+'a'+1.8-23.114*'b'= "<<( 9+'a'+1.8-23.114*'b' )<<",类型字节："<<sizeof( 9+'a'+1.8-23.114*'b' ) <<endl;
	return 0; 
}

• 转换规则
  

• 显式转换
  格式： (类型名) (表达式)
  如果转换的是一个变量则不需要括起来，如果转换的是一个表达式则需要括起来。

#include
using namespace std;
int main(void){
	short q1=2; 
	cout<<"q1的类型字节："<<sizeof(q1)<<endl;//q1的类型字节：2
	float q2=float(q1);
	cout<<"q2的类型字节："<<sizeof(q2)<<endl;//q2的类型字节：4 
	double q3=(double)(q1+4);
	cout<<q3<<",q3的类型字节："<<sizeof(q3)<<endl;//6,q3的类型字节：8 
	return 0; 
}

第五章 C++条件循环语句

1.基于过程的程序设计

程序必须告诉计算机应当具体怎么做。给出计算机全部操作的具体过程，执行完这个过程也就是实现了问题的求解。

• 程序
  一个基于过程的程序应该包含以下两个方面：
  对数据的描述：数据结构
  对操作的描述：操作步骤也即是算法
  程序=算法+数据结构

• 算法的表示
  (1)自然语言
  (2)流程图
  (3)伪代码
  (4)计算机语言

2.选择结构设计思路

• 分支结构设计1

• 分支结构设计2

• 分支结构设计3
  
• 分支结构设计4
  

3.选择结构之if-else语句

• 代码示例

#include
using namespace std;
int main(void){
	bool rain=false;
	if(rain){
		cout<<"天气下雨，看电视"<<endl;
	}
	else{
		cout<<"天气不下雨，出去玩"<<endl;	
	}
	return 0;
} 

4.选择结构之else-if语句

• 代码示例

#include
using namespace std;
int main(void){
	int score=57;
	if(score>=90){
		cout<<"优等生"<<endl;
	}
	else if(score>=80){
		cout<<"较好生"<<endl;	
	}
	else if(score>=70){
		cout<<"较好生"<<endl;
	}
	else if(score>=60){
		cout<<"及格生"<<endl;
	} 
	else{
		cout<<"差等生"<<endl;
	}
	return 0;
} 

5.选择结构之if-else语句嵌套

• 代码示例

#include
using namespace std;
int main(void){
	int a=2,b=3,c=4,d=8;
	if (a+b+c>d){
		cout<<"a+b+c>d"<<endl;
		if(a>b){
			cout<<"a>b"<<endl;
		}
		else{
			cout<<"a<=b"<<endl;	
			if(c>d){
				cout<<"c>d"<<endl;
			}
			else{
				cout<<"c<=d"<<endl;
			}
	
		}
	}
	else{
		cout<<"a+b+c<=d"<<endl;
	}
	
	return 0;
} 

6.选择结构之switch语句

switch是多分支选择结构，用来实现多分支结构选择的结构。

• 语法结构：

switch(表达式){
	case 常量表达式1:
		语句1;
		break;
	case 常量表达式2:
		语句2;
		break;
	default:
		语句3;
}

• 代码示例

#include
using namespace std;
int main(void){
	char ch;
	cin>>ch;
	switch(ch){
		case 'A':
			cout<<"A_name"<<endl;
			break;
		case 'B':
			cout<<"B_name"<<endl;
			break;
		case 'C':
			cout<<"C_name"<<endl;
			break;
		default:
			cout<<"Lily"<<endl;
	}
	return 0;
} 

7.选择结构之switch嵌套

• 语法结构

switch(表达式1)
	case 1:
		if(表达式2)
			表达式2;
		else
			表达式3；
		break;
	........

• 代码示例

#include
using namespace std;
int main(void){
	int number =3;
	char sex='M' ;
	int s=5;
	switch(number){
		case 1:
			cout<<"选择了1号"<<endl;
			break;
		case 2:
			cout<<"选择了2号"<<endl;
			if(sex='M'){
				cout<<"性别为男"<<endl;
			}
			else{
				cout<<"性别为女"<<endl;
			}
			break;
		case 3:
			cout<<"选择了3号"<<endl;
			switch(s){
				case 4:
					cout<<"s==4"<<endl;
					break;
				case 5:
					cout<<"s==5"<<endl;
					break;
			}
			break;
		default:
			cout<<"没有选择"<<endl;
	}
	return 0;
} 

8.选择语句练习

#include
using namespace std;
int main(void){
	//1.小明的难题
	bool weather=false;
	if(weather==true){
		cout<<"天气好，小明可以出去玩"<<endl;
	} 
	else{
		cout<<"天气不好，小明不可以出去玩"<<endl;
	}
	// 2.不同年龄段的人喜欢做什么
	int age=36;
	if(age>80){
		cout<<"喜欢回忆往事"<<endl;
	}
	else if(age>60){
		cout<<"喜欢锻炼身体"<<endl;
	}
	else if(age>30){
		cout<<"拼命工作"<<endl;
	}
	else if(age>20){
		cout<<"整天谈恋爱"<<endl; 
	}
	else{
		cout<<"玩游戏"<<endl; 
	}
	//3.斯坦福分数等级划分 
	int grade='C';
	switch(grade){
		case 'A':
			cout<<"90分以上"<<endl;
			break; 
		case 'B':
			cout<<"80分~90分"<<endl;
			break;
		case 'C':
			cout<<"70分~80分"<<endl;
			break;
		case 'D':
			cout<<"60分~70分"<<endl;
			break;
		case 'E':
			cout<<"60分以下"<<endl;
			break;
		default:
			break;
	}
	return 0;
} 

9.循环结构设计思路

• 循环结构设计1

• 循环结构设计2
  
• 循环结构设计3
  

10.循环结构之while语句

先做条件判断，再执行循环体。

• 代码示例
  1+2+3+…+100的和。

#include
using namespace std;
int main(void){
	int sum=0;
	int i=1;
	while (i<=100){
		sum=sum+i;
		i+=1;
	}
	cout<<"1+2+3+...+100="<<sum<<endl;
	return 0;
} 

11.循环结构之do-while语句

先执行循环体，再做条件判断。

• 代码示例
  求1+2+3+…+100的和。

#include
using namespace std;
int main(void){
	int sum=0;
	int i=1;
	do{
		sum+=i;
		i++;
	}while (i<=100);
	cout<<"1+2+3+...+100="<<sum<<endl;
	return 0;
} 

12.循环结构之for语句

• 代码示例
  求1+2+3+…+100的和

#include
using namespace std;
int main(void){
	int sum=0;
	for(int i=1;i<=100;i++){
		sum+=i;
	}
	cout<<"1+2+3+...+100="<<sum<<endl;
	return 0;
} 

13.多重循环结构

• 输出一个三角形

#include
using namespace std;
int main(void){
	for(int i=1;i<=9;i++){
		for(int j=1;j<=i;j++){
			cout<<"*";
		}
		cout<<endl;
	}
	return 0;
} 

• 结果显示
  

14.跳出循环的办法

可以使用break语句跳出当前循环，从而中断循环。注意break语句只能跳出一层循环体。
continue跳出本次循环。
goto语句无条件跳转，不常用。

#include
using namespace std;
int main(void){
	//break跳出循环 
	for(int i=1;i<=100;i++){
		cout<<"i="<<i<<endl;
		if(i==55){
			cout<<"跳出循环，循环结束"<<endl; 
			break;
		}
	}
	
	//continue跳过本次循环
	for(int i=1;i<=10;i++){	
		if(i==6){
			continue;
		}
		cout<<"i="<<i<<endl;
	} 
	
	//goto 无条件跳转语句 
	goto hello;
	cout<<"1"<<endl;
	cout<<"2"<<endl;
	cout<<"3"<<endl;
	hello:
		cout<<"goto finished!"<<endl; 
	return 0;
} 

15.循环语句的练习

• 1.输出1到100之间的偶数
• 2.输出图形
  

#include
using namespace std;
int main(void){
	//1.输出1—100的偶数 
	for(int i=1;i<=100;i++){
		if(i%2==0){
			cout<<i<<endl;
		}
	}
	cout<<"方法二"<<endl;
	for(int i=0;i<=100;i+=2){
		cout<<i<<endl;
	} 
	//2.输出图形
	for(int i=0;i<5;i++){
		for (int j=0;j<9;j++){
			if(i==0||i==4){
				cout<<"*";
			}
			else{
				if(j>0&&j<8){
					cout<<" ";
				}
				else{
					cout<<"#";
				}
			}
		}
	cout<<endl;
	} 
	return 0;
} 

16.程序控制总结

第六章 函数语法

1.函数的介绍

一个函数实现一个功能

• 函数分类
  系统函数、库函数、用户自定义函数

• 函数要素
  函数名、函数体、返回值、入参、出参

• 函数的语法结构

类型名 函数名(参数列表){
	 声明部分
	 执行语句
	 返回语句
}

• 函数的声明

声明函数的样式，以便其他方进行函数调用。int max(int x,int y);

2.函数的参数和返回值

#include
using namespace std;
//函数声明
int max(int x,int y); 
int main(void){
	int a=max(3,6);
	cout<<"max(3,6)="<<a<<endl;
	return 0;
}
int max(int x,int y){
	if(x>y){
		return x;
	}
	else{
		return y;
	}
} 

• 无参函数
  参数可以为空

int play(){
	doSoming...
}

• 代码示例

#include
using namespace std;
//无参函数声明
void play(); 

int main(void){
	play();
	return 0;
	 }
void play(){
	cout<<"play------"<<endl;
	return; 
} 

• 参数形式
  形式参数、实际参数
  形参在定义函数的时候函数名后面括号中的变量名称称为形式参数。形参可以是基本数据类型或者派生数据类型。
  实参在函数进行调用的时候传入的实际参数称为实参。实参可以是常量、变量、或者表达式。
• 返回值
  调用函数经常希望返回一个结果，这个结果就是函数的返回值。返回值类型要与函数声明类型一致。使用return关键字。

3.函数的调用

• 定义
  函数被调用执行的过程称为函数调用。
  形如:f();

• 函数调用方式
  (1)普通调用
  max(2,3);直接按照形参传入对应的实参即可。
  (2)函数表达式
  C=4*max(a,b);可以把函数作为一个整体，函数调用返回一个数据，然后作为表达式的一个操作数进行运算。
  (3)函数参数
  C=max(a,sqrt(b));带返回值的函数可以作为另一个函数调用的实参使用。

• 嵌套调用
  在自定义函数中调用其他函数
  注意事项:
  (1) 被调用的函数必须是已经存在的函数
  (2) 如果调用库函数，需要引入对应的头函数如：std::out()
  (3) 如果使用自定义函数，一般需要实现做函数声明

4.函数的递归调用

函数直接或者间接的调用函数自己本身称为递归调用。
求年龄问题
有5个人ABCDE在一起，问E多少岁，E说比D大2岁，问D,D说比C大2岁，问C,C说比B大2岁，问B,B说比A大2岁，A说自己20岁。

#include
using namespace std;

int age(int n);
int main(void){
	int ageE=age(5);
	cout<<"E的年龄是"<<ageE<<"岁"<<endl; 
	return 0;
	}
//递归求解算法 
int age(int n){
	int result;
	if (n==1){
		result=20;
	}
	else{
		result=age(n-1)+2;
	}
	return result;
}

5.函数的重载

#include
using namespace std;
//函数声明
int min(int x,int y);
long min(long x,long y);
double min(double x,double y);
int main(void){
	cout<<min(2,3)<<","<<min(4L,5L) <<","<<min(2.3,4.5)<<endl;
	return 0;
}

int min(int x,int y){
	return(x<y?x:y);
} 
long min(long x,long y){
	return(x<y?x:y);
}
double min(double x ,double y){
	return(x<y?x:y);
}

• 函数重载条件
  参数个数、参数类型 、参数顺序三者必须至少有一种不同。 注意：函数类型不同不能认为是重载函数。

6.带默认参数的函数

一般情况下，函数调用时候会从调用者方面取得参数值。但是我们也可以在定义函数时候给函数默认参数。

#include
using namespace std;
//默认参数
void want(int a=2);
int fly(int b=3,int c=4);
/*
//错误的
void age(int a=1,int b){
	cout< 
//默认参数必须在函数参数列表的尾部，否则会报错
int run(int a,int b=5);

int main(void){
	want();
	fly();
	run(9);
	return 0;
}

void want(int a){
	cout<<"是我想要的值："<<a<<endl;
}
int fly(int b ,int c){
	cout<<"b="<<b<<",c="<<c<<endl;
	return 0;
}
int run(int a,int b){
	cout<<"a="<<a<<",b="<<b<<endl;
	return 0;
}

7.局部变量和全局变量

变量是在程序运行中可以改变的量。

• 局部变量
  在函数内部定义的变量，他只在函数的内部有效，称为局部变量。主函数中定义的变量只有主函数内才能使用。

• 全局变量
  在函数体外定义的变量称为全局变量。全局变量的有效范围从变量定义位置开始到本源文件结束位置。

• 全局变量示例代码

#include
using namespace std;
void want(int a=2);
// 全局变量
int m=9; 

int main(void){
	want();
	cout<<"全局变量m="<<m<<endl;
	//cout<
	return 0;
}
//注意全局变量的作用范围 
int n=3;
void want(int a){
	cout<<"是我想要的值："<<a<<endl;
}

设置全局变量为了增加函数之间的数据联系渠道，在同一个文件中所有函数都能够使用全局变量。建议不在必要时候不要使用全局变量。因为全局变量在程序全部执行过程中都占用存储单元，而不是仅在需要的时候才开辟单元。

8.变量的存储介绍

• 存储期
  变量在内存中的存储周期。这是从变量值存在的时间角度来分析的。

• 静态存储方式
  在程序运行期间系统对变量分配固定的存储空间。

• 动态存储方式
  在程序运行期间系统对变量动态的分配存储空间。

• 存放内容
  程序中的数据分别放在静态存储区和动态存储区。全局变量全部存放在静态存储区，在程序开始执行时候给全局变量分配存储空间，在程序执行过程中他们占用固定的存储单元，直到程序退出才会释放空间。动态存储区存放以下数据：（函数形式参数，在调用函数时候给形参分配存储空间；函数中定义的局部变量；函数调用时候的现场保护和返回地址等。）动态存储区的数据在函数调用时候分配动态的存储空间，函数调用结束的时候释放这些存储空间。如果在程序中调用两次同一个函数要进行两次的分配和释放。

• 存储类别
  auto 自动
  static 静态
  register 寄存器
  extern 外部

9.auto和static变量

• auto
  函数中的局部变量（不用关键字static修饰）编译系统对它们是动态的分配存储空间的。在调用函数的时候，系统给形参和函数中定义的变量分配存储空间，数据存储在动态存储区，函数调用结束时候自动释放空间，这类局部变量称为自动变量。使用关键字auto修饰。auto int a=3; auto可以省略，我们用的大部分变量属于auto变量。

• static
  由于局部变量在函数调用结束时候空间会释放掉。如果我们希望函数调用结束变量值还存在内存里，保存上次的结果，就可以使用static修饰将变量存储静态存储区。

• 代码示例

#include
using namespace std;
int age(int x); 
void staticFunction();
int main(void){
	//动态局部变量 
	auto int m = age(6);
	//静态存储
	staticFunction();//2
	staticFunction();//3
	staticFunction(); //4
	return 0;
}
int age(int x){
	cout<<"小明的年龄是；"<<x<<endl;
	return 0;
}
void staticFunction(){
	static int a=1;
	a+=1;
	cout<<"a="<<a<<endl; 
}

10.register 寄存器变量

• 存取数过程

当程序用到一个变量时候，由控制器发出指令将内存中该变量的值送到cpu的运算器，经过运算器的运算，再把数据送回内存存放。

• register
  如果有以下变量使用特别频繁（例如执行10000次循环，每次都要用到某个变量）则存取变量的值就要用到不少时间。为了提高效率引入寄存器变量，C++允许直接将数据放入cpu寄存器中，直接从寄存器取数据，寄存器存取数据效率远远大于内存。

#include
using namespace std;
int sum();
int main(void){
	cout<<"sum="<<sum()<<endl;
	return 0;
}
int sum(){
	//寄存器变量 
	register int i;
	int sum=0;
	for (i=1;i<=10000;i++){ 
	sum+=i;
	}
	return sum;
}
 

11.extern外部变量

有时候需要使用extern声明全局变量，以扩展全局变量的作用域。

• 一个文件声明全局变量
  如果在定义点之前的函数想要引用该全局变量，则应该在引用之前使用关键字extern对该变量做外部变量声明，表示接下来将定义这个全局变量。有了这个声明我们就可以在声明的位置起，合法引用该变量。

#include
using namespace std;
//函数声明
int max(int x,int y);
extern int a,b;//提前声明外部变量
int main(){
	cout<<"hello world!\n";
	cout<<max(a,b);
	return 0;
} 
int a=2,b=3;
int max(int x,int y){
	return x>y?x:y;
}

• 在多文件中声明外部变量
  如果有多个源文件，在一个源文件中希望引用另一个文件中以及定义好的变量。

12.C++函数和变量总结

• 函数
  程序中实现一定特定功能的代码块称为函数。

• 参数和返回值

• 函数调用
  普通调用、表达式调用、参数调用。

• 函数递归
  不断调用自身的过程。注意退出递归。

• 函数重载

• 带默认参数的函数

• 局部变量和全局变量

• 变量的存储

• 变量的类别

  • auto
  • static
  • register寄存器变量
  • extern外部变量

第七章 C++数组研究

1.数组的介绍

• 定义
  将同一数据类型的数据按照一定形式有序组织起来，这些有序的数据集合称为数组。
  -数组
  所谓数组就是用一个统一的名字来代表这批数据，而用序号或者小标来区分各个数据。

• 数组在内存中的表示
  一个数组在内存中占用一片连续的内存空间。
  

2.一维数组的定义和使用

通常我们说数组值的是一维数组。

• 数组语法
  类型 数组标识符 [常量表达式]
  如： int a[10] 其中数组类型为整型，数组名是a,数组个数为10个；含义是数组名为a的数组里面可以存放10个整型。

• 说明
  数组名的命名规则和变量名相同，使用花括号来表示数组个数，值为常量表达式，注意[]中的表达式不能是动态的，必须是确定的常量。

• 引用数组
  即是取得数组中的某个值。
  语法：数组名[下标] 如： a[2]

• 下标越界
  定义数组时定义了数组长度，数组是由0-length。引用数组时范围为0-length-1，非此范围会产生下标越界。

#include
using namespace std;
int main(){
	int a[10];
	a[0]=1;
	a[1]=3;
	cout<<"a[0]="<<a[0]<<endl;
	int b[10]={1,2,3,4,5,6};
	b[3]=9;
	cout<<"b[3]="<<b[3];
	return 0;
} 

3.一维数组的输出

• 数组长度自动初始化
  我们可以在初始化时候不指定数组长度，直接进行初始化则编译器会自动获取数组长度。如：int a[]={1,2,3,4,5}; 编译器会自动获取数组长度。

• 一维数组的赋值
  有时候我们希望简单的对数组进行赋值，我们经常会采用循环赋值法。

• 循环赋值

#include
using namespace std;
int main(){
	int d[7];
	//循环赋值法 
	for(int i=0;i<7;i++){
		d[i]=i+1;
	}
	//循环输出
	for(int i=0;i<7;i++){
		cout<<d[i]<<" ";
	} 
	return 0;
} 

• f[10]和int f[10]={}的区别？

#include
using namespace std;
int main(){
	//int f[10];
	int f[10]={};	
	for(int i=0;i<10;i++){
		cout<<f[i]<<" ";
	}
	cout<<"f[10]的首地址"<<f<<endl; 
	return 0;
} 

4.一维数组的练习

给定数组int g[10]={23,45,67,89,10,99,100,32,56,84}，请输出数组中的数据。

#include
using namespace std;
int main(){
	int g[10]={23,45,67,89,10,99,100,32,56,84};
	for(int i=0;i<10;i++){
		cout<<g[i]<<" ";
	}
	return 0;
} 

编写程序实现操作员录入年龄，知道输入-1，退出输入，并且输出刚刚输入的年龄。

#include
using namespace std;
int main(){
	cout<<"请输入年龄"<<endl;
	int b[12]={};
	int i=-1;
	do{
		i++;
		cin>>b[i];
	}while(b[i]!=-1);
	for(int j=0;j<i;j++){
		cout<<b[j]<<" ";
	}
	return 0;
} 

5.二维数组介绍

可以有个二维空间来保存数据，数据可以根据两个因素来确定。
按照行列，先取行再取列。

• 数据存取
  a[1][2]=13
  

6.二维数组的定义和使用

• 语法
  类型名 数组名[常量表达式][常量表达式]
  例如：int a[5][7];

• 二维数组初始化

  • 最原始方式
    a[0][0]=2;
  • 按行赋值
    int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
  • 部分赋值
    int a[3][4]={{1},{2},{3}};

• 二维数组的输出

#include
using namespace std;
int main(){
	int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
	for(int i=0;i<3;i++){
		for(int j=0;j<4;j++){
			cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
} 

7.二维数组的练习

请输出一下二维数组。

#include
using namespace std;
int main(){
	double a[4][4]={
		{2.3,4.6,7.9,5.0},
		{7.8,2.7,6.9,2.3},
		{5.6,4.5,7.2,9.2},
		{8.8,3.7,6.9,4.1}
	};
	for(int i=0;i<4;i++){
		for(int j=0;j<4;j++){
			cout<<a[i][j]<<"  ";
		}
		cout<<endl;
	}
	return 0;
} 

用数组方式打印出三角形

#include
using namespace std;
int main(){
	char a[6][6]={
		{'*'},
		{'*','*'},
		{'*','*','*'},
		{'*','*','*','*'},
		{'*','*','*','*','*'},
		{'*','*','*','*','*','*'}
	};
	for(int i=0;i<6;i++){
		for(int j=0;j<6;j++){
			cout<<a[i][j];
		}
		cout<<endl;
	}
	return 0;
} 

8.数组作为函数参数

数组也是一种数据类型，所以也可以作为函数参数使用。

• 数组作为实参
  showArray(a,10);
• 代码示例

#include
using namespace std;
void showArray(int a[],int leng);
void showArray(int a[][4],int row,int col);
int main(){
	int p[10]={1,3,6,7,8,4};
	//一维数组作为参数 
	showArray(p,10);
	int k[3][4]={
		{1,2,3,6},
		{4,5,6,9},
		{7,8}
	};
	//二维数组作为参数 
	showArray(k,3,4);
	return 0;
} 
void showArray(int a[],int leng){
	for(int i=0;i<leng;i++){
		cout<<a[i]<<" ";
	}
	cout<<endl;
}
void showArray(int a[][4],int row,int col){
	for(int i=0;i<row;i++){
		for(int j=0;j<col;j++){
			cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
}

9.字符数组介绍

• 语法
  char 数组名[常量表达式] 例如char ch[7];
• 赋值
  char ch[]={‘w’,‘e’,‘l’,‘c’,‘o’,‘m’,‘e’};
  char ch[7]={‘w’,‘e’,‘l’,‘c’,‘o’,‘m’,‘e’};
  其他：元素逐一赋值，指定长度。

#include
using namespace std;
int main(){
	char ch0[]={'h','e','l','l','o'};
	char ch1[]={'h','e','l','l','o','\0','m'};
	char ch2[6]={'h','e','l','l','o'};
	cout<<"ch0="<<ch0<<endl<<"ch1="<<ch1<<endl<<"ch2="<<ch2<<endl;
	//字符数组的方式输出 
	for(int i=0;i<5;i++){
		cout<<ch0[i];
	}
	return 0;
} 

10.字符数组的输入输出

• 字符数组的存储
  chr ch[]={‘h’,‘e’,‘l’,‘l’,‘o’};
  
  输入完成，会自动在字符串后面加一个\0

#include
using namespace std;
int main(){
	//自动初始化为\0 
	char ch3[10]={};
	cin>>ch3;
	cout<<"ch3="<<ch3<<endl; 
	return 0;
} 

11.字符串函数的使用

• 引入头文件
  #include

• strcat
  strcat(字符数组1，字符数组2），字符数组连接函数，将字符数组2连接到字符数组1中去，保证字符数组1够大。

#include
#include
using namespace std;
int main(){
	char w1[30]="welcome,";
	char w2[10]="lily";
	strcat(w1,w2);
	cout<<w1;
	return 0;
} 

• strcpy
  strcpy(字符数组1，字符数组2），将字符数组2复制到字符数组1中去连\0一起复制。注意不能直接ch1=ch2直接赋值，ch1代表数组地址是常量，不能作为左值，不能被赋值。

#include
#include
using namespace std;
int main(){
	char w1[30]="welcome,";
	char w2[10]="lily";
	strcat(w1,w2);
	cout<<"w1="<<w1<<endl;
	strcpy(w1,w2);
	cout<<"w1="<<w1<<endl;
	return 0;
} 

• strcmp
  strcmp (字符数组1，字符数组2)，如果字符串1等于字符串2，返回0；如果字符串1大于字符串2，返回正整数；如果字符串1小于字符串2，返回负整数。比较规则：从左至右一个个比较，直到遇到不同字符或者\0为止（比较ascii值）。

#include
#include
using namespace std;
int main(){
	char w1[30]="lelc";
	char w2[10]="lily";
	cout<<strcmp(w2,w1);
	return 0;
} 

• strlen
  strlen(字符数组） 得到数组实际长度。

#include
#include
using namespace std;
int main(){
	char w1[30]="lelc\0";
	char w2[10]="lily";
	cout<<"w1的长度："<<strlen(w1)<<endl;
	cout<<"w2的长度："<<strlen(w2)<<endl;
	return 0;
} 

12.字符串函数的练习

客人输入四句话，请连成一句话输出。

#include
#include
using namespace std;
int main(void){
	char w1[30]={};
	char w2[10]={};
	cout<<"input four words,please."<<endl;
	for (int i=0;i<4;i++){
		cin>>w2;
		strcat(w1,w2);
	}
	cout<<w1;
	return 0;
} 

把小明的姓名改成和小王的姓名一样。

#include
#include
using namespace std;
int main(void){
	char w1[30]="xiaoming";
	char w2[30]="xiaowang";
	cout<<w1<<","<<w2<<endl;
	strcpy(w1,w2);
	cout<<w1<<endl;
	return 0;
} 

用户输入银行卡密码，判断密码是否为6位。

#include
#include
using namespace std;
int main(void){
	char w1[10]={};
	cout<<"请输入密码:";
	cin>>w1;
	if(strlen(w1)==6){
		cout<<"密码输入正确！"<<endl;
	}
	else{
		cout<<"密码输入错误！"<<endl;
	}
	return 0;
} 

13.string数据类型的使用

• 定义
  string是C++一种比较新的数据类型，使用方法和普通数据类型一样。如：string s=“hello”; string其实C++,使用它可以很方便的处理关于字符串相关的内容。

• 字符串变量的赋值

#include
#include
using namespace std;
int main(void){
	string s="hello";
	cout<<"s="<<s;
	cin>>s;
	cout<<"s="<<s<<endl;
	return 0;
} 

• 连接
  string s=“hello,”+“lily”;

#include
#include
using namespace std;
int main(void){
	string s1="hello,";
	string s2="lily";
	string s=s1+s2;
	cout<<"s="<<s;
	return 0;
} 

• 字符串数组
  string s[3];

#include
#include
using namespace std;
int main(void){
	string s[3]={"lily","is","cool."};
	cout<<s[0]<<s[1]<<s[2]<<endl;
	return 0;
} 

14.数组的总结

第八章 C++指针和引用

1.指针的概念

• 数据存储
  int a=28;
  int b=56;
  其中每个整型占据4个字节；变量a分配了2000~ 2003空间；变量b分配了2004~2007。
  

• 数据的存储过程
  在程序代码中我们通过变量名对内存进行存取操作，但是代码编译以后会将变量名与内存地址一一对应，对变量存取都是通过地址操作的。例如计算a+b,首先根据a的变量名找到地址为2000然后从2000开始读取4个字节数据到cpu的寄存器中，再找到变量b的地址为2004开始读取4个字节，然后在cpu中进行数据的相加操作。

• 指针
  一个变量的地址称为此变量的指针

• 指针变量
  如果有一个变量专门用来存储地址的，则成为指针变量。

2.指针的声明

• 指针声明
  语法： 数据类型 * 指针变量名 例如： int *p; double *x,*y;
  注意：* 代表是指针变量

• 取地址符号 &
  可以获取变量的地址。例如： cout<<&a ;
  示例： int a=93; &a=2009
  

• 指针赋值
  int a=3; int* p=&a ;
  上面的意思是取a的地址赋值给p指针变量。通过变量名访问一个变量是直接访问的，而通过指针访问一个变量是间接的。
  注意：不能用正整数给指针变量赋值。例如 int* p=2000;可能你想要把2000给p指针变量但是编译系统不认为2000是个地址。

#include
#include
using namespace std;
int main(void){
	//指针变量声明 
	int* p;
	double*x,* y;
	int a=5;
	cout<<"a的地址为："<<&a<<endl;
	p=&a;
	cout<<p<<endl;
	return 0;
} 

3.指针的运算

• 取值运算符*
  用来获取变量的值。int a=93; int* p=&a ; *p=93;

#include
#include
using namespace std;
int main(void){
	//指针运算 
	int x=88;
	int* y=&x; 
	cout<<"x的地址为："<<&x<<endl;
	cout<<"获取指针y指向的值："<<*y<<endl;
	return 0;
} 

• 指针运算
  指针变量存储的地址，对指针做运算就是对地址做运算。

#include
#include
using namespace std;
int main(void){
	int a=2;
	int* p=&a;
	cout<<p<<endl;
	p++;
	cout<<p<<endl;
	p++;
	cout<<p<<endl;
	return 0;
} 

结果：

4.指针常量和空指针

• void 空指针类型
  空指针可以接受任何数据类型，指针可以指向NULL。

#include
#include
using namespace std;
int main(void){
	void* p;
	int b=2;
	int* p1=&b;
	void* s=NULL;
	s=p1;
	cout<<*(int*)s<<endl;
	return 0;
} 

• 指针常量
  指针不可以改变

int a=2;
int* const p=&a; 

指针常量必须初始化，指针常量不能改变指向的地址，但是可以改变指向地址的内容，也即是说*p=5;

#include
#include
using namespace std;
int main(void){
	int a=2;
	int b=3;
	int* const p=&a;
	cout<<p<<endl;
	cout<<*p<<endl;
	//p=&b;//错误，指针常量不能修改指向
	*p=9; //正确，可以改变指向地址的内容 
	cout<<*p<<endl;
	return 0;
} 

• 指向常量的指针
  内容不可以改变

int a=2;
int const* p=&a;

const放在*前面表明内容不可改变。

#include
#include
using namespace std;
int main(void){
	int a=2;
	int b=3;
	int const* p=&a;
	cout<<p<<endl;
	cout<<*p<<endl;
	//*p=9;//错误，不可以改变指向地址的内容 
	p=&b;//正确，可以改变指向的地址
	cout<<p<<endl;
	cout<<*p<<endl;
	return 0;
} 

• 指向常量的指针常量

指针指向不可以改变，内容也不可以改变。

int a=2;
int const* const p=&a;

5.指针函数以及数组

#include
#include
using namespace std;
void show(int* p,int n) ;
int main(void){
	int a[10]={11,22,33,44,55,66,77,88,99,111};
	int* p=a;
	show(p,10);
	return 0;
} 
void show(int* p,int n){
	for(int i=0;i<n;i++,p++){
		cout<<*p<<" ";
	}
}

6.指针与字符串

• 用字符数组存放一个字符串

char name[]="hello,world!";

• 用字符串变量存放一个字符串

string s="hello,world";

• 用字符指针指向一个字符串

char const* hello="hello, world!";

在输出时候，系统首先输出hello所指向的第一个字符数据，然后使hello自动加一指向下一个字符，然后再输出一个字符，一直输出直到遇到\0结束。\0是字符串结束的标志。

#include
#include
using namespace std;

int main(void){
	char name[]="hello,world!";
	string s="lily";
	char const* hello="hello,lily!";
	cout<<hello<<endl;//hello,lily!
	cout<<"*hello="<<*hello<<endl;//h
	return 0;
} 

• 循环输出字符串

#include
#include
using namespace std;
int main(void){
	char const* hello="hello,lily!";
	do{
		cout<<*hello<<" ";
		hello++;
	}while(*hello!='\0');
	return 0;
} 

7.指针数组

#include
#include
using namespace std;
int main(void){
	int a[10]={11,22,33,44,55,66,77,88,99,111};
	int* p[10]={&a[0],&a[1],&a[2],&a[3],&a[4],&a[5],&a[6],&a[7],&a[8],&a[9]};
	cout<<"p[5]="<<p[5]<<endl;
	cout<<"*p[5]="<<*p[5]<<endl;
	return 0;
} 

• 取值
  获取第一个数组元素cout<<*(*p); cout<<**p;
  获取第二个数组元素cout<<*p[1];//p[i]是个地址，存储的各个整型的地址

8.引用的介绍

• 定义
  对数据可以建一个引用，它的作用是为一个变量起一个别名。
  例如：int a=23; int& b=a;以上指的是b是a的引用。

#include
#include
using namespace std;
int main(void){
	int a=20;
	int& b=a;
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
	a=30;
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
	b=40;
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
	return 0;
} 

注意：&在这里是引用声明符，不是之前说的取地址符。不能理解成把a的值赋值给b。
在数据类型后面出现的&是引用符号。其他地方是地址符号。
1.引用不是一种独立的数据类型。对引用只有声明没有定义。必须先建立一个变量，然后再对该变量建立引用。
2.声明一个引用时候，必须同时初始化，即声明它代表哪一个变量。
3.在声明一个引用后不能再使之成为另一个变量的引用。

#include
#include
using namespace std;
int main(void){
	int a=20;
	int b=34;
	int& c=a;
	//int& c=b;//错误 
	return 0;
} 

4.不能建立引用数组
int a[5]; int& b[5]=a;//错误
5.区别引用符号&和取地址符号&

9.经典的AB值交换问题

#include
#include
using namespace std;
void swap(int x,int y);
void swap(int* x,int* y);
int main(void){
	int s1=4;
	int s2=9;
	cout<<"函数外部交换之前：s1="<<s1<<","<<"s2="<<s2<<endl;
	swap(s1,s2); 
	cout<<"函数外部交换之后：s1="<<s1<<","<<"s2="<<s2<<endl;
	cout<<"===================================================="<<endl;
	cout<<"函数外部交换之前：s1="<<s1<<","<<"s2="<<s2<<endl;
	swap(&s1,&s2); 
	cout<<"函数外部交换之后：s1="<<s1<<","<<"s2="<<s2<<endl;
	return 0;
} 
void swap(int x,int y){
	cout<<"函数内部交换之前：x="<<x<<","<<"y="<<y<<endl;
	int temp;
	temp=x;
	x=y;
	y=temp;
	cout<<"函数内部交换之后：x="<<x<<","<<"y="<<y<<endl;
}
void swap(int *x,int *y){
	cout<<"函数内部交换之前：x="<<*x<<","<<"y="<<*y<<endl;
	int temp;
	temp=*x;
	*x=*y;
	*y=temp;
	cout<<"函数内部交换之后：x="<<*x<<","<<"y="<<*y<<endl;
}

10.指针练习题

如下数组，请用指针输出。int a[10]={1,2,3,4,5,6,7,8,9,0};

#include
using namespace std;
int main(void){
	int a[10]={1,2,3,4,5,6,7,8,9,0};
	int* p=a;
	for (int i=0;i<10;i++,p++){
		cout<<*p<<" ";
	}
	return 0;
} 

利用函数实现数据真实修改。

#include
using namespace std;
void  calc(int *x,int *y,int*sum);
int main(void){
	int u1=5,u2=6,sum=0;
	calc(&u1,&u2,&sum);
	cout<<"u1="<<u1<<",u2="<<u2<<",sum="<<sum<<endl;
	return 0;
}
void  calc(int *x,int *y,int*sum){
	(*x)++;
	(*y)--;
	*sum=*x+*y; 
} 

给变量起别名并进行相关操作。

#include
using namespace std;
int main(void){
	int u1=4;
	int& u2=u1;
	u2=u2+6;
	cout<<"u1="<<u1<<endl;
	return 0;
}

注: 本文内容为自学笔记。学习视频详见