看我为了水作业速通C++！

e.g数组中第一怪元素的地址为：(int)&arr[0] //其实和首地址是一样的

&是取址符

二维数组

二维数组就是在一维数组上多加一个维度

定义

数据类型 数组名[行数][列数];

数据类型 数组名[行数][列数] = {{数据1,数据2}，{数据3,数据4}}；

数据类型 数组名[行数][列数] = {数据1, 数据2, 数据3, 数据4};

数据类型 数组名[][列数] = {数据1, 数据2, 数据3, 数据4};

*推荐使用第二种

数组名*

查看二维数组所占内存空间： sizeof(数组名)

e.g获取二维数组行数

sizeof(arr)/sizeof(arr[0])

获取二维数组列数

sizeof(arr)/sizeof(arr[0][0])

获取二维数组首地址： 直接打印

运算符

算术

处理四则运算

*注意在除法运算中除数不可以为0

赋值

将表达式的值赋给变量

比较

表达式的比较，返回true/false

逻辑

根据表达式的值返回true/false

非零的数都是真，不仅仅是1！

程序流程结构

顺序

程序按顺序执行，不发生跳转

选择

依据条件是否满足，有选择执行相应功能，还可以嵌套

if

单行

if(条件){

满足条件执行的语句

}

多行

if(条件){

条件满足执行的语句

}else{

条件不满足执行的语句

}

多条件

if(条件1){

条件1满足执行的语句

}else if(条件2){

条件2满足执行的语句

}else{

都不满足执行的语句

}

三目运算符

表达式1 ？ 表达式2 ：表达式3

1为真，执行2

1为假，执行3

e.g 1

将a和b做比较，将变量大的赋值给c

c = (a>b ? a:b);

e.g2 

三目运算符返回的是变量，可以继续赋值

(a>b ? a:b) =100;

switch

执行多条件分支

switch(表达式){

        case 结果1: 执行语句;break;

        case 结果2: 执行语句;break;

        ...

        default: 执行语句;break;

}

case里如果没有break会一直执行下去

与if相比，对于多条件判断效率高，但是不可以判断区间

循环

依据条件是否满足，循环多次执行某段代码，可以嵌套

while

满足循环条件，执行循环语句

while(循环条件）{

循环语句

}

for

满足循环条件，执行循环语句

for(起始表达式；条件表达式；末尾循环体){

循环语句;

}

跳转语句

break

用于跳出选择/循环结构

continue

在循环中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

goto*

如果标记的名称存在，执行到goto语句时候，会跳转到标记的位置

goto 标记

标记：

函数*

定义

返回值类型 函数名（参数列表）{

        函数体语句

        return 表达式

} 

e.g

int add(int num1, int num2){

        int sum = num1 +num2;

        return sum;

}

调用

函数名（参数）

值传递

函数调用时将数值传入给形参；值传递时，如果形参发生并不会影响实参

e.g  交换输入的两个数

void swap(int num1, int num2){

        int temp = num1;

        num1 = num2;

        num2 = temp;

}

常见样式

无参无返

e.g

void test01(){

        cout << "this is test01" << endl

}

有参无返

void test02(int a ){

        cout <<"this is test02 a ="<

}

无参有返

int test03(){

        cout<<"this is test03" <

        return 1000;

}

有参有返

int test04(int a ){

        cout <<"this is test02 a ="<

        return a;

}

声明*

提前告诉编译器函数名称以及如何调用函数，这样函数就可以在mian'方法后面。

函数的实际主题可以单独定义

*声明可以多次，定义只有一次

e.g

//声明

int max(int a, int b);

int main(){

        略

}

//定义

int max(int a, int b){

return a>b?a:b;

}

分文件编写*

让代码结构更加清晰

步骤：

1. 创建后缀名为.h的头文件

2. 创建后缀名为.cpp的源文件

3. 在头文件中写函数的声明

4. 在源文件中写函数的定义

感觉视频比较直观：55 函数-函数的分文件编写_哔哩哔哩_bilibili

指针*

用途：可以通过指针保存一个地址，间接访问内存

一个指针32位占4个字节空间，64位占4个字节空间 

定义

数据类型*指针变量名；

e.g

//1.定义指针
int a =10;
//指针定义
int * p
//让指针记录变量a的地址
p = &a;
cout << "a的地址为：" <<&a<
cout << "p为：" <<&a<//打印结果一样

使用

通过解引用的方式来找到指针指向的内存

*指针

 e.g 

//接上一个代码
//找到内存中的数据并修改
*p =1000；
cout << "a的地址为：" <<&a<//1000
cout << "p为：" <<&a<//1000

空指针

指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的(内存编号0~255)

int *指针 = NULL;

野指针

指针变量指向非法的内存空间

看const右侧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量

const修饰指针

修饰指针 --常量指针

指针的指向可以修改，但是指针指向的值不可以修改

const int*p = &a;

修饰常量 --指针常量

指针的指向不可以改，指针指向的值可以改

int * const p = &a；

既修饰指针又修饰常量

指针指向和指针指向的值都不可以改

const int * const p =&a;

int main() {
int a = 10;
int b = le;
//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
const int * p1 = &a;
p1 = &b;//正确
*p1 = 100; 报错
 
//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
int * const p2 = &a;
p2 = &b; //错误
*p2=100;//正确
 
//const既修饰指针又修饰常量
const int * const p3 = &a;
p3 = &b; //错误
*p3 = 100;//错误
system("pause");
return 0 ;
}

搭配使用

数组

//test pointer
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr; //这里arr就是数组首地址， *p == arr[0]
p++; //让指针向后偏移四个字节
//遍历数组
for (int i = 0; i < 10; i++) {
	p++;
}

函数

指针作为函数参数的时候，可以修改实参的值

e.g两个数字交换

值传递

值传递不会改变实参

就是我们一般的数字交换函数，懒得写了

地址传递

地址传递会改变实参

void swap02(int * p1, int *p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int a = 10;
int b = 20;
swap02(&a, &b);

关键字

sizeof

求出数据类型占用内存大小

sizeof (数据类型/变量)

cin*

用于从键盘获取数据

cin>>变量