c++程序设计复习笔记

---

一、c++的数据类型

变量

---

数据类型名（常用）
整型：int
字符型：char
布尔型：bool
长整型：long long
单精度型（小数点后一位）：float
双精度型（小数点后两位）：double
无符号整型：unsigned int

变量命名规则

各类型字节数和范围

带符号的最高位存符号
float提供6位有效数字，double提供15位有效数字

---

派生类型：
*指针类型

*枚举类型

*数组类型

*结构体类型

*共用体类型

*类类型

空类型(void)

---

常量（无unsignd型）

进制表示：
十进制：不需要特殊表示

八进制：常数开头加数字0

十六进制：常数开头加x

浮点数表示：
十进制小数形式：3.14

指数形式：314e-2

在内存存储方式：+ | .314 | 1 (数字部分<1, 指数部分必须为整数)

字符常量(内存中ASCⅡ码储存–>和整型可以互相赋值)：

只包括一个字符

区分大小写

转义字符：

字符串常量：“hahaha”
符号常量define（改起来方便）：#define ABC 3.1415

变量
没赋初值变量值不确定

加const以后变量值不能改变（函数参数）

---

运算符

++i 和i++

*小赋给大可能丢数据（溢出）

*强制类型转换（类型名）（表达式（括完整））

*两整数相除结果为整数，取整方向不确定

*算数运算符，逗号运算符自左向右结合，赋值运算符从右向左结合

*浮点数不能做%运算（可以强制转换为整型再%）

*x%=y+3 -> x%=(y+3)

*赋值运算符左值不能为表达式or长变量，左值都能作为右值

*逗号表达式：1，2，…,n 整个表达式的值是n的值（a=3,a×4 -> a=12）

*关于结合性的例题：（1.从左向右解析 -> 从右向左算 2.赋值运算符return回去的变量值替代原来的变量值）

---

二、基本的语句和操作

算法

算法+数据结构=程序

算法的分类

数值算法：求数值解

非数值算法：其他

*算法表示：

自然语言

流程图

伪代码

计算机语言

程序结构

每一个程序单位由三部分组成

预处理指令：#include，#define等

全局声明：函数外做的定义

函数

c++的语句

声明语句

执行语句：

控制语句: 九种（if语句，三种循环，continue，break，switch，goto，return）

函数和流对象调用语句：sort(a,b) cout<<“Hello”

表达式语句

空语句：只有一个分号的语句（；）

复合语句：用{}括起来的一些语句

输入输出

<< : 流插入运算符，>> : 流提取运算符

#include  <iostream>

*执行cout<<语句时直到缓冲区满或者遇到endl才输出

*用cin>>输入时系统会根据变量的类型从输入流中提取相应长度字节

*分割变量：Tab 空格 回车
*格式控制符（#include ）：

---

优先级:算术运算符>关系运算符>赋值运算符

---

算术运算符

(1)加减乘（+，-，*）
变量的加减乘运算与数学中的加减乘一样。
除了运算的两个对象均为整型是结果为整型，若运算对象中有实型变量，结果为实型。
(2)除法（/）
若参与运算的两个对象均为整型，其结果为数学运算的整数部分
例如：3/2结果为1，而不是1.5
若运算对象中有实型，其结果为正常运算结果。
例如：7/5.0结果为1.4
(3)模运算（%）
参与运算对象均需为整型
例如：7%5结果为2

关系运算符

*关系表达式：用关系运算符将两个表达式连接起来的句子

*逻辑表达式：两个关系表达式用逻辑运算符连接

*逻辑运算优先顺序：！> && > ||

*判断逻辑量标准：0 -> false, 其他 ->true（‘c’&&‘d’ -> true[ASCⅡ] 4&&0||2 -> true ）

*选择结构 if(表达式)，表达式结果非0则执行下面的语句

*条件运算符：a？b：c 判断a真假，真就执行b，否则执行c

*switch（表达式）：

别漏了default

除了defaul，每条语句后加break

各个case和default顺序不影响结果

逻辑运算符

&&左侧为0(False)，右侧无需运算直接输出0(False)
||左侧为1(True)，右侧无需运算直接输出1(True)

