c++入门基础（基础语法）

#include<iostream>     //头文件：输入输出
using namespace std;   //使用标准命名空间

int main() {     //主函数：程序入口

	cout << "Hello world" << endl;    //输出： Hello world

	return 0;     //程序出口
}

1.1.2运行结果

1.2注释

作用：在代码中加一些说明和解释，方便自己或其他程序员阅读代码

两种格式：

1、单行注释： / / 相关描述

通常放在某行代码的上方，或者某一条语句的末尾，对该行代码说明

2、多行注释： / * 相关描述 * /

通常放在一段代码的上方，对该段代码做整体说明

注：编译器在编译代码时，注释不会执行，会忽略注释的内容

2、数据类型

2.1数据类型

数据类型
类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双精度浮点型	double
无类型	void
宽字符型	wchar_t

数据类型占用空间大小
类型	位（n个字节）	范围
char	1	-128 到 127 或者 0 到 255
int	4	-21 4748 3648 到 21 4748 3647
float	4	7位有效数字
double	8	15～16位有效数字
unsigned char	1	0 到 255
signed char	1	-128 到 127
unsigned int	4	0 到 42 9496 7295
signed int	4	-21 4748 3648 到 21 4748 3647
short int	2	-3 2768 到 3 2767
unsigned short int	2	0 到 6 5535
signed short int	2	-3 2768 到 3 2767
long int	8	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8	0 到 18,446,744,073,709,551,615
long double	16
wchar_t	2或4	1个宽字符

一个字节 = 8bit = 8 个位

一些基本类型可以使用一个或多个类型修饰符进行修饰：

signed 符号型
unsigned 无符号型
short 短型
long 长型

字符型

作用：存单个字符

语法： char ch = '单个字符' ; 如： char ch = 'p' ;

注： 1、用单引号将字符括起来，不要用双引号

2、单引号内只能有一个字符，不可以是字符串

字符串型

作用：存多个字符组成的字符串

语法： string str = "字符串" 如： string str = "abc123";

布尔型（bool）

作用：布尔数据类型代表真或假的值

bool类型只有两个值：

true -- 真（本质是1）
false -- 假（本质是0）

2.3标识符命名规则

即变量、常量、函数的命名规则：

标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线，不能是数字
标识符中字母区分大小写
标识符不能是关键字

正确命名：abc_、a1、c3、_t 、Char 、 int4 等

错误命名：int、4ab、long、"abc" 等

大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。所以Char可以当作变量使用。

2.2变量

变量：

1 变量代表一个有名字的、具有特定属性的一个存储单元；

2 变量用来存放数据，也就是存放变量的值；

3 变量的值可以改变；

4 变量有特定的类型，类型决定了存储单元的大小和变量值的范围，运算符可应用于变量上

语法： 数据类型变量命 = 初始值；

注：每个变量名都是唯一，不能重命名。

2.4常量

作用：用于记录程序中不可更改的数据

两种方式：

1、宏定义：# define 常量名常量值

位于头文件后，主函数前。

2、const修饰的变量： const 数据类型变量 = 常量值

修饰该变量为常量，不可修改。

2.5输入输出流

输出：cout

cout << 变量1;
cout << 变量 1 << 变量2 << 变量3;
cout << "字符串";

输出：cin

cin >> 变量1;
cin >> 变量1 >> 变量2 >> 变量3;

2.6关键字

3、运算符

新手主要学习一下三种运算符：

算术运算符
关系运算符
逻辑运算符
位运算符（新手不学）

3.1算术运算符

符号	描述	示例（a = 5, b = 2）	结果
+	把两个操作数相加	a + b	7
-	把两个操作数相减	a - b	3
*	把两个操作数相乘	a * b	10
/	把两个操作数相除，取整	a / b	2
%	把两个操作数相除，取余（取模）	a % b	1
++	自增运算符，整数值增加 1	a++ 、++a	5、6
--	自减运算符，整数值减少 1	b--、 --b	2、1

注：

只有整型变量可以进行取模运算
在除法运算中，除数不能为0

a++：先赋值，后自增

++a：先自增，后赋值

