目录
一、选择结构：
1、if语句：
作用：执行满足条件的语句。分为下面三种形式：
-
单行格式if语句
-
多行格式if语句
-
多条件的if语句
int main() {
//选择结构-单行if语句
int score = 200;
//if语句
//注意事项，在if判断语句后面，不要加分号
if (score > 600)
{
cout << "我考上了一本大学！！！" << endl;
}
//多行格式if语句
if (score > 600)
{
cout << "我考上了一本大学" << endl;
}
else
{
cout << "我未考上一本大学" << endl;
}
//多条件if语句：
if (score > 600)
{
cout << "我考上了一本大学" << endl;
}
else if (score > 500)
{
cout << "我考上了二本大学" << endl;
}
else if (score > 400)
{
cout << "我考上了三本大学" << endl;
}
else
{
cout << "我未考上本科" << endl;
}
system("pause");
return 0;
}同时C++也支持空if体，但是要加分号；
int main()
{
if (1 > 0);
system("pause");
return 0;
}2、三目运算符：
作用： 通过三目运算符实现简单的判断
语法：表达式1 ? 表达式2 ：表达式3
int main() {
int a = 10;
int b = 20;
int c = 0;
c = a > b ? a : b;
cout << "c = " << c << endl; //20
//C++中三目运算符返回的是变量,可以继续赋值
(a > b ? a : b) = 100;
cout << "a = " << a << endl; //10
cout << "b = " << b << endl; //100
cout << "c = " << c << endl; //20
system("pause");
return 0;
}3、switch语句：
作用：执行多条件分支语句
语法：
switch(表达式)
{
case 结果1：执行语句;break;
case 结果2：执行语句;break;
...
default:执行语句;break;
}注意1：switch语句中表达式类型只能是整型或者字符型
注意2：case里如果没有break，那么程序会一直向下执行
总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间
nt main() {
//请给电影评分
//10 ~ 9 经典
// 8 ~ 7 非常好
// 6 ~ 5 一般
// 5分以下 烂片
int score = 0;
cout << "请给电影打分" << endl;
cin >> score;
switch (score)
{
case 10:
case 9:
cout << "经典" << endl;
break;
case 8:
cout << "非常好" << endl;
break;
case 7:
case 6:
cout << "一般" << endl;
break;
default:
cout << "烂片" << endl;
break;
}
system("pause");
return 0;
}二、循环结构：
1、while循环语句
作用：满足循环条件，执行循环语句
语法：while(循环条件){ 循环语句 }
解释：==只要循环条件的结果为真，就执行循环语句==
int main() {
int num = 0;
while (num < 10)
{
cout << "num = " << num << endl;
num++;
}
system("pause");
return 0;
}2、do...while循环语句
作用： 满足循环条件，执行循环语句
语法： do{ 循环语句 } while(循环条件);
注意：与while的区别在于，do...while会先执行一次do内的语句，然后再去判断循环体条件是否满足，然后再次决定是否进入循环体，do语句只会被执行一次。
int main() {
int num = 0;
do
{
cout << num << endl;
num++;
} while (num < 10);
system("pause");
return 0;
}3、for循环语句
作用： 满足循环条件，执行循环语句
语法：for(起始表达式;条件表达式;末尾循环体) { 循环语句; }
注意：for循环中的表达式，要用分号进行分隔
int main() {
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
system("pause");
return 0;
}
三、数组：
所谓数组，就是一个集合，里面存放了相同类型的数据元素
特点1：数组中的每个数据元素都是相同的数据类型
特点2：数组是由连续的内存位置组成的
1、一维数组：
一维数组定义的三种方式：
-
数据类型 数组名[ 数组长度 ]; -
数据类型 数组名[ 数组长度 ] = { 值1，值2 ...}; -
数据类型 数组名[ ] = { 值1，值2 ...};
int main() {
//定义方式1
//数据类型 数组名[元素个数];
int score[10];
//利用下标赋值
score[0] = 100;
score[1] = 99;
score[2] = 85;
//利用下标输出
cout << score[0] << endl;
cout << score[1] << endl;
cout << score[2] << endl;
//第二种定义方式
//数据类型 数组名[元素个数] = {值1，值2 ，值3 ...};
//如果{}内不足10个数据，剩余数据用0补全
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
//逐个输出
//cout << score2[0] << endl;
//cout << score2[1] << endl;
//一个一个输出太麻烦，因此可以利用循环进行输出
for (int i = 0; i < 10; i++)
{
cout << score2[i] << endl;
}
//定义方式3
//数据类型 数组名[] = {值1，值2 ，值3 ...};
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 10; i++)
{
cout << score3[i] << endl;
}
system("pause");
return 0;
}一维数组名称的用途：
-
可以统计整个数组在内存中的长度
-
可以获取数组在内存中的首地址
-
数组名是常量，不可以赋值
-
直接打印数组名，可以查看数组所占内存的首地址
-
对数组名进行sizeof，可以获取整个数组占内存空间的大小
int main() {
//数组名用途
//1、可以获取整个数组占用内存空间大小
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;
//2、可以通过数组名获取到数组首地址
cout << "数组首地址为： " << (int)arr << endl; //也就是arr[0]的地址
cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;
//arr = 100; 错误，数组名是常量，因此不可以赋值
system("pause");
return 0;
}2、冒泡排序：
作用： 最常用的排序算法，对数组内元素进行排序
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
-
重复以上的步骤，每次比较次数-1，直到不需要比较
int main() {
int arr[9] = { 4,2,8,0,5,7,1,3,9 };
int len = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//打印数据
for (int i = 0; i < 9; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}2、 二维数组：
二维数组定义的四种方式：
-
数据类型 数组名[ 行数 ][ 列数 ]; -
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } }; -
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4}; -
数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
定义二维数组时，如果初始化了数据，可以省略行数，无论哪种定义方式都必须写清列
int main() {
//方式1
//数组类型 数组名 [行数][列数]
int arr[2][3];
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 5;
arr[1][2] = 6;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}
//方式2
//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
//方式3
//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4 };
int arr3[2][3] = { 1,2,3,4,5,6 };
//方式4
//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4 };
int arr4[][3] = { 1,2,3,4,5,6 };
system("pause");
return 0;
}二维数组数组名
-
查看二维数组所占内存空间
-
获取二维数组首地址
int main() {
//二维数组数组名
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "二维数组大小： " << sizeof(arr) << endl;
cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
//地址
cout << "二维数组首地址：" << arr << endl;
cout << "二维数组第一行地址：" << arr[0] << endl;
cout << "二维数组第二行地址：" << arr[1] << endl;
cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
system("pause");
return 0;
}四、函数：
1、函数的定义：
1、返回值类型：一个函数可以返回一个值。在函数定义中
2、函数名：给函数起个名称
3、参数表列：使用该函数时，传入的数据
4、函数体语句：花括号内的代码，函数内需要执行的语句
5、return 表达式： 和返回值类型挂钩，函数执行完后，返回相应的数据
语法：
返回值类型 函数名 （参数列表）
{
函数体语句
return表达式
}
//函数定义
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}2、 函数的调用
功能：使用定义好的函数
语法：函数名（参数）
示例：
//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
int sum = num1 + num2;
return sum;
}
int main() {
int a = 10;
int b = 10;
//调用add函数
int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
cout << "sum = " << sum << endl;
system("pause");
return 0;
}3、值传递与地址传递：
1、值传递：
-
所谓值传递，就是函数调用时实参将数值传入给形参
-
值传递时，如果形参发生，并不会影响实参
2、地址传递：
-
所谓地址传递，就是函数调用时实参将实参地址传入给形参
-
地址传递时，如果形参发生，实参也跟着变化
#include<iostream>
using namespace std;
#pragma warning(disable:4996)
void swap(int num1, int num2)
{
num1 = 20;
num2 = 10;
}
void swap_address(int &num1, int &num2) {
num1 = 20;
num2 = 10;
}
int main() {
int a = 10;
int b = 20;
swap(a, b);
cout << "mian中的 a = " << a << endl; //10
cout << "mian中的 b = " << b << endl; //20
swap_address(a, b);
cout << "mian中的 a = " << a << endl; //20
cout << "mian中的 b = " << b << endl; //10
system("pause");
return 0;
}
4、函数的常见样式
1、无参无返 2、有参无返
3、无参有返 3、有参有返
//函数常见样式
//1、 无参无返
void test01()
{
//void a = 10; //无类型不可以创建变量,原因无法分配内存
cout << "this is test01" << endl;
//test01(); 函数调用
}
//2、 有参无返
void test02(int a)
{
cout << "this is test02" << endl;
cout << "a = " << a << endl;
}
//3、无参有返
int test03()
{
cout << "this is test03 " << endl;
return 10;
}
//4、有参有返
int test04(int a, int b)
{
cout << "this is test04 " << endl;
int sum = a + b;
return sum;
}5、函数的声明
作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
-
函数的声明可以多次，但是函数的定义只能有一次
示例：
//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
return a > b ? a : b;
}
int main() {
int a = 100;
int b = 200;
cout << max(a, b) << endl;
system("pause");
return 0;
}6、分文件书写函数：
作用：让代码结构更加清晰，编写一般有4个步骤：
-
创建后缀名为.h的头文件
-
创建后缀名为.cpp的源文件
-
在头文件中写函数的声明
-
在源文件中写函数的定义
三个文件，第一个 .h 文件用于声明函数。第二个 .cpp 文件用于定义函数体。 第三个main函数文件用于使用。
示例：
//swap.h文件
#include<iostream>
using namespace std;
//实现两个数字交换的函数声明
void swap(int a, int b);//swap.cpp文件
#include "swap.h"
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}//main函数文件
#include "swap.h"
int main() {
int a = 100;
int b = 200;
swap(a, b);
system("pause");
return 0;
}