---

优先级:！>算术运算符>关系运算符> &&和|| >赋值运算符

---

循环结构

if语句

语法格式：

if（判断条件）{
    条件成立时执行的语句
}else{
    条件不成立时执行的语句
}

多重if重合

语法格式：

if（判断语句1）{
	语句1
}else{
	if（判断语句2）{
		语句2
	}else（）{
		if。。。
			else。。。{
				语句n
			}
	}
}

if内包含多重if语句

语法格式：

if（条件1）{
	if（条件2）{
		1，2都成立的执行语句
	}else{
		1成立，2不成立的执行语句
	}
}else{
	if（条件3）{
		1不成立，3成立的执行语句
	}else{
		1，3都不成立的执行语句
	}
}

并列if语句(else只能有一个，else if可以多个)

if(条件1){
   结果1
}else if(条件2){
   结果2
}else if(条件3){
   结果3
}else if(条件4){
   结果4
}else{
   结果5
}

return 0;

if else的就近原则

语法格式：

//ifelse的就近原则
if (a > 0)
	if (a > 10)//配下面的else
		cout << "a属于(10,+oo)" << endl;
else//就近原则，配的是第二个if
	cout << "错误" << endl;

switch循环

switch (c) {
case 'a': //c=='a'
case 'A':
	cout << "优秀" << endl; 
	break;
case 'b':
case 'B':
	cout << "良好" << endl;
	break;
default: //相当于if的else
	cout << "不及格" << endl;
	break;
}
//if和switch的区别，switch适合用于判断次数多的，效率高

for循环

// for (进入循环时执行，只执行一次;判断;每次循环结束时执行) {
// }

for (i = 0; i < 3; i++) {
	cout << i << endl;//0 1 2
}
cout << i << endl;//最终i=3,将未能再次进入循环的3输出

for (int i = 0; i < 5; i++) {// i的生命周期:整个for循环里
	//cout << i << endl;//循环完后i就销毁
	int a = 0;      // 一次循环里
	a++;
	cout << a << '\t';//a每次循环后直接销毁，再次进入循环重新赋值
	cout << i << endl;

}
cout << i << endl;//是最上面i=3

while循环

    int a = 0;
    /*while (a < 3) {
        int a = 0;//若在此定义a则会无限循环
        cout << a << endl;//输出0 1 2
        a++;
    }
    cout << endl << a << endl;//输出的a是等于3*/
    while (1){//为1的话一直循环，直到满足if的条件后，break跳出循环
        if (a > 3) {
            break;
        } 
        cout << a << endl;
        a++;
    }
    cout << endl << a << endl;
    
    //判断字符长度
    char str[] = "123";
    int i = 0;
    while (str[i]){
        cout << str[i] << endl;
        i++;
    }
    cout << endl << "字符串的长度为：" << i << endl;

    while (str[i++]);  // str[3]  错误  i++,比正确值多1
        cout << endl << "字符串的长度为：" << i << endl;
}

do while循环

 int a = 0;
 do {
     cout << a << '\t';
     a++;
 } while (a<5);//while(0),dowhile不看条件，会首先直接进行一次循环

 while (0) {
     cout << a << '\t';
     a++;
 }

break&continue:

break: 跳出这个循环体，提前结束循环

continue：结束本次循环

---

三、用数组处理数据

一维数组

不允许对数组长度做动态定义（其实现在编译器很多都可以QWQ）

定义成全局变量初始值为0，否则初值不确定

给一部分元素赋值完其他元素默认值为0

对全部元素赋初值时可以不指定数组长度

不能对两个数组用 ‘=’ 赋值

int a[] = { 1,2,3,4,5,6,7,8 };//4*8=32字节
//int a[4] = { 1,2,3,4 };//4个int 4*4=16字节
//int a[] = { 1,2,3,4 };//4个int 4*4=16字节
//int a[4];//不初始化，放的随机的数
//int a[4] = {};//全为0
//int a[4] = {1};//第一位为1，其余全为0
//short a[] = { 1,2,3,4 };//4*4=16字节