a--、--a 同理

3.2关系运算符

符号	描述	示例（a=5、b=2、c=2）	结果
==	判断两个操作数的值是否相等，如果相等则条件为真。	a==b、b==c	假、真
!=	判断两个操作数的值是否不相等，如果不相等则条件为真。	a != b、b != c	真、假
>	判断左操作数的值是否大于右操作数的值，如果是则条件为真。	a>b、b>c	真、假
<	判断左操作数的值是否小于右操作数的值，如果是则条件为真	a<b、b<c	假、假
>=	判断左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	a>=b、b>=c	真、真
<=	判断左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	a<=b、a<=c	假、假

#include<iostream>
using namespace std;

int main(){
	int a = 5;
	int b = 2;
	int c = 2;
	
	if(a==b){
		cout<<"a等于b"<<endl;
	}else{
		cout<<"a不等于b"<<endl;
	}
	
	if(a!=b){
		cout<<"a不等于b"<<endl;
	}else{
		cout<<"a等于b"<<endl;
	}
	
	if(a>=b){
		cout<<"a大于或等于b"<<endl;
	}else{
		cout<<"a不大于或不等于b"<<endl;
	}
	
	return 0;
}

3.3逻辑运算符

符号	描述	示例	结果
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
\|\|	或	a \|\| b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。
！	非	!a	如果a为假，则!a为真；如果a为真，则!a为假。

3.4位运算符

(后续更新)

4、程序流程结构

三大基本结构：

顺序结构：程序按照顺序一次执行，不发生跳转
选择结构：判断条件是否满足，执行相应的程序
循环结构：判断条件是否满足，对某段程序重复执行

4.1顺序结构

如上图所示。

4.2选择结构（分支结构）

4.2.1if-else语句

语法1：

if( 条件 ){
   执行语句1
}else{
   执行语句2
}

语法2：

if(  条件1 ){
    执行语句1
}else if( 条件2 ) {
    执行语句2
}else{
    执行语句n
}

#include<iostream>
using namespace std;

int main() {

	int a=93,b=45;//a:语文成绩  b:数学成绩 
	if(a>=60){
		cout<<"语文成绩及格"<<endl;
	}else{
		cout<<"语文成绩不及格"<<endl;
	}
	
	if(a<60){
		cout<<"语文成绩不及格"<<endl;
	}else if(a>=60 && a<70){
		cout<<"语文成绩及格"<<endl;
	}else if(a>=70 && a<90){
		cout<<"语文成绩良"<<endl;
	}else{
		cout<<"语文成绩优秀"<<endl; 
	}

	return 0;
}

4.2.2switch语句

注意：

switch语句中表达式数据类型只能是整型或者字符型
case里如果没有break，那么程序会一直向下执行

总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

switch(变量)
{
    case 条件1:  //条件为：变量的值      整形：1、2、...  字符型：'a'、'f'、...
        执行语句1;
        break;    //执行完这一种情况后不会再执行下面的语句，即跳出switch
    case 条件2:
        执行语句2;
        break;
    case 条件3:
        执行语句3;
        break;
    default:执行语句4;	//如果上面条件都不满足，就执行语句4
}

#include<iostream>
using namespace std;

int main() {
	int a;
	cin>>a;
	
	switch(a){
		case 1:
			cout<<"一技能"<<endl;
			break; 
		case 2:
			cout<<"二技能"<<endl;
			break; 
		case 3:
			cout<<"三技能"<<endl;
			break; 
		default:
			cout<<"输入错误"<<endl;
	} 
	
	return 0;
}

4.2.3多条件的if分支结构

4.3循环结构

c++中有三种循环，

for循环：一边用于已知循环次数

while循环：未知循环次数

do...while循环：第一次不用进行条件判断

4.3.1for循环

语法：

for(表达式1；表达式2；表达式3){ // 表达式2为真继续循环，否则结束循环

循环体语句；

}

其中：

表达式1：初始条件

表达式2：循环条件

表达式3：初始条件变化

#include<iostream>
using namespace std;

