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

 和java不太一样的一样的标题打个*，方便对比

基本架构*

#include<iostream>
using namespace std;

int main()
{
    system("pause");
    return 0;
}

打印*

std::cout <<  "需要打印的内容" <<需要打印的变量<<std::endl

endl 是一个特殊的输出流控制符，它代表"end line"

注意加#include <iostream>才能使用哦

批注

//

/*

变量

数据类型 变量名 = 变量初始值；

int b =10;

常量*

 define 宏常量

通常在文件上

#define 常量名 常量值

*这个听学长说用了容易出问题所以还是推荐第二种

const 修饰的变量

通常在变量定义前假关键字const

const 数据类型 常量名 = 常量值

数据类型

整型

short

int 

long

long long

实型（浮点型）

单精度 float （7位有效数）

双精度 double（15-16位有效数）

字符

char xx = ‘a’

转义字符

字符串

C风格*

char 变量名[ ] = "字符串值"

C++风格

string 变量名 = "字符串值"

布尔型

bool flag = true/false

数组

是一个集合，里面存放了相同类型的数据元素,并且是由连续的内存位置组成的

一维数组

定义

数据类型 数组名[数组长度]；

数据类型 数组名[数组长度] = {值1, 值2, 值3 ...};

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

数组名*

1. 可以统计整个数组在内存中的长度： sizeof(数组名)

e.g获取数组元素个数

sizeof(arr)/sizeof(arr[0])  //整个数组占用的内存空间/每个元素占有的内存空间

2. 可以获取数组在内存中的首地址 ：cout<<数组名<<endl

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 ="<<a<<endl;

}

无参有返

int test03(){

        cout<<"this is test03" <<endl;

        return 1000;

}

有参有返

int test04(int a ){

        cout <<"this is test02 a ="<<a<<endl;

        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<<endl;
cout << "p为：" <<&a<<endl;   //打印结果一样

使用

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

*指针

 e.g 

//接上一个代码
//找到内存中的数据并修改
*p =1000；
cout << "a的地址为：" <<&a<<endl; //1000
cout << "p为：" <<&a<<endl;   //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>>变量