//输出a[]
//for (int i = 0; i < 4; i++) {
for (int i = 0; i < sizeof(a)/sizeof(a[0]); i++) {
//sizeof(a)/sizeof(a[0] 
//32字节除以4字节 8个int/1个int=8 可以换为a[1]、a[2]……
	cout << a[i] << '\t';
}

字符数组(char)

字符数组 字符串，以’\0’结尾

默认为空字符

不能对两个数组用 ‘=’ 赋值

遇到 ‘/0’ 就表示字符串结束，结束输出

一些函数(const应该都能省略)

// 字符数组   字符串，以'\0'结尾
char str[] = "1234";//1 2 3 4 '\0'

cout << sizeof(str) << endl;//共5字节
cout << sizeof(str[0]) << endl;//char 1字节

for (int i = 0; i < sizeof(str) / sizeof(str[0]); i++) {
    cout << str[i] << '\t';//显示五个内容 '\0'显示为空
}
cout << str[0] << endl;//1
cout << str <<endl;

//单个字符，无'\0'
char s[] = { '1','2','3','4' };
cout << sizeof(s) << endl;//4个字符 无'\0'
cout << s << endl;//1234烫烫烫烫

s[2] = '\0'; 
cout << s << endl;//12

for (int i = 0; i < sizeof(s) / sizeof(s[0]); i++) {
    //cout << s[i] << '\t';
    cout << (int)s[i] << '\t';
}
cout << endl;
cout << s << endl;

二维数组

内存里按行存放

对行部分元素赋值用{ }

对全部元素赋初值，第一维长度可以不指定，但是第二维长度不能省略

int s[3];//1行3列
int a[3][2] = { {1,2},{3,4},{5} };//3行2列 最后一个其实是{5,0}
for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << a[r][c] << '\t';
	}
	cout << endl;
}

cout << sizeof(a) << endl;//4*3*2=24

int b[6];//1行6列
//赋值
for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		b[r * 2 + c] = a[r][c];
		//1       2       3       4       5       0
		//1:0*2+0 1:0*2+1 3:1*2+0 4:1*2+1 5:2*2+0 0:2*2+1
	}
}
for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++) {
	cout << b[i] << '\t';
}

---

四、指针与引用

变量与指针

一个变量的地址称为这个变量的指针

如果有一个变量专门用来存放地址，称之为指针变量

‘*’ 是取值运算符，'&'是取地址运算符

用法：形如 int *p=&i; ——> 把i的地址存到p中

不能用整数给指针变量赋值

指针变量只能指向同类型的指针变量

/*
int *p;//指针
*p;//间接运算符/解引用运算符
a*b;//乘号
*/
int a;//数据类型 变量名；
a = 10;
int* p;//数据类型 变量名；int类型指针 一个指针占4个字节 x86 32位 

//a && b;逻辑与  bool && bool =bool
//a & b;位运算与  int && int =int
//&a;//取地址运算符，结果是一个指针
p = &a;

*p = *p * a;//a=10*10

cout << &a << endl;//int* 16进制
cout << p << endl;
//*p;//间接运算符/解引用运算符
cout << *p << endl;//int 
cout << a << endl;

cout << sizeof(p) << endl;// int*
cout << sizeof(*p) << endl;// int

int b = 99;
p = &b;
*p = 66;//b和*p均改变
cout << *p << endl;
cout << b << endl;

字符与指针

    char c = 'a';//97 1字节
    char* p;//char类型指针 一个指针占4个字节
    
    p = &c;//char*
    *p;//char

    cout << sizeof(c) << endl;
    cout << sizeof(p) << endl;

    cout << c << endl;
    cout << *p << endl;

const int与指针

const int

	const int a = 10;
	//a = 20;不能这样改值，需要通过改变内存空间，改变值
	//int* p = &a;//const int* 常量指针
	int* p = (int*) & a;
	*p = 20;

	cout << a << endl;//a虽然显示10，但是实际上已经改为20了
	cout << *p << endl;

	const int a = 10;
	int* p = (int*)&a;
	*p = 20;
	cout << a << endl;
	cout << *p << endl;

	int b = 10;

	//int s[b];//用s[]内不能放变量，应使用常量
	//int s[10];
	int s[a];
	cout << sizeof(s) << endl;