int main() {
	int a;
	cout<<"请输入："; 
	cin>>a;
	
	for(int i=1; i<=a; i++){  //  i从1开始，i每次循环自增1，当大于a时结束循环
		cout<<"第"<<i<<"次"<<endl;
	}

	return 0;
}

4.3.2while循环

语法：

while( 循环条件 ){ // 条件为真继续循环，否则结束循环

循环体语句

}

#include<iostream>
using namespace std;

int main() {
	int a;
	cout<<"请输入："; 
	cin>>a;
	
	while(a>=0){
		cout<<"第"<<a<<"次"<<endl;
		--a;
	}

	return 0;
}

3.3.3do...while循环

语法：

do{

循环体语句

}while( 循环条件)

注：该循环与while循环有区别，这是先循环一次，再进行判断

#include<iostream>
using namespace std;

int main() {
	int a;
	cout<<"请输入："; 
	cin>>a;
	
	do{
		cout<<a<<endl;
		--a;
	}while(a>=0);

	return 0;
}

3.3.4嵌套循环

在某循环体中再嵌套一层循环。

一个变量相当于输出一个点，一个循环相当于输出一条线，双重循环相当于输出一个平面，三重循环相当于输出一个立体图形

语法：由for、while、do...while循环，其中两个或以上的组合

#include<iostream>
using namespace std;

int main() {
	
	for(int i=1; i<=6; i++){
		for(int j=1; j<=6; j++){
			cout<<"*"<<" ";
		}
		cout<<endl;
	}

	return 0;
}

4.4三目运算符

语法：表达式1 ? 表达式2 ：表达式3

解释：

当表达式1的值为真，执行表达式2，并返回表达式2的结果；
当表达式1的值为假，执行表达式3，并返回表达式3的结果。

#include<iostream>
using namespace std;

int main() {
	int a=10,b=20,c;
	c=a>b ? a:b;    // a>b为假，所以c=b
	
	cout<<a<<" "<<b<<" "<<c;
	
	return 0;
}

4.5跳转语句

符号	描述
break	在switch条件语句中，终止case并跳出switch 在循环语句中，跳出当前的循环在嵌套循环中，跳出最近的内层循环
continue	不执行下面的语句，回到前面。在循环中时，跳过剩下的程序不再执行，重新开始下一轮循环。
goto	无条件跳到指定位置。

注意：continue并不会终止整个循环，而break会跳出循环

goto语句示例：

#include<iostream>
using namespace std;

int main() {
	cout << "aaaaaa" << endl;

	goto THIS;

	cout << "bbbbbbb" << endl;
	cout << "ccccccc" << endl;

	THIS:
	cout << "VVVVVVV" << endl;

	return 0;
}

注意：不建议使用goto语句，容易造成程序流程混乱

5、数组

定义：是一个集合，存放相同数据类型的数据元素。

特点：数组中的每个元素都是相同的数据类型，内存是连续的。

5.1一维数组

语法：数据类型数组名称 [ 数组大小 ]

int a[5] = {1, 2, 3, 4,5 };    //全部初始化
int a[5] = { 0 };     // 用0初始化全部数据
int a[ ] = {1, 2, 9, 11 ,78 };     // 不指定数组长度
int a[5] = {12};      //第一个元素为12，其它为0
char ch[3] = {'c', 'e', '%'};

注：数组中下标是从0开始索引

#include<iostream>
using namespace std;

int main() {
	int a[10];

	a[0] = 10;
	a[1] = 9;
	a[2] = 25;

	//根据下标输出
	cout << a[0] << endl;
	cout << a[1] << endl;
	cout << a[2] << endl;

	int a2[10] = { 10, 9,8,7,6,5,4,3,2,1 };
	
	//循环输出 
	for (int i = 0; i < 10; i++)
	{
		cout << a2[i] << endl;
	}

	return 0;
}

获取数组大小及地址

&：取地址符号

#include<iostream>
using namespace std;

