【黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难】基础部分
目录
在C++基础知识部分中，大多都与C相同，只有少部分发生了变化，如
头文件：#include <stdio.h>——>#include<iostream>
头文件下加入了，using namespace std;
输入，输出函数：printf——>cout scanf——>cin
C++中加入了string（字符串类型）
C++初识
第一个C++程序
#include<iostream>
using namespace std;
int main()
{
cout << "hello world" << endl;
system("pause");
return 0;
}注释
方便自己或其他程序员程序员阅读代码
// 单行注释
/*
多行注释
*/变量
给一段指定的内存空间起名，方便操作这段内存
语法： 数据类型 变量名 = 初始值;
int a = 10;
cout<<"a = "<<a<<endl;常量
用于记录程序中不可更改的数据
C++定义常量两种方式：
1，#define 宏常量
#define 常量名 常量值通常在文件上方定义，表示一个常量
2，const 修饰变量
const 数据类型 常量名 = 常量值;通常在变量定义前加关键字const，修饰该变量为常量，不可修改
#include<iostream>
using namespace std;
#define day 7
int main()
{
cout << "一周共有：" << day << "天" << endl;
//day = 8; //报错，常量不可修改
const int month = 12;
cout << "一年共有：" << month << "月" << endl;
//month = 24; //报错，常量不可修改
system("pause");
return 0;
}
关键字
关键字是C++中预先保留的单词（标识符）
在定义变量或者常量时候，不要用关键字
标识符命名规则
C++规定给标识符（变量、常量）命名时，有一套自己的规则
- 标识符不能是关键字
- 标识符只能由字母、数字、下划线组成
- 第一个字符必须为字母或下划线
- 标识符中字母区分大小写
- 给标识符命名时，争取做到见名知意的效果，方便自己和他人的阅读
数据类型
C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存
整型
整型变量表示的是整数类型的数据
C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同
| 数据类型 | 占用空间 | 取值范围 |
| short(短整型) | 2字节 | (-2^15 ~ 2^15-1) |
| int(整型) | 4字节 | (-2^31 ~ 2^31-1) |
| long(长整形) | Windows为4字节， Linux为4字节(32位)，8字节(64位) | (-2^31 ~ 2^31-1) |
| long long(长长整形) | 8字节 | (-2^63 ~ 2^63-1) |
sizeof关键字
利用sizeof关键字可以统计数据类型所占内存大小
语法：sizeof( 数据类型 / 变量)
#include<iostream>
using namespace std;
int main()
{
cout << "short类型所占内存空间为：" << sizeof(short) << endl;
cout << "int 类型所占内存空间为： " << sizeof(int) << endl;
cout << "long 类型所占内存空间为： " << sizeof(long) << endl;
cout << "long long 类型所占内存空间为： " << sizeof(long long) << endl;
system("pause");
return 0;
}整型：short < int <= long <= long long
实型（浮点型）
用于表示小数
浮点型变量分为两种，两者的区别在于表示的有效数字范围不同。
| 数据类型 | 占用空间 | 有效数字范围 |
| float | 4字节 | 7位有效数字 |
| double | 8字节 | 15～16位有效数字 |
#include<iostream>
using namespace std;
int main()
{
float f1 = 3.14f;
double d1 = 3.14;
cout << f1 << endl;
cout << d1 << endl;
cout << "sizeof(float) = " << sizeof(float) << endl;
cout << "sizeof(double) = " << sizeof(double) << endl;
//科学计数法
float f2 = 3e2; //3*10^2
cout << "f2 = " << f2 << endl;
float f3 = 3e-2; //3*10^-2
cout << "f3 = " << f3 << endl;
system("pause");
return 0;
}字符型
字符型变量用于显示单个字符
语法： char 字符名 = '字符'
char ch = 'a';注意：用单引号将字符括起来，单引号内只能有一个字符，不可以是字符串
C和C++中字符型变量只占用1个字节
字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元
#include<iostream>
using namespace std;
int main()
{
char ch = 'a';
cout << ch << endl;
cout << sizeof(char) << endl;
//ch = "abcde"; 错误，不可以用双引号,单引号内只能引用一个字符
cout << (int)ch << endl; //查看字符a对应的ASCII码
ch = 97; //可以直接用ASCII给字符变量赋值
cout << ch << endl;
system("pause");
return 0;
}ASCII码：
ASCII 码大致由以下两部分组成：
ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII 打印字符：数字 32-126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。
转义字符
用于表示一些不能显示出来的ASCII字符
现阶段我们常用的转义字符有：\n \\ \t
#include<iostream>
using namespace std;
int main()
{
cout << "\\" << endl;
cout << "\thello" << endl;
cout << "\n" << endl;
system("pause");
return 0;
}字符串型
用于表示一串字符
两种风格：
1，C风格字符串：char 变量名[] = "字符串"
char str1[] = "hello world";2,C++风格字符串：string 变量名 = "字符串"
C++风格字符串，需要加入头文件#include <string>
#include <string>
string str2 = "hello world"; 布尔类型bool
布尔数据类型代表真或假的值
bool类型只有两个值：
true --- 真（本质是1）
false --- 假（本质是0）
bool类型占1个字节大小
#include<iostream>
using namespace std;
int main()
{
bool flag = true;
cout << flag << endl; // 1
flag = false;
cout << flag << endl; //0
cout << "sizeof(bool) = " << sizeof(bool) << endl; // 1
system("pause");
return 0;
}数据的输入
用于从键盘获取数据
关键字：cin
语法：cin>>变量
#include<iostream>
using namespace std;
int main()
{
int a = 0;
cout << "请输入变量：" << endl;
cin >> a;
cout << a << endl;
system("pause");
return 0;
}
运算符
用于执行代码的运算
| 运算符类型 | 作用 |
| 算术运算符 | 用于处理四则运算 |
| 赋值运算符 | 用于将表达式的值赋给变量 |
| 比较运算符 | 用于表达式的比较，并返回一个真值或假值 |
| 逻辑运算符 | 用于根据表达式的值返回真值或假值 |
算术运算符
用于处理四则运算
| 运算符 | 术语 | 示例 | 结果 |
| + | 正号 | +3 | 3 |
| - | 正号 | -3 | -3 |
| + | 加 | 10 + 5 | 15 |
| - | 减 | 10 - 5 | 5 |
| * | 乘 | 10 * 5 | 50 |
| / | 除 | 10 / 5 | 2 |
| % | 取模(取余) | 10 % 3 | 1 |
| ++ | 前置递增 | a=2; b=++a; | a=3; b=3; |
| ++ | 后置递增 | a=2; b=a++; | a=3; b=2; |
| -- | 前置递减 | a=2; b=--a; | a=1; b=1; |
| -- | 后置递减 | a=2; b=a--; | a=1; b=2; |
两个整数相除结果依然是整数
在除法运算中，除数不可以为0；取模运算时，除数也不能为0
只有整型变量可以进行取模运算
前置递增先对变量进行++，再计算表达式，后置递增相反—— (--相同)
赋值运算符
用于将表达式的值赋给变量
| 运算符 | 术语 | 示例 | 结果 |
| = | 赋值 | a=2; b=3; | a=2; b=3; |
| += | 加等于 | a=0; a+=2; | a=2; |
| -= | 减等于 | a=5; a-=3; | a=2; |
| *= | 乘等于 | a=2; a*=2; | a=4; |
| /= | 除等于 | a=4; a/=2; | a=2; |
| %= | 模等于 | a=3; a%2; | a=1; |
比较运算符
用于表达式的比较，并返回一个真值或假值
| 运算符 | 术语 | 示例 | 结果 |
| == | 相等于 | 4 == 3 | 0 |
| != | 不等于 | 4 != 3 | 1 |
| < | 小于 | 4 < 3 | 0 |
| > | 大于 | 4 > 3 | 1 |
| <= | 小于等于 | 4 <= 3 | 0 |
| >= | 大于等于 | 4 >= 1 | 1 |
C和C++ 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。
逻辑运算符
用于根据表达式的值返回真值或假值
| 运算符 | 术语 | 示例 | 结果 |
| ! | 非 | !a | 如果a为假，则!a为真； 如果a为真，则!a为假。 真变假，假变真 |
| && | 与 | a && b | 如果a和b都为真，则结果为真，否则为假。 同真为真，其余为假 |
| || | 或 | a || b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。 同假为假，其余为真 |
程序流程结构
C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构
- 顺序结构：程序按顺序执行，不发生跳转
- 选择结构：依据条件是否满足，有选择的执行相应功能
- 循环结构：依据条件是否满足，循环多次执行某段代码
-
选择结构
-
if语句
- 执行满足条件的语句
-
if语句的三种形式：
1，单行格式if语句：
-
if(条件) { 条件满足执行的语句 }2，多行格式if语句
if(条件) { 条件满足执行的语句 } else { 条件不满足执行的语句 }3，多条件的if语句
-
if(条件1) { 条件1满足执行的语句 } else if(条件2) { 条件2满足执行的语句 } ... else { 都不满足执行的语句 }4，嵌套if语句：在if语句中，可以嵌套使用if语句，达到更精确的条件判断
-
案例需求：
-
提示用户输入一个高考考试分数，根据分数做如下判断；分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。
-
#include<iostream> using namespace std; int main() { int socre = 0; cout << "请输入高考分数：" << endl; cin >> socre; if (socre > 600) { cout << "考上一本" << endl; if (socre > 700) { cout << "考入北大" << endl; } else if (socre > 650) { cout << "考入清华" << endl; } else { cout << "考入人大" << endl; } } else if (socre > 500) { cout << "考上二本" << endl; } else if(socre > 400) { cout << "考上三本" << endl; } else { cout << "未考上本科" << endl; } system("pause"); return 0; }练习案例：三只小猪称体重
有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重
-
#include<iostream> using namespace std; int main() { int a = 0; int b = 0; int c = 0; cout << "输入a的体重：" << endl; cin >> a; cout << "输入b的体重：" << endl; cin >> b; cout << "输入c的体重：" << endl; cin >> c; cout << "小猪A的体重为：" << a << endl; cout << "小猪B的体重为：" << b << endl; cout << "小猪C的体重为：" << c << endl; if (a > b) { if (a > c) { cout << "A最重" << endl; } else { cout << "C最重" << endl; } } else { if (b > c) { cout << "B最重" << endl; } else { cout << "C最重" << endl; } } system("pause"); return 0; }三目运算符
-
通过三目运算符实现简单的判断
-
表达式1 ？ 表达式2 : 表达式3如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
如果表达式1的值为假，执行表达式3，并返回表达式3的结果。
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 20;
int c = 0;
c = a > b ? a : b;
cout << "c = " << c << endl;
//C++中三目运算符返回的是变量,可以继续赋值
(a > b ? a : b) = 100;
//a小于b，执行表达式2，返回b，将b=100
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
system("pause");
return 0;
}
和if语句比较，三目运算符优点是短小整洁，缺点是如果用嵌套，结构不清晰
switch语句
执行多条件分支语句
switch(表达式)
{
case 结果1 : 执行语句;break;
case 结果2 : 执行语句;break;
...
default:执行语句;breal;
}#include<iostream>
using namespace std;
int 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：switch语句中表达式类型只能是整型或者字符型
注意2：case里如果没有break，那么程序会一直向下执行
总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间
循环结构
while循环语句
满足循环条件，执行循环语句
while(循环条件)
{
循环语句
}循环条件的结果为真，执行循环语句
#include<iostream>
using namespace std;
int main()
{
int num = 0;
while (num < 10)
{
cout << "num = " << num << endl;
num++;
}
system("pause");
return 0;
}注意：在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环
练习案例：猜数字
系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。
#include<iostream>
using namespace std;
#include <ctime>
int main()
{
srand((unsigned int)time(NULL));
int num = rand() % 100 + 1;
int val = 0;
while (1)
{
cin >> val;
if (val > num)
{
cout << "大了" << endl;
}
else if(val < num)
{
cout << "小了" << endl;
}
else
{
cout << "猜对了" << endl;
break;
}
}
system("pause");
return 0;
}
do...while 循环语句
满足循环条件，执行循环语句
do
{
循环语句
}while(循环条件);注意:与while的区别在于do...while会先执行一次循环语句，再判断循环条件
#include<iostream>
using namespace std;
int main()
{
int num = 0;
do
{
cout << num << endl;
num++;
} while (num < 10);
system("pause");
return 0;
}练习案例：水仙花数
水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身
例如：1^3 + 5^3+ 3^3 = 153
请利用do...while语句，求出所有3位数中的水仙花数
#include<iostream>
using namespace std;
//水仙花数
int main()
{
int num = 100;
do
{
int ge = num % 10;
int shi = num / 10 % 10;
int bai = num / 100;
if (num == ge * ge * ge + shi * shi * shi + bai * bai * bai)
{
cout << num << endl;
}
num++;
} while (num < 1000);
system("pause");
return 0;
}
for循环语句
满足循环条件，执行循环语句
for(起始表达式;条件表达式;末尾循环体)
{
循环语句
}#include<iostream>
using namespace std;
int main()
{
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
system("pause");
return 0;
}练习案例：敲桌子
从1开始数到数字100， 如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。
#include<iostream>
using namespace std;
int main()
{
for (int i = 1; i <= 100; i++)
{
if (i % 10 == 7 || i / 10 == 7 || i % 7 == 0)
{
cout << "敲桌子" << endl;
}
else
{
cout << i << endl;
}
}
system("pause");
return 0;
}
嵌套循环
在循环体中再嵌套一层循环，解决一些实际问题
#include<iostream>
using namespace std;
//10X10的图形
int main()
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
cout << "*" << " ";
}
cout << endl;
}
system("pause");
return 0;
}练习案例：乘法口诀表
利用嵌套循环，实现九九乘法表
#include<iostream>
using namespace std;
int main()
{
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout << i << "*" << j << "=" << i * j << "\t";
}
cout << endl;
}
system("pause");
return 0;
}跳转语句
break语句
用于跳出选择结构或者循环结构
break使用的时机：
- 出现在switch条件语句中，作用是终止case并跳出switch
-
#include<iostream> using namespace std; int main() { //1、在switch 语句中使用break cout << "请选择您挑战副本的难度：" << endl; cout << "1、普通" << endl; cout << "2、中等" << endl; cout << "3、困难" << endl; int num = 0; cin >> num; switch (num) { case 1: cout << "您选择的是普通难度" << endl; break; case 2: cout << "您选择的是中等难度" << endl; break; case 3: cout << "您选择的是困难难度" << endl; break; } system("pause"); return 0; } - 出现在循环语句中，作用是跳出当前的循环语句
-
#include<iostream> using namespace std; int main() { //2、在循环语句中用break for (int i = 0; i < 10; i++) { if (i == 5) { break; //跳出循环语句 } cout << i << endl; } system("pause"); return 0; } - 出现在嵌套循环中，跳出最近的内层循环语句
-
#include<iostream> using namespace std; int main() { //在嵌套循环语句中使用break，退出内层循环 for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { if (j == 5) { break; } cout << "*" << " "; } cout << endl; } system("pause"); return 0; }continue语句
-
在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
-
#include<iostream> using namespace std; int main() { for (int i = 0; i < 100; i++) { if (i % 2 == 0) { continue; } cout << i << endl; } system("pause"); return 0; }注意：continue并没有使整个循环终止，而break会跳出循环
goto语句
可以无条件跳转语句
goto 标记;
如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
#include<iostream>
using namespace std;
int main()
{
cout << "1" << endl;
goto FLAG;
cout << "2" << endl;
cout << "3" << endl;
cout << "4" << endl;
FLAG:
cout << "5" << endl;
system("pause");
return 0;
}
注意：在程序中不建议使用goto语句，以免造成程序流程混乱
数组
所谓数组，就是一个集合，里面存放了相同类型的数据元素
特点1：数组中的每个数据元素都是相同的数据类型
特点2：数组是由连续的内存位置组成的
一维数组
一维数组定义方式
数据类型 数组名[ 数组长度 ];
数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};
数据类型 数组名[ ] = { 值1，值2 ...};
#include<iostream>
using namespace std;
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 };
//一个一个输出太麻烦，因此可以利用循环进行输出
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;
}
总结1：数组名的命名规范与变量名命名规范一致，不要和变量重名
总结2：数组中下标是从0开始索引
一维数组数组名
- 可以统计整个数组在内存中的长度
-
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; - 可以获取数组在内存中的首地址
-
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; cout << "数组首地址为： " << (int)arr << endl; cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl; cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;注意：数组名是常量，不可以赋值
-
总结1：直接打印数组名，可以查看数组所占内存的首地址
总结2：对数组名进行sizeof，可以获取整个数组占内存空间的大小
-
练习案例1:五只小猪称体重
在一个数组中记录了五只小猪的体重，如：int arr[5] = {300,350,200,400,250};
找出并打印最重的小猪体重。
#include<iostream> using namespace std; int main() { int arr[5] = { 300,350,200,400,250 }; int max = 0; for (int i = 0; i < 5; i++) { if (arr[i] > max) { max = arr[i]; } } cout << max << endl; system("pause"); return 0; }练习案例2：数组元素逆置
请声明一个5个元素的数组，并且将元素逆置.
(如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);
-
#include<iostream> using namespace std; int main() { int arr[5] = { 1,3,2,5,4 }; int start = 0; int end = sizeof(arr) / sizeof(arr[0]) - 1; while (start < end) { int tmp = arr[start]; arr[start] = arr[end]; arr[end] = tmp; start++; end--; } for (int i = 0; i < 5; i++) { cout << arr[i]; } return 0; } -
冒泡排序
最常用的排序算法，对数组内元素进行排序
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3. 重复以上的步骤，每次比较次数-1，直到不需要比较
示例：将数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序
#include<iostream>
using namespace std;
int main()
{
int arr[] = { 4,2,8,0,5,7,1,3,9 };
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz - 1; i++)
{
for (int j = 0; j < sz - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
for (int i = 0; i < sz; i++)
{
cout << arr[i] << endl;
}
return 0;
}
二维数组
二维数组定义方式
数据类型 数组名[ 行数 ][ 列数 ];
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
第二种更加直观，提高代码的可读性
在定义二维数组时，如果初始化了数据，可以省略行数
二维数组数组名
查看二维数组所占内存空间
获取二维数组首地址
二维数组应用案例
考试成绩统计：
三名同学（张三，李四，王五），在一次考试中的成绩分别如下表，请分别输出三名同学的总成绩
| 语文 | 数学 | 英语 | |
| 张三 | 100 | 100 | 100 |
| 李四 | 90 | 50 | 100 |
| 王五 | 60 | 70 | 80 |
#include<iostream>
using namespace std;
#include <string>
int main()
{
int scores[3][3] = { {100,100,100},{90,50,100},{60,70,80} };
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;
}
system("pause");
return 0;
}函数
概述
将一段经常使用的代码封装起来，减少重复代码
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。
函数的定义
返回值类型 函数名(参数列表)
{
函数体语句
return 表达式
}返回值类型 ：一个函数可以返回一个值。在函数定义中
函数名：给函数起个名称
参数列表：使用该函数时，传入的数据
函数体语句：花括号内的代码，函数内需要执行的语句
return表达式： 和返回值类型挂钩，函数执行完后，返回相应的数据
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}
函数的调用
使用定义好的函数
函数名 （参数）int main()
{
int a=10;
int b=10;
int sum=add(a,b);
}函数定义里小括号内称为形参，函数调用时传入的参数称为实参
值传递
函数调用时实参将数值传入给形参
值传递时，如果形参发生，并不会影响实参
#include<iostream>
using namespace std;
void swap(int num1, int num2)
{
cout << "交换前：" << endl;
cout << "num1 = " << num1 << endl;
cout << "num2 = " << num2 << endl;
int temp = num1;
num1 = num2;
num2 = temp;
cout << "交换后：" << endl;
cout << "num1 = " << num1 << endl;
cout << "num2 = " << num2 << endl;
//return ; 当函数声明时候，不需要返回值，可以不写return
}
int main() {
int a = 10;
int b = 20;
swap(a, b);
cout << "mian中的 a = " << a << endl;
cout << "mian中的 b = " << b << endl;
system("pause");
return 0;
}
总结： 值传递时，形参是修饰不了实参的
函数的常见样式
- 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; }函数的声明
- 告诉编译器函数名称及如何调用函数,函数的实际主体可以单独定义。
- 函数的声明可以多次，但是函数的定义只能有一次
-
#include<iostream> using namespace std; //声明 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; }函数的份文件编写
让代码结构更加清晰
- 1. 创建后缀名为.h的头文件
- 2. 创建后缀名为.cpp的源文件
- 3. 在头文件中写函数的声明
- 4. 在源文件中写函数的定义
指针
结构体
扫一扫
189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