const int指针类型的常量

#include <iostream>
using namespace std;

int main()
{
	//const int a = 10; //int类型的常量
	//int const a = 10; //int类型的常量
	//const int* p; //const int类型的指针
	
	int a = 10;
	int* const p = &a; //int指针 类型的 常量 int*类型的常量

	int b = 20;
	//p = &b;//p常量，指向a的地址后不能被改变
	*p=66;//int 可以被改变
	cout << a << endl;

	const int* const h=&a;//常量指针常量 cont int*  类型 的常量
	//h = &a;//不可改
	//*h = 100;//不可改
	a = 99;
	cout << a << endl;
}

char和int指针关系

int a;
char b = 48;

a = b;//char->int

a = 100;
b = a;//int->char
cout << (int)b << endl;
a = 200;
b = a;//int->char
cout << (int)b << endl;//不能正确赋值

cout << "-------------------------------" << endl;

a = 48;
b = 48;

int* x;
char* y;

x = &a;
y = (char*)&a;// int*

cout << x << endl;
cout << y << endl;// char* 字符串
cout << (int*)y << endl;

cout << *x << endl;
cout << *y << endl;//'0'
cout << (int)*y << endl;

x = (int*)&b;
y = &b;

cout << *x << endl;
cout << *y << endl;//'0' 以'\0'结束

cout << x << endl;
cout << y << endl;

数组与指针

若p已经指向数组一个元素，则p+1指向这个数组下一个元素

用数组名做参数的函数，传递的是数组首元素的地址

指针与数组示例1

int a[] = { 1,2,3,4 };
a[0];  // int
a[1];  // int

//int* p = a;
cout << a << endl;// 数组的首地址  int*
cout << a + 1 << endl;// 因为int是4字节,所以int*+1实际上是加了4

cout << *a << endl;
cout << *(a + 1) << endl;
cout << a[0] << endl;
cout << a[1] << endl;

for (int i = 0; i < 4; i++) {
	cout << a[i] << '\t';
}
cout << endl;

for (int i = 0; i < 4; i++) {  // 数组就是指针
	cout << *(a + i) << '\t';
}
cout << endl;

int* p = a;
*p;//1
//计算顺序不同
*p + 1;//2
*(p + 1);//2

// 指针就是数组
p[0];
p[1];
for (int i = 0; i < 4; i++) {
	cout << p[i] << '\t';
}
cout << endl;
cout << sizeof(a) << endl;  // 4*4=16
cout << sizeof(p) << endl;  // 4

指针与数组示例2

int a[] = { 1,2,3 };  // int类型的3位数组
int* p[4];   // int*类型的数组   指针数组

p[0] = a;
p[1] = &a[1];
p[2] = a + 2;
p[3] = &a[0];

cout << *p[0] << endl;

//输出数组a
for (int i = 0; i < 3; i++) {
	cout << a[i] << '\t';
}
cout << endl;

//输出a的地址
for (int i = 0; i < 4; i++) {
	cout << &a[i] << '\t';
}
cout << endl;

//输出p,p中放的是a的地址
for (int i = 0; i < 4; i++) {
	cout << p[i] << '\t';
}
cout << endl;

//输出p中的值：*p[]
for (int i = 0; i < 4; i++) {
	cout << *p[i] << '\t';
}
cout << endl;

//输出p的地址
for (int i = 0; i < 4; i++) {
	cout << &p[i] << '\t';
}
cout << endl;

指针与数组示例3

//int(*)[3];  //int[3]类型的指针  数组指针
//int(*)[3]  p;
//int a; //数据类型 变量名;

int(*p)[3];
//int* x = p;

int a[3] = { 1,2,3 };
a;  // int*
//p = a;// int*不能隐式类型转换
p = &a;  //int(*)[3]   *是int[3]的指针
*p;      // int* *是取地址里的值 //上下两个*不同
**p;//由int*->int         
cout << a << endl;   // int*
cout << &a << endl;  // int(*)[3]
cout << p << endl;   // int(*)[3]
cout << *p << endl;  // int*
cout << **p << endl; // int
cout << endl;