int main() {
	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "整个数组所占内存空间为： " << sizeof(a) << endl;
	cout << "每个元素所占内存空间为： " << sizeof(a[0]) << endl;
	cout << "数组的元素个数为： " << sizeof(a) / sizeof(a[0]) << endl;

	//以通过数组名获取到数组首地址
	cout << "数组首地址为： " << (int *)a << endl;
	cout << "数组中第一个元素地址为： " << (int *)&a[0] << endl;
	cout << "数组中第二个元素地址为： " << (int *)&a[1] << endl;

	return 0;
}

5.2二维数组

语法：数据类型数组名[ 行数 ] [ 列数 ]

int  a[2][3];
int b[2][3] = { {1,2,3}, {4,5,6 } };
int c[ ][3] = {1,2,3};     //只写列上元素，行自动生成

学生成绩：

姓名	语文	数学	英语
张三	89	95	98
李四	79	78	56
王五	90	99	93

#include<iostream>
using namespace std;

int main() {
	int scores[3][3] ={
		{89,95,98},
		{79,78,56},
		{90,99,93},
	};

	string names[3] = { "张三","李四","王五" };

	for (int i=0; i<3;i++){
		int sum=0;
		for (int j=0; j<3; j++){
			sum+=scores[i][j];
		}
		cout << names[i] << "总分为： " << sum << endl;
	}

	return 0;
}

初始化只有一列：

#include<iostream>
using namespace std;

int main() {
	int arr[2][3] = { 1,2,3 };

	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

	return 0;
}

// 这两种方法是一样的
char a[6] = {'h', 'e', 'l', 'l', 'O','\0'};
char b[] = "hello";

5.3数组增删改查

求字符数组的长度： strlen( 数组名 )

按值删除
按下标删除
某元素，插入某个位置
修改某个位置的值
查找某个元素的位置
找某下标的值

#include<iostream>
#include<cstring>
using namespace std;

int main() {
	
	char arr[10]={'0','d','2','p','t','z','+','7'};
	cout<<"初始值（字符）："<<endl; 
	for(int i=0;i<strlen(arr);i++){
		cout<<arr[i]<<"  ";
	}
	cout<<endl<<endl;
	
	//按值删除
	char a; 
	cout<<"需要删除的值："; 
	cin>>a;
	for(int i=0; i<strlen(arr); i++){
		if( arr[i]==a){
				for(int j=i;j<10-1;j++){
					arr[j]=arr[j+1];
				}
		}
	}
	cout<<"按值删除后："<<endl; 
	for(int i=0;i<strlen(arr);i++){
		cout<<arr[i]<<"  ";
	}
	cout<<endl<<endl;
	
	//按下标删除
	int b;
	cout<<"要删除元素的下标：";
	cin>>b;
	for(int i=b;i<strlen(arr);i++){
		arr[i]=arr[i+1];
	}
	cout<<"按下标删除后："<<endl; 
	for(int i=0;i<strlen(arr);i++){
		cout<<arr[i]<<"  ";
	}
	cout<<endl<<endl;
	
	//增：插入某个位置
	int index;
	char ch;
	cout<<"要插入的位置、值（空格隔开）：";
	cin>>index>>ch;
	for(int i=strlen(arr);i>=index;i--){
		arr[i+1]=arr[i];
	}
	arr[index]=ch;
	for(int i=0;i<strlen(arr);i++){
		cout<<arr[i]<<"  ";
	}
	cout<<endl<<endl;
	
	//改：修改某个位置的值 
	int index2;
	char ch2;
	cout<<"要改的位置、值（空格隔开）：";
	cin>>index2>>ch2;
	arr[index2]=ch2; 
	for(int i=0;i<strlen(arr);i++){
		cout<<arr[i]<<"  ";
	}
	cout<<endl<<endl;
	
	//查：查找某个元素的位置
	char ch3;
	cout<<"要查找的元素：";
	cin>>ch3;
	 for(int i=0;i<strlen(arr);i++){
		if(arr[i]==ch3){
			cout<<i<<" ";
		}
	}
	cout<<endl<<endl;
	
	//查：查找某下标的值
	int index3;
	cout<<"某下标的值:"; 
	cin>>index3;
	cout<<arr[index3];
	cout<<endl<<endl; 
	
	
	return 0;
}

6排序