*p;
a;//二者含义一样

for (int i = 0; i < 3; i++) {
    cout << (*p)[i] << '\t';
}
cout << endl;
//*p换算成p[0]
for (int i = 0; i < 3; i++) {
    cout << p[0][i] << '\t';
}
cout << endl;

p = 0;			// 数组类型int[3]类型的指针  int(*)[3] 3*4=16
int* x = 0;     // int*  

p + 1;//加了三个int 12 加上一个数组
x + 1;//一个int 4 加上一个int

cout << endl;
cout << p + 1 << endl;
cout << x + 1 << endl;

//cout << *p[1] << endl;

p = &a;
cout << *p << endl;       // int*
cout << *(p + 1) << endl; // int* 和下面一致
cout << p[1] << endl;     // int* 和上面一致
cout << *p[1] << endl;    // 随机的数

二维数组与指针(较为复杂、比较难以理解)

int a[3][2] = { 1,2,3,4,5 };
int(*p)[2] = a;  // int(*)[2]  p;

cout << sizeof(a) << endl;// 24 数组
cout << sizeof(p) << endl;// 4  指针

cout << a << endl;// int(*)[2]
//报错int* p = a; // int(*)[2]
cout << a + 1 << endl;// int(*)[2]
cout << endl;

cout << *a << endl;// int*
cout << *(a + 1) << endl;// int*
cout << endl;

cout << a[0] << endl;// int*
cout << a[1] << endl;// int*

cout << **a << endl;// int
cout << **(a + 1) << endl;// int 加一加了两个int 一个数组
cout << *(a + 1) + 1 << endl;// int* 加一加了一个int
cout << *(*(a + 1) + 1) << endl;// int 加一加了一个int

cout << endl;
cout << *(a[1] + 1) << endl;//int
cout << a[1][1] << endl;//int
cout << endl;

cout << "------以下是通过两种循环输出------" << endl;
cout << "------第一种------" << endl;

for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << a[r][c] << '\t';
	}
	cout << endl;
}
cout << endl;

for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << *(a[r]+c) << '\t';
	}
	cout << endl;
}
cout << endl;

for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << *(*(a+r)+c) << '\t';
	}
	cout << endl;
}
cout << endl;

cout << "------以下将a换成p------" << endl;
cout << "------第二种------" << endl;

for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << p[r][c] << '\t';
	}
	cout << endl;
}
cout << endl;

for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << *(p[r] + c) << '\t';
	}
	cout << endl;
}
cout << endl;

for (int r = 0; r < 3; r++) {
	for (int c = 0; c < 2; c++) {
		cout << *(*(p + r) + c) << '\t';
	}
	cout << endl;
}

指针数据类型

动态内存分配

void func() {
    int a;
    // 函数结束被销毁释放
    // 不想让其被销毁就使用new堆数组
}

int main()
{
    int a = 10;  // 4字节 栈
    //函数结束被销毁释放

    int* p = new int(10); // 堆 没有名字 返回一个地址 变量初始化 一个int
    *p = 50;
    cout << *p << endl;

    //p = &a;不可放在delete前
    //函数结束仍存在，需要delete销毁释放
    delete p;//释放堆
    p = &a;

    //int b[a];//不能传一个变量

    p = new int[a] {1,2,3}; //int [10]; 数组初始化 十个int
    //p = new int[a] ; // 不初始化则放的是地址    int a[10];  p=a;

    cout << p[0] << endl;
    cout << p[1] << endl;
    for (int i = 0; i < a; i++) {
        cout << p[i] << '\t';
    }

    delete[]p;//释放堆数组
}

结构体的指针

ps:后面会对结构体有具体的详写

struct Hero {
    int hp;
    int mp;
};

int main()
{
    Hero a;//两个int 8字节

    cout << &a << endl;  // Hero*

    Hero* p;
    p = &a;
    cout << sizeof(p) << endl;//4字节

    char* m;//4字节
    cout << sizeof(m) << endl;

    a.hp = 100;
    a.mp = 50;
    p->hp = 200;//->
    p->mp = 100;

    //cout << a.hp << endl;
    //cout << a.mp << endl;
    cout << a.hp << '\t' << a.mp << endl;
    cout << endl;
    
    int* x=(int*)&a;
    cout << *x << endl;// int

    //取hp
    *x = 1000;
    //cout << a.hp << endl;
    cout << a.hp << '\t' << a.mp << endl;
    
    //向后加一取mp
    cout << *(x + 1) << endl;

    *(x + 1) = 500;
    cout << a.hp << '\t' << a.mp << endl;

}

指针的指针

	int a = 10;//a:9527
	int* p = &a;//p:9630

	&a;//int*    sint类型的指针
	&p;//int**  int*类型的指针

	int** pp = &p;//9630
	
	pp;  // int**
	*pp; // int*
	**pp; // int
	
	//p = &p;//错误，不能转过去
	p = (int*)&p;
	cout << p << endl;  // int*
	cout << &p << endl; // int**
	//cout << *p << endl; // int**
	cout << hex << *p << endl; // int
	cout << (int*)*p << endl;
	cout << *(int*)*p << endl;//取值

	int*** ppp;

引用

相当于起别名 int a; int &b=a;

引用只有声明,没有定义

声明引用同时必须初始化

声明一个引用之后不能让它再作为其他变量的引用

不能建立引用数组

不能建立引用的引用

没有引用的指针

静态static

#include <iostream>
using namespace std;

int func(int* a, int* b) {  // int* a=p;  int* b=p++;
	cout << a << endl;
	cout << b << endl;
	return *a + *b;
}

int main()
{
	int a[] = { 1, 3, 5, 7, 11, 13 };

	int* p;
	p = a + 3;

	cout << p << endl;
	cout << *p << '\t' << (*p++) << endl;// 先p++后*p
	//这里的 (*p++) 实际上是先解引用 p（得到7），然后 p 自增。
	//cout << *(p - 2) << '\t' << (*p++) << endl;

	printf("%x  %x", p, p++);
	cout << endl;

	func(p, p++);//先p++ 后p
	cout << p << endl;
}

函数与指针

函数的入口地址称为函数的指针

函数类型（*变量名）（形参表）int(*p)(int ,int)

---

五、函数

函数分类

从用户角度：库函数，自定义函数

从系统角度：无参函数，有参函数

#include <iostream>
using namespace std;
void change(int x) {// void:返回值为空  int x=a;
	x = 20;
	return;//可省
}
/*
返回值类型  函数名(参数类型 变量名) {  // 形式参数
	//
	return 返回值;
}
*/
int add(int a, int b) {
	int c = a + b;
	return c;
}//abc在此之后生命周期结束

int ave(int a, int b) {
//double ave(int a, int b) {//1.5
	//return (a + b) / 2;//输出1
	return (a + b) / 2.0;
	// (int+int)/double = double  1.5  int w=1.5;double->int
	//int输出1
}

double func(int a, int b) {
	return (a + b) / 2;   
	// (int+int)/int = int  1    double w=1;
	//double类型，但是不输出1.0，cout直接输出1
}

int main()
{
	int a = 10;
	change(a);
	cout << a << endl;//10

	cout << add(a, 2) << endl;//add(a, 2)返回是是一个w（无名字的变量），不是c

	cout << ave(1, 2) << endl;

	cout << func(1, 2) << endl;
}

函数声明

#include <iostream>
#include "head.h"
using namespace std;

/* head.h文件 声明
extern int add(int a, int b);//声明，可以有无数次
extern int add(int a, int b);
extern int add(int a, int b);
int add(int a, int b);//可省略extern 
extern int add(int , int );
extern int add(int b, int a);
extern int a;//见第最后一行//不可省extern 
*/

/* yuan.cpp
int ave(int a, int b) {//定义的同时声明了
	return (a + b) / 2.0;
}
*/
//int a = 100;
int main()//从main开始，只能有一个
{
	cout << a << endl;//100,见main上面一行
	cout << add(1, 2) << endl;

	int a;//定义，没有初始化  定义同时声明了
	a = 66;
	cout << a << endl;
	cout << ::a << endl;//::a引用全局变量的a
}