6.1桶排序

思想：在已知数据范围的情况下，分配相应范围大小的数组空间。遍历所有数据，遇到对应下标时，计数增一。

桶排序动画视频

#include<iostream>
#define N 20  //宏定义，数组最大下标为N-1 
using namespace std;

int main() {
	int arr[N]={0};
	int a,n;
	printf("(数据范围0~%d) 数据个数n:",N);
	cin>>n;
	printf("输入n个数据(空格隔开):");
	for(int i=0;i<n;i++){
		cin>>a;
		++arr[a];
	}
	int num;
	for(int i=N-1;i>=0;i--){  //输出 
		num=arr[i];  
		for(int j=num;j>0;j--){  //对于的元素有几个 
			cout<<i<<" ";
		}
		
	}
}

6.2选择排序

思想：

在待排序的一组数据中，选出最小（最大）的一个数与第一个位置的数交换。
然后在剩下的数中，再找最小（最大）的数与第二个位置的数交换位置。
依次类推直到第 n-1 个元素与第 n 个元素交换位置，选择排序结束。

//从小到大排序 
#include <iostream>
using namespace std;
int main(){
	int arr[5]={7,2,8,3,1};
	int min,index;
	
	for(int i=0;i<5-1;i++){
		min=arr[i];    //设当前值为最小值 
		index=i;      //设当前下标为最小下标 
		for(int j=i+1;j<5;j++){ // 从i的下一个开始比较
			if(min>arr[j]){
				min=arr[j];  //更新最小值 
				index=j;   //更新最新下标 
			}
		}
		if(index != i){   //下标不为i，即找到新的最小值 
			arr[index]=arr[i];
			arr[i]=min;
		}
	}
	
	for(int i=0;i<5;i++){  //输出 
		cout<<arr[i]<<" ";
	}
	
	return 0; 
}

6.3冒泡排序

思想：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这一趟比较完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。（排好序的数不再进行比较）
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

如：气泡在水中上浮时，气泡越来越大

冒泡排序动画视频

基本解法：

//从小到大 
#include <iostream>
using namespace std;
int main(){
	int arr[200]={};
	int a,n;
	cout<<"输入n:";
	cin>>n;
	for(int i=1;i<=n;i++){ //逐个存入数组 
		cin>>a;
		arr[i]=a;
	}
	
	int temp;
	for(int i=1;i<=n-1;i++){
		for(int j=1;j<=n-i;j++){
			if(arr[j]>arr[j+1]){
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		} 
	
	} 
	
	for(int i=1;i<=n;i++){  //输出 
		cout<<arr[i]<<" ";
	}
	
	return 0; 
}

优化程序：

//从小到大 
#include <iostream>
using namespace std;
int main(){
	int arr[200]={};
	int a,n;
	cout<<"输入n:";
	cin>>n;
	for(int i=1;i<=n;i++){ //逐个存入数组 
		cin>>a;
		arr[i]=a;
	}
	
	int temp,flag;
	for(int i=1;i<=n-1;i++){
		flag=0;    //0:未移动  1：移动 
		for(int j=0;j<=n-i;j++){
			if(arr[j]>arr[j+1]){
				flag=1;
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		} 
		if(!flag){   //每一趟没被移动，说明数列有序 
			break;
		}
	
	} 
	
	for(int i=1;i<=n;i++){  //输出 
		cout<<arr[i]<<" ";
	}
	
	return 0; 
}

7、字符串

char a[1000];
strlen(a);

7.1c++字符串输入总结

直接输出string类型，须加<string>

分为：cin、getchar和scanf、cin.get()、gets、cin.getline()、getline

1、cin: 接收字符串时，遇“空格”、“TAB”、“回车”都结束

char a[20];
cin>>a;
cout<<a;
//遇到空格、回车键结束

2、scanf: 接收字符串时，遇“空格”、“TAB”、“回车”都结束

getchar: 接收一个字符

char ch2[20]; // 字符数组
scanf("%s", ch2);
printf("%s\n", ch2);
getchar(); // 用完 scanf 后，清除缓冲区 

/* 注：scanf读取字符时遇到空格和回车符时都会停止读取，
此时输入缓冲区还剩一个\n，如果不清除，会影响下一次的输入*/

3、 cin.get(): 接收字符串时, 可以接收空格

#include<iostream>
using namespace std;

int main() {
	char ch;
	cin.get(ch);  //获取一个字符
	cout<<ch<<endl;

    getchar();  //清除缓存区
    
	char ch2[20];
	cin.get(ch2,10);  //获取字符串，存入ch2中，限制长度为10-1=9
	cout<<ch2;

	return 0;
}

4、gets(): 接收字符串时, 可以接收空格

char ch1 [20]; // 字符数组
gets(ch1);  // 输入    不能写成ch1=gets();
puts(ch1);   // 输出

5、cin.getline()：接收字符串时，可以接收空格并输出

#include<iostream>
using namespace std;
int main(){
	char m[20];
	cin.getline(m,4);   //存入m，限制长度为4个字符，第5个位置存\0
	cout<<m<<endl;
	
	return 0;
}

#include<iostream>
using namespace std;
int main(){
	char m2[20];
	cin.getline(m2,5,'a');   //存入m，限制长度为4个字符，第5个位置存\0, 遇到字符a停止
	cout<<m2<<endl;    //当输入123abcde时，输入123
	
	return 0;
}

6、getline() : 接收字符串时，可以接收空格并输出，需包含头文件“ #include<cstring> ”

#include<iostream>
#include<cstring>
using namespace std;
int main(){
	string str;
	getline(cin, str);//用于string字符串类型，存入带空格的字符串
	cout <<"str= "<< str << endl;

	char a[10];
	cin.getline(a, 6);//用于字符数组类型，存入带空格的字符串
	cout <<"a= "<< a;
}

7.2 字符串处理函数

头文件：#iclude<cstring>

strcpy(s1,s2)、strcmp(s1,s2)、strlen(s1)、strcat(s1,s2)、strlwr(s1)、strupr(s1)

1、strcpy(s1, s2)

说明：把字符串s2拷贝到s1，即s1的数据变成了s2的数据

注意：必须保证s1的内存空间大于或等于s2

#include<iostream>
#include<cstring>
using namespace std;
int main(){
	char str1[] = "123";
	char str2[] = "abc";

	cout<<strcpy(str1,str2);
}

//输出结果：abc

2、strcmp(s1, s2)

说明：按照ASCII码顺序，s1和s2中的每个字符进行比较，

注意：当遇到某个字符不等时结束判断

返回值：比较结果。

字符串1=字符串2，返回值=0；
字符串1>字符串2，返回值>0，即 1；
字符串1<字符串2，返回值<0，即 -1。

#include<iostream>
#include<cstring>
using namespace std;
int main(){
	char str1[] = "123456";
	char str2[] = "123456";
	char str3[] = "a23456";
	cout<<strcmp(str1,str2)<<"  "<<strcmp(str1,str3);
	
}

//输出结果为： 0   -1

3、strlen(s1)

作用：求字符数组或字符串的长度

#include<iostream>
#include<cstring>
using namespace std;
int main(){
	char str1[] = "123";
	char str2[] = "abcabc";
	
	cout<<strlen(str1)<<"  "<<strlen(str2);
}

//输出结果：3   6

4、strcat（s1, s2)

作用：把s2拼接到s1后面

#include<iostream>
#include<cstring>
using namespace std;
int main(){
	char s1[] = "123";
	char s2[] = "abc";

	cout<<strcat(s1,s2);
}

//输出结果：123abc

5、strlwr(s1) 大写转小写

6、strupr(s1) 小写转大写

8、函数

作用： 将一段经常使用的代码封装起来，减少重复代码

返回值类型 函数名 (数据类型 变量1， 数据类型 变量2){

      函数体语句;

      return  表达式;

}

#include<iostream>
using namespace std;
 
//1、 无参无返
void test1(){
	cout<<"无参无返"<<endl;
}

//2、 有参无返
void test2(int a){
	cout<<"有参无返"<<endl;
	cout<<"a="<<a<< endl;
}

//3、无参有返
int test3(){
	cout<<"无参有返"<<endl;
	return 10;
}

//4、有参有返
int test4(int num1, int num2){  //此处num1、num2为形式参数，即形参
	cout<<"有参有返 "<<endl;
	int sum=num1+num2;
	return sum;
}

int main(){
	
	int a=10,b=20; 
	test1();
	test2(a);
	cout<<test3()<<endl;
	
	int sum;
	sum=test4(a,b);  //此处a、b为实际参数，即实参
	cout<<sum<<endl;
	
	return 0; 
}

形参数据改变时，实参不会改变。
形参和实参可以同名，也可以不同名

9、指针

语法：数据类型 * 指针变量

指针所占内存：32位电脑占4字节，64位电脑占8字节。所有数据量类型都一样。

9.1一维指针

示例：

#include<iostream>
using namespace std;

int main() {
	int a = 10;
	int *p;
	
	p=&a;   //a的地址 
	int *q=&a;  //a的值   *q可以改变对应变量的值

	cout<<"(地址)a："<<&a<<endl;
	cout<<"(地址)p: "<<p<<endl;
	cout<<"(值)*p："<<*p<<endl; 
	cout<<"(值)*q："<<*q<<endl;
	
	//以下是错误案例 
	int *t;
	*t=a;
	
	cout<<"*t"<<*t<<endl;
	cout<<"t"<<t<<endl;

	return 0;
}

输出时可以简单的理解成：* 号取值，& 号取地址

9.2const修饰

#include<iostream>
using namespace std;

int main() {
	int a = 10;
	int b = 10;

	//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; //错误

	return 0;
}

9.3二维数组

9.4指针与数组、函数

指针与数组：

#include<iostream>
using namespace std;
int main()
{
	int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	int *p = arr;//指向首元素
	for (int i = 0; i < 10; i++)
	{
		
		cout << *p<< endl;
		p++;
	}
	
	return 0;
}

指针与函数：

传地址会改变实参的值，穿值不改变

#include<iostream>
using namespace std;

void s1(int a, int b){
	int temp=0;
	temp = a;
	a = b;
	b = temp;
}
void s2(int *a, int *b){
	int temp = *a;
	*a = *b;
	*b = temp;
}

int main(){
	int a = 10;
	int b = 20;
	//值传递
	s1(a, b);
	cout<<"传值后："<<a <<" "<<b<<endl;
	//地址传递
	s2(&a, &b);
	cout<<"传地址后："<<a<<" "<<b<<endl;
	
	return 0;
}

10、结构体

10.1结构体概念与定义

结构体就像excel表格一样，可以存不同类型的元素。数组只能存一种类型的元素。

语法：

struct 结构体名{
结构体成员列表
};

struct是关键字不能省略。

结构体的使用有三种方式：

#include<iostream>
using namespace std;
 
struct student{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int math;    //数学 
	int chinese;  //语文 
}stu3; // stu3是单独定义的一个对象 

int main() {
	//方法一 
	struct student stu1; //struct 关键字可以省略
	stu1.name = "小码";
	stu1.age = 18;
	stu1.math = 120;
	stu1.chinese=135; 
	cout<<"姓名："<<stu1.name<<" 年龄："<< stu1.age <<" 数学："<<stu1.math<<" 语文："<<stu1.chinese<<endl;

	//方法二
	struct student stu2 = { "小明",19,116,129 };
	cout<<"姓名："<<stu2.name<<" 年龄："<< stu2.age <<" 数学："<<stu2.math<<" 语文："<<stu2.chinese<<endl;

	//方法三 
	stu3.name = "小花";
	stu3.age = 18;
	stu3.math = 130;
	stu3.chinese=140; 
	cout<<"姓名："<<stu3.name<<" 年龄："<< stu3.age <<" 数学："<<stu3.math<<" 语文："<<stu3.chinese<<endl;

	return 0;
}

10.2结构体数组

#include<iostream>
using namespace std;
 
struct student{
	//成员列表
	string name;  //姓名
	int math;      //数学 
	int chinese;    //语文 
};

int main() {
	
	struct student arr[3]={
		{"张三",146,80},
		{"李四",119,90},
		{"王五",120,53}
	};

	for (int i=0;i<3;i++){
		cout<<"姓名:"<<arr[i].name
		<<" 数学:"<<arr[i].math
		<<" 语文:"<<arr[i].chinese
		<<endl;
	}

	return 0;
}

10.3结构体指针

#include<iostream>
using namespace std;

struct student{
	string name;  //姓名
	int math;      //数学 
	int chinese;    //语文 
};

int main(){

	student stu1 = {"周杰伦",132,149};    //一个对象 
	struct student *p = &stu1;
	p->chinese = 80; 
	cout<<"姓名:"<<p->name
		<<" 数学:"<<p->math
		<<" 语文:"<<p->chinese
		<<endl<<endl;;
		
		
	student stu2[2] = {   //对象数组 
		{"小明",112,150},
		{"小美",123,97,}
	};
	student (*q)[2];   //结构体数组指针 
	q=&stu2;
	q[1]->math=150;
	for (int i=0;i<2;i++){
		cout<<"姓名:"<<q[i]->name
		<<" 数学:"<<q[i]->math
		<<" 语文:"<<q[i]->chinese
		<<endl;
	}

	return 0;
}

10.4结构体嵌套（含数组）

嵌套时也可以使用数组。

#include<iostream>
#define N 40
using namespace std;

struct student{   //学生 
	string name;  //姓名
	int math;      //数学 
	int chinese;    //语文 
};

struct school{  //班 
	string teacher;  //班主任 
	string grade;   //年级 
	student students[N];   //一个班N个人 
}; 


int main(){

	school class1;
	class1.grade="二年级三班";
	class1.teacher="马冬梅";
	class1.students[0].name="小明";
	class1.students[0].chinese=98;
	class1.students[0].math=130;
	
	
	class1.students[1].name="小红";
	class1.students[1].chinese=118;
	class1.students[1].math=123;
	 
	for (int i=0;i<2;i++){
		cout<<"年级:"<<class1.grade
		<<" 班主任:"<<class1.teacher
		<<" 姓名:"<<class1.students[i].name
		<<" 语文:"<<class1.students[i].chinese
		<<" 数学:"<<class1.students[i].math
		<<endl;
	}

	return 0;
}

10.5结构体作函数参数

传值的时候不改变实参的值，穿地址会修改实参的值。

#include<iostream>
using namespace std;

struct student{   //学生 
	string name;  //姓名
	int math;      //数学 
	int chinese;    //语文 
};

//传值   不可修改数据
void s1(student stu){
	stu.name="小伦";
	cout<<"第一次："; 
	cout<<"姓名:"<<stu.name
		<<" 数学:"<<stu.math
		<<" 语文:"<<stu.chinese
		<<endl; 
} 

//传地址   可修改数据
void s2(student *stu){
	stu->name="小伦";
} 


int main(){
	
	student stu={"小明",98,77};

	//传值
	s1(stu);
	cout<<"第二次："; 
	cout<<"姓名:"<<stu.name
		<<" 数学:"<<stu.math
		<<" 语文:"<<stu.chinese
		<<endl; 
		
	s2(&stu);
	cout<<"第三次："; 
	cout<<"姓名:"<<stu.name
		<<" 数学:"<<stu.math
		<<" 语文:"<<stu.chinese
		<<endl; 

	return 0;
}

11、查找

1、二分查找

#include<iostream>
using namespace std;
 
int main(){
	int arr[]={1,2,4,6,8,9,13,15};
    int left=0;
    int right=7;
    int mid,flag=0,a;
    cout<<"输入需要查找的值:";
    cin>>a;
    while (left<=right){
        mid=(left+right)/2;
        if (arr[mid]>a){
            right=mid-1;
        }else if(arr[mid]<a){
            left=mid+1;
        }else{
            cout<<"索引:"<< mid<<endl;
            flag=1;
            break;
        }
    }
    
    if(flag==0){
		cout<<"查无此数！"<<endl;
	}
 
    return 0;
}