/* yuan.cpp文件 定义
int add(int a, int b) {//定义，只能有一次
					   //定义如果写在main后切不进行声明的话会报错，因计算机从后往前看
	int c = a + b;
	return c;
}
int a = 100;// 定义同时声明了
*/

交换数字案例

#include <iostream>
using namespace std;

//void exchange1(int a, int b) {//int a=a;int b=b;
//						     //    后      先 
//	int temp = a;
//	a = b;
//	b = temp;
//}

//void exchange2(int* x, int* y) {//int *x=&a;int *y=&b;
//	int temp = *x;
//	*x = *y;
//	*y = temp;
//}

//void exchange3(int** t, int** u) {//int** t=&x;int** u=&y;
//	int* temp = *t;//int *
//	*t = *u;
//	*u = temp;
//}

void exchange4(int& x, int y){// int& x=a , int& y=b
	int temp = x;
	x = y;
	y = temp;
}

void exchange5(int*& t, int*& u) {
	t;//int*
	int* temp = t;//int*
	t = u;
	u = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	//exchange1(&a, &b);
	exchange4(a, b);
	int* x = &a;
	int* y = &b;
	//exchange2(x, y);
	//exchange3(&x, &y);
	//exchange5(x, y);

	cout << a << endl;
	cout << b << endl;

	cout << x << endl;
	cout << y << endl;

	cout << *x << endl;//int
	cout << *y << endl;//

	cout << x << endl;
	cout << &a << endl;
}

地址引用

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int& z = a;
	z; // int

	int* p = &a;

	int* & x = p; //int* 给p换了个名字，叫做x
	//int** p = &p;

	x; //int*

	int b = 20;
	x = &b;

	cout << p << endl;//p放的是b的地址
	cout << &b << endl;
	cout << *p << endl;

}

数组参数

#include <iostream>
using namespace std;

//void func(int* x) {//int* x=a;
//    for (int i = 0; i < 3; i++) {
//        cout << x[i] << '\t';
//    }
//    cout << endl;
//
//    cout << sizeof(x) << endl;
//}

void func(int x[],int size) {//int* x=a;  只有4个字节，相当于指针
    for (int i = 0; i < size; i++) {
        cout << x[i] << '\t';
    }
    cout << endl;

    cout << sizeof(x) << endl;
}

int main()
{
    //int a[] = { 1,2,3 };
    int a[] = { 1,2,3,4,5 };
    a;//int*

    cout << a << endl;
    cout << a[2] << endl;//a[2]：首地址+2*int、即+2*4

    //func(a);//传参只是传的a的首地址，9527
    func(a, sizeof(a) / sizeof(a[0]));

    cout << sizeof(a) << endl;
}

char类型函数数组参数

#include <iostream>
using namespace std;

void func(char* x) {
	x[0]; //char
	x[2];
	for (int i = 0; x[i]; i++) {
		cout << x[i] << '\t';
	}
	cout << endl;
}

int length(char* s) {//char* s=str;
//int length(char s[]) {
	int i;
	for (i = 0; s[i]; i++);
	return i;
}

int main()
{
	char str[] = "123";//1 2 3 '\0' 字符串以'\0'结尾

	cout << sizeof(str) << endl;

	func(str);

	cout << length(str) << endl;//不包括'\0'
}

返回值

#include <iostream>
using namespace std;

int change(int a) {
	a = 20;
	return a;// int w = a; w=20;
}

int* change1(int a) {
	a = 20;
	return &a;// int w = a; w=20; 不能返回一个临时变量的地址
}

int* change2() {
	int* p = new int(20);
	return p;
}

int main()
{
	int a = 10;
	//a = change(a);//w = change(a)
	//cout << a << endl;

	int* p;
	p = change1(a);
	cout << *p << endl;
	cout << *change1(a) << endl;

	p = change2();
	cout << *p << endl;

	delete p;//new之后一定要delete
}

---