熬夜爆肝!C++基础入门大合集【万字干货预警 建议收藏】
前言
前几天有粉丝问我,大一结束c++刚学完,不知道自己目前学得怎么样?要掌握的知识点有没有都弄懂了?是否基础入门了?
这就安排上,熬夜爆肝整理出来的C++基础入门知识!
一篇文带你入门C++!一篇文带你疏通C++基础入门知识点!
目录
- 前言
- 1 c++入门初识
- 1.1 hello world
- 1.2 注释
- 1.3 变量
- 1.4 常量
- 1.5 关键字
- 1.6 命名规则
- 2 数据类型
- 2.1 整型
- 2.2 浮点型
- 2.3 字符型
- 2.4 字符串
- 2.5 布尔类型
- 2.6 转义字符
- 3 运算符
- 3.1 算数运算符
- 3.2 关系运算符
- 3.3 逻辑运算符
- 3.4 位运算符
- 3.5 赋值运算符
- 4 程序流程结构
- 4.1 判断类型
- 4.2 循环类型
- 4.3 循环控制语句
- 5 数组
- 5.1 数组定义创建
- 5.2 数组指针
- 6 函数
- 6.1 函数的定义
- 6.2 函数的调用
- 6.3 函数的声明
- 6.4 函数的参数
- 7 指针
- 7.1 指针变量的定义使用
- 7.2 空指针和野指针
- 7.3 const修饰指针
- 7.4 指针、数组
- 7.5 指针、函数
- 7.6 指针、数组、函数
1 c++入门初识
C++ 是一种静态类型、编译式、通用、大小写敏感、不规则的编程语言,支持过程化编程、面向对象编程和泛型编程。
1.1 hello world
我们从最简单的hello world开始。下面就是一个最简单的C++程序。
// C++ 语言定义了很多头文件,包含程序中必需的或有用的内容 iostream就是
#include <iostream>
// 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个新概念
using namespace std;// main() 是主函数,程序从这里开始执行
int main()
{cout << "Hello World"; // 输出 Hello Worldreturn 0; // 终止 main( )函数,并向调用进程返回0
}
1.2 注释
可以在代码片段中添加一些说明和解释,方便自己或别人阅读理解写的代码。
编译器在编译代码时,会忽略注释的内容。
注释方式:
- 单行注释 : // 注释内容
通常放在一行代码上方或者末尾 - 多行注释: /* 注释内容 */
通常放在一段代码的上方,对该段代码做整体说明
1.3 变量
可以对某段内存空间起名字,方便操作该内存空间。
数据类型 变量名 = 初始值;
#include<iostream>
using namespace std;int main() {// 定义变量//数据类型 变量名 = 初始值int a = 12;cout << "a = " << a << endl;system("pause");return 0;
}
1.4 常量
可以用来存储,无法修改的数据。
常量定义方式:
- #define 宏常量:
#define 常量名 常量值
- const修饰的变量:
const 数据类型 常量名 = 常量值
//1、宏常量
#define day 7int main() {cout << "一周有 " << day << " 天" << endl;//day = 8; //error,宏常量不可修改//2、const修饰变量const int month = 12;cout << "一年有 " << month << " 个月份" << endl;//month = 24; //error,常量不可修改的system("pause");return 0;
}
1.5 关键字
关键字是C++中预先保留的单词,又称为标识符。 这些关键词都是有特殊含义的,所以后面我们定义变量或者常量名称时,不能用这些关键字。
C++关键字:
asm | do | if | return | typedef |
---|---|---|---|---|
auto | double | inline | short | typeid |
bool | dynamic_cast | int | signed | typename |
break | else | long | sizeof | union |
case | enum | mutable | static | unsigned |
catch | explicit | namespace | static_cast | using |
char | export | new | struct | virtual |
class | extern | operator | switch | void |
const | false | private | template | volatile |
const_cast | float | protected | this | wchar_t |
continue | for | public | throw | while |
default | friend | register | true | |
delete | goto | reinterpret_cast | try |
1.6 命名规则
C++中给变量、常量命名时,为了阅读理解,起名字的时候最好做到见名知义。当然命名也有自己的规则:
- 标识符不能是关键字
- 标识符只能由字母、数字、下划线组成
- 第一个字符必须为字母或下划线
- 标识符中字母区分大小写
2 数据类型
C++规定在创建变量或者常量时,必须要指定出对应的数据类型,否则无法给变量分配内存。
2.1 整型
整型变量表示的是整数数据,c++对于整数类型总共有4种,主要的差异是占内存空间不同。
数据类型 | 占用空间 | 取值范围 |
---|---|---|
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) |
2.2 浮点型
浮点型都是用来表示小数,分为2种。
单精度float和双精度double,他们的区别在于表示的有效数字范围不同。
数据类型 | 占用空间 | 有效数字范围 |
---|---|---|
float | 4字节 | 7位有效数字 |
double | 8字节 | 15~16位有效数字 |
int main() {float f1 = 3.14f;double d1 = 3.14;cout << f1 << endl;cout << d1<< endl;cout << "float sizeof = " << sizeof(f1) << endl;cout << "double sizeof = " << sizeof(d1) << endl;//科学计数法float f2 = 3e2; // 3 * 10 ^ 2 cout << "f2 = " << f2 << endl;float f3 = 3e-2; // 3 * 0.1 ^ 2cout << "f3 = " << f3 << endl;system("pause");return 0;
}
2.3 字符型
字符型变量用于显示单个字符。例如 a, b, c这些英文字母。
1. 在显示字符型变量时,用单引号将字符括起来,不要用双引号。
2. 单引号内只能有一个字符,不能是字符串。
3. 字符型变量只占用1个字节
int main() {char ch = 'a';cout << ch << endl;cout << sizeof(char) << endl;//ch = "abcde"; //错误,不可以用双引号//ch = 'abcde'; //错误,单引号内只能引用一个字符cout << (int)ch << endl; //查看字符a对应的ASCII码ch = 97; //可以直接用ASCII给字符型变量赋值cout << ch << endl;system("pause");return 0;
}
2.4 字符串
上面介绍了字符,而字符串就是用来表示一串字符的。
C++中字符串定义有2中方式:
- string 变量名 = "字符串值
- char 变量名[] = "字符串值"
int main() {string str = "hello world";cout << str << endl;char str1[] = "hello world";cout << str1 << endl;system("pause");return 0;
2.5 布尔类型
布尔类型用来判断数据值的真或假。bool类型占1个字节内存空间。
bool类型只有两个值:
- true — 真 (本质是1)
- false — 假(本质是0)
int main() {bool flag = true;cout << flag << endl; // 1flag = false;cout << flag << endl; // 0cout << "size of bool = " << sizeof(bool) << endl; //1 system("pause");return 0;
}
2.6 转义字符
用于表示不能显示出来的ASCII字符。
转义字符 | 含义 | ASCII码值(十进制) |
---|---|---|
\a | 警报 | 007 |
\b | 退格(BS) ,将当前位置移到前一列 | 008 |
\f | 换页(FF),将当前位置移到下页开头 | 012 |
\n | 换行(LF) ,将当前位置移到下一行开头 | 010 |
\r | 回车(CR) ,将当前位置移到本行开头 | 013 |
\t | 水平制表(HT) (跳到下一个TAB位置) | 009 |
\v | 垂直制表(VT) | 011 |
\\ | 代表一个反斜线字符"" | 092 |
’ | 代表一个单引号(撇号)字符 | 039 |
" | 代表一个双引号字符 | 034 |
? | 代表一个问号 | 063 |
\0 | 数字0 | 000 |
\ddd | 8进制转义字符,d范围0~7 | 3位8进制 |
\xhh | 16进制转义字符,h范围09,af,A~F | 3位16进制 |
3 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号,执行代码的运算。
C++ 内置了丰富的运算符,提供了以下类型的运算符:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
3.1 算数运算符
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
+ | 加 | 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; |
int main() {int a1 = 10;int b1 = 3;cout << a1 + b1 << endl;cout << a1 - b1 << endl;cout << a1 * b1 << endl;cout << a1 / b1 << endl; //两个整数相除结果依然是整数int a2 = 10;int b2 = 20;cout << a2 / b2 << endl; int a3 = 10;int b3 = 0;//cout << a3 / b3 << endl; //报错,除数不可以为0//两个小数可以相除double d1 = 0.5;double d2 = 0.25;cout << d1 / d2 << endl;int a3 = 10;int b3 = 0;//cout << a3 % b3 << endl; //取模运算时,除数也不能为0//两个小数不可以取模double d1 = 3.14;double d2 = 1.1;//cout << d1 % d2 << endl;//后置递增int a = 10;a++; //等价于a = a + 1cout << a << endl; // 11//前置递增int b = 10;++b;cout << b << endl; // 11//区别//前置递增先对变量进行++,再计算表达式int a2 = 10;int b2 = ++a2 * 10;cout << b2 << endl;//后置递增先计算表达式,后对变量进行++int a3 = 10;int b3 = a3++ * 10;cout << b3 << endl;system("pause");return 0;
}
3.2 关系运算符
进行表达式比较,并返回一个布尔类型的返回值–真(1)或假(0)。
比较运算符有以下符号:
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
== | 相等于 | 4 == 3 | 0 |
!= | 不等于 | 4 != 3 | 1 |
< | 小于 | 4 < 3 | 0 |
> | 大于 | 4 > 3 | 1 |
<= | 小于等于 | 4 <= 3 | 0 |
>= | 大于等于 | 4 >= 1 | 1 |
#include <iostream>
using namespace std;int main()
{int a = 21;int b = 10;int c ;if( a == b ){cout << "Line 1 - a 等于 b" << endl ;}else{cout << "Line 1 - a 不等于 b" << endl ;}if ( a < b ){cout << "Line 2 - a 小于 b" << endl ;}else{cout << "Line 2 - a 不小于 b" << endl ;}if ( a > b ){cout << "Line 3 - a 大于 b" << endl ;}else{cout << "Line 3 - a 不大于 b" << endl ;}/* 改变 a 和 b 的值 */a = 5;b = 20;if ( a <= b ){cout << "Line 4 - a 小于或等于 b" << endl ;}if ( b >= a ){cout << "Line 5 - b 大于或等于 a" << endl ;}return 0;
}
输出结果:
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a
3.3 逻辑运算符
根据表达式的值返回真或假。
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
! | 非 | !a | 如果a为假,则!a为真; 如果a为真,则!a为假。 |
&& | 与 | a && b | 如果a和b都为真,则结果为真,否则为假。 |
|| | 或 | a || b | 如果a和b有一个为真,则结果为真,二者都为假时,结果为假。 |
#include <iostream>
using namespace std;int main()
{int a = 5;int b = 20;int c ;if ( a && b ){cout << "Line 1 - 条件为真"<< endl ;}if ( a || b ){cout << "Line 2 - 条件为真"<< endl ;}/* 改变 a 和 b 的值 */a = 0;b = 10;if ( a && b ){cout << "Line 3 - 条件为真"<< endl ;}else{cout << "Line 4 - 条件不为真"<< endl ;}if ( !(a && b) ){cout << "Line 5 - 条件为真"<< endl ;}return 0;
}
输出结果:
Line 1 - 条件为真
Line 2 - 条件为真
Line 4 - 条件不为真
Line 5 - 条件为真
3.4 位运算符
位运算符作用于位,并逐位执行操作。&、 | 和 ^ 的真值表如下所示:
p | q | p & q | p|q | p^q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
假设如果 A = 60,B = 13,二进制格式表示如下所示:
A = 0011 1100
B = 0000 1101
#include <iostream>
using namespace std;int main()
{unsigned int a = 60; // 60 = 0011 1100 unsigned int b = 13; // 13 = 0000 1101int c = 0; c = a & b; // 12 = 0000 1100cout << "Line 1 - c 的值是 " << c << endl ;c = a | b; // 61 = 0011 1101cout << "Line 2 - c 的值是 " << c << endl ;c = a ^ b; // 49 = 0011 0001cout << "Line 3 - c 的值是 " << c << endl ;c = ~a; // -61 = 1100 0011cout << "Line 4 - c 的值是 " << c << endl ;// 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位(左边的二进制位丢弃,右边补0)c = a << 2; // 240 = 1111 0000cout << "Line 5 - c 的值是 " << c << endl ;// 二进制右移运算符。将一个数的各二进制位全部右移若干位,正数左补0,负数左补1,右边丢弃。c = a >> 2; // 15 = 0000 1111cout << "Line 6 - c 的值是 " << c << endl ;return 0;
}
3.5 赋值运算符
赋值运算符将表达式的值赋给变量,包括以下几个符号:
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
= | 赋值 | 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; |
int main() {//赋值运算符// =int a = 10;a = 100;cout << "a = " << a << endl;// +=a = 10;a += 2; // a = a + 2;cout << "a = " << a << endl;// -=a = 10;a -= 2; // a = a - 2cout << "a = " << a << endl;// *=a = 10;a *= 2; // a = a * 2cout << "a = " << a << endl;// /=a = 10;a /= 2; // a = a / 2;cout << "a = " << a << endl;// %=a = 10;a %= 2; // a = a % 2;cout << "a = " << a << endl;system("pause");return 0;
}
4 程序流程结构
C++支持最基本的三种程序运行结构:顺序结构、选择结构、循环结构
- 顺序结构:程序按顺序执行,不发生跳转
- 选择结构:依据条件是否满足,有选择的执行相应功能
- 循环结构:依据条件是否满足,循环多次执行某段代码
4.1 判断类型
判断结构要求指定一个或多个要评估或测试的条件,以及条件为真时要执行的语句(必需的)和条件为假时要执行的语句(可选的)。
语句 | 描述 |
---|---|
if 语句 | 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
if…else 语句 | 一个 if 语句 后可跟一个可选的 else 语句,else 语句在布尔表达式为假时执行。 |
嵌套 if 语句 | 在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。 |
switch 语句 | 一个 switch 语句允许测试一个变量等于多个值时的情况。 |
嵌套 switch 语句 | 可以在一个 switch 语句内使用另一个 switch 语句。 |
1. if else语句:
#include <iostream>
using namespace std;int main ()
{// 局部变量声明int a = 100;int b = 200;// 检查布尔条件if( a == 100 ){// 如果条件为真,则检查下面的条件if( b == 200 ){// 如果条件为真,则输出下面的语句cout << "a 的值是 100,且 b 的值是 200" << endl;}}cout << "a 的准确值是 " << a << endl;cout << "b 的准确值是 " << b << endl;return 0;
}
输出结果:
a 的值是 100,且 b 的值是 200
a 的准确值是 100
b 的准确值是 200
2. switch语句:
#include <iostream>
using namespace std;int main ()
{// 局部变量声明int a = 100;int b = 200;switch(a) {case 100:cout << "这是外部 switch 的一部分" << endl;switch(b) {case 200:cout << "这是内部 switch 的一部分" << endl;}}cout << "a 的准确值是 " << a << endl;cout << "b 的准确值是 " << b << endl;return 0;
}
输出结果:
这是外部 switch 的一部分
这是内部 switch 的一部分
a 的准确值是 100
b 的准确值是 200
3. ? : 运算符
#include <iostream>
using namespace std;int main ()
{// 局部变量声明int x, y = 10;x = (y < 10) ? 30 : 40;cout << "value of x: " << x << endl; return 0;
}
输出结果:
value of x: 40
4.2 循环类型
循环类型 | 描述 |
---|---|
while 循环 | 当给定条件为真时,重复语句或语句组。它会在执行循环主体之前测试条件。 |
for 循环 | 多次执行一个语句序列,简化管理循环变量的代码。 |
do…while 循环 | 除了它是在循环主体结尾测试条件外,其他与 while 语句类似。 |
嵌套循环 | 可以在 while、for 或 do…while 循环内使用一个或多个循环。 |
int main() {int num = 0;while (num < 10){cout << "num = " << num << endl;num++;}system("pause");return 0;
}
int main() {int num = 0;do{cout << num << endl;num++;} while (num < 10);system("pause");return 0;
}
do…while和while循环区别在于,do…while先执行一次循环语句,再判断循环条件。
int main() {for (int i = 0; i < 10; i++){cout << i << endl;}system("pause");return 0;
}
执行过程:
4.3 循环控制语句
控制语句 | 描述 |
---|---|
break 语句 | 终止 loop 或 switch 语句,程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
continue 语句 | 引起循环跳过主体的剩余部分,立即重新开始测试条件。 |
goto 语句 | 将控制转移到被标记的语句,不建议在程序中使用 goto 语句。 |
1. break:
#include <iostream>
using namespace std;int main ()
{// 局部变量声明int a = 10;// do 循环执行do{cout << "a 的值:" << a << endl;a = a + 1;if( a > 15){// 终止循环break;}}while( a < 20 ); return 0;
}
输出结果:
a 的值: 10
a 的值: 11
a 的值: 12
a 的值: 13
a 的值: 14
a 的值: 15
2. continue:
#include <iostream>
using namespace std;int main ()
{// 局部变量声明int a = 10;// do 循环执行do{if( a == 15){// 跳过迭代a = a + 1;continue;}cout << "a 的值:" << a << endl;a = a + 1;}while( a < 20 ); return 0;
}
输出结果:
a 的值: 10
a 的值: 11
a 的值: 12
a 的值: 13
a 的值: 14
a 的值: 16
a 的值: 17
a 的值: 18
a 的值: 19
3. goto:
#include <iostream>
using namespace std;int main ()
{// 局部变量声明int a = 10;// do 循环执行LOOP:do{if( a == 15){// 跳过迭代a = a + 1;goto LOOP;}cout << "a 的值:" << a << endl;a = a + 1;}while( a < 20 ); return 0;
}
输出结果:
a 的值: 10
a 的值: 11
a 的值: 12
a 的值: 13
a 的值: 14
a 的值: 16
a 的值: 17
a 的值: 18
a 的值: 19
5 数组
数组就是一个集合,里面存放了相同类型的数据元素。
- 数组中的每个数据元素都是相同的数据类型
- 由连续的内存位置组成
5.1 数组定义创建
C++ 中可以逐个初始化数组,也可以使用一个初始化语句,如下所示:
// 一维数组
//数据类型 数组名[元素个数];
int score[10];
//利用下标赋值
score[0] = 100;
score[1] = 99;
score[2] = 85;//数据类型 数组名[元素个数] = {值1,值2 ,值3 ...};
//如果{}内不足10个数据,剩余数据用0补全
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };// 二维数组
//数组类型 数组名 [行数][列数]
int arr[2][2];
arr[0][0] = 1;
arr[0][1] = 2;
arr[1][0] = 3;
arr[1][1] = 4;//数据类型 数组名[行数][列数] = { {数据1,数据2 } ,{数据3,数据4 } };
int arr2[2][3] =
{{1,2,3},{4,5,6}
};
5.2 数组指针
数组名实际是指向数组中第一个元素的常量指针
double runoobAarray[50];
其中的runoobAarray 可以看做是一个指向 &runoobAarray[0] 的指针,数组 runoobAarray 的第一个元素的地址。
可以把指针 p 赋值为 runoobAarray 的第一个元素的地址:
double *p;
double runoobAarray[10];
p = runoobAarray;
使用数组名作为常量指针是合法的,反之亦然。
*(runoobAarray + 4) 是一种访问 runoobAarray[4] 数据的合法方式。
当第一个元素的地址存储在 p 中,可以用 p、(p+1)、*(p+2) 来依次访问数组的各个元素。
#include <iostream>
using namespace std;int main ()
{// 带有 5 个元素的双精度浮点型数组double runoobAarray[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};double *p;p = runoobAarray;// 输出数组中每个元素的值cout << "使用指针的数组值 " << endl; for ( int i = 0; i < 5; i++ ){cout << "*(p + " << i << ") : ";cout << *(p + i) << endl;}cout << "使用 runoobAarray 作为地址的数组值 " << endl;for ( int i = 0; i < 5; i++ ){cout << "*(runoobAarray + " << i << ") : ";cout << *(runoobAarray + i) << endl;}return 0;
}
输出结果:
使用指针的数组值
*(p + 0) : 1000
*(p + 1) : 2
*(p + 2) : 3.4
*(p + 3) : 17
*(p + 4) : 50
使用 runoobAarray 作为地址的数组值
*(runoobAarray + 0) : 1000
*(runoobAarray + 1) : 2
*(runoobAarray + 2) : 3.4
*(runoobAarray + 3) : 17
*(runoobAarray + 4) : 50
6 函数
函数是将一段经常使用的代码封装起来,减少重复代码。每个 C++ 程序都至少有一个函数,即主函数 main() ,所有简单的程序都可以定义其他额外的函数。
6.1 函数的定义
函数定义一般主要有5个步骤:
1、返回值类型 – 在函数定义中,一个函数可以返回一个值。
2、函数名 – 给函数起个名称
3、参数表列 – 使用该函数时,传入的数据
4、函数体语句 – 大括号内的代码,函数内需要执行的语句
5、return 表达式 – 和返回值类型挂钩,函数执行完后,返回相应的数据
//函数定义(两数相加)
int add(int num1, int num2)
{int sum = num1 + num2;return sum;
}
6.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;a = 100;b = 100;sum = add(a, b);cout << "sum = " << sum << endl;system("pause");return 0;
}
6.3 函数的声明
函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
函数的声明可以多次,但是函数的定义只能有一次。
//声明可以多次,定义只能一次
//声明
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 函数的参数
如果函数要使用参数,则必须声明接受参数值的变量。这些变量称为函数的形式参数。
形式参数就是在进入函数时被创建,退出函数时被销毁。
当调用函数时,有三种向函数传递参数的方式:
调用类型 | 描述 |
---|---|
传值调用 | 把参数的实际值赋值给函数的形式参数,修改函数内的形式参数对实际参数没有影响。 |
指针调用 | 把参数的地址赋值给形式参数。该地址用于访问调用中要用到的实际参数,修改形式参数会影响实际参数。 |
引用调用 | 把参数的引用赋值给形式参数。该引用用于访问调用中要用到的实际参数,修改形式参数会影响实际参数。 |
1. 传值调用:
#include <iostream>
using namespace std;// 函数声明
void swap(int x, int y);// 函数定义
void swap(int x, int y)
{int temp;temp = x; /* 保存 x 的值 */x = y; /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y */return;
}int main ()
{// 局部变量声明int a = 100;int b = 200;cout << "交换前,a 的值:" << a << endl;cout << "交换前,b 的值:" << b << endl;// 调用函数来交换值swap(a, b);cout << "交换后,a 的值:" << a << endl;cout << "交换后,b 的值:" << b << endl;return 0;
}
输出结果:
交换前,a 的值: 100
交换前,b 的值: 200
交换后,a 的值: 100
交换后,b 的值: 200
2. 指针调用:
#include <iostream>
using namespace std;// 函数声明
void swap(int *x, int *y);// 函数定义
void swap(int *x, int *y)
{int temp;temp = *x; /* 保存地址 x 的值 */*x = *y; /* 把 y 赋值给 x */*y = temp; /* 把 x 赋值给 y */return;
}int main ()
{// 局部变量声明int a = 100;int b = 200;cout << "交换前,a 的值:" << a << endl;cout << "交换前,b 的值:" << b << endl;/* 调用函数来交换值* &a 表示指向 a 的指针,即变量 a 的地址 * &b 表示指向 b 的指针,即变量 b 的地址 */swap(&a, &b);cout << "交换后,a 的值:" << a << endl;cout << "交换后,b 的值:" << b << endl;return 0;
}
输出结果:
交换前,a 的值: 100
交换前,b 的值: 200
交换后,a 的值: 200
交换后,b 的值: 100
3. 引用调用:
#include <iostream>
using namespace std;// 函数声明
void swap(int &x, int &y);// 函数定义
void swap(int &x, int &y)
{int temp;temp = x; /* 保存地址 x 的值 */x = y; /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y */return;
}int main ()
{// 局部变量声明int a = 100;int b = 200;cout << "交换前,a 的值:" << a << endl;cout << "交换前,b 的值:" << b << endl;/* 调用函数来交换值 */swap(a, b);cout << "交换后,a 的值:" << a << endl;cout << "交换后,b 的值:" << b << endl;return 0;
}
输出结果:
交换前,a 的值: 100
交换前,b 的值: 200
交换后,a 的值: 200
交换后,b 的值: 100
7 指针
每一个变量都有一个内存位置,每一个内存位置都定义了可使用连字号(&)运算符访问的地址,它表示了在内存中的一个地址。
7.1 指针变量的定义使用
指针变量和普通变量的区别
- 普通变量存放的是数据,指针变量存放的是地址
- 指针变量可以通过" * "操作符,操作指针变量指向的内存空间,这个过程称为解引用
int main() {//1、指针的定义int a = 10; //定义整型变量a//指针定义语法: 数据类型 * 变量名 ;int * p;//指针变量赋值 通过 & 符号 获取变量的地址p = &a; //指针指向变量a的地址cout << &a << endl; //打印数据a的地址cout << p << endl; //打印指针变量p ,指针可以记录地址//2、指针的使用//对指针变量解引用,可以操作指针指向的内存//通过*操作指针变量指向的内存 cout << "*p = " << *p << endl;system("pause");return 0;
}
7.2 空指针和野指针
1. 空指针:
空指针变量指向内存中编号为0的空间,初始化指针变量。空指针指向的内存是不可以访问的。
int main() {//指针变量p指向内存地址编号为0的空间int * p = NULL;//访问空指针报错 //内存编号0 ~255为系统占用内存,不允许用户访问cout << *p << endl;system("pause");return 0;
}
2. 野指针:
野指针变量指向非法的内存空间,野指针不是我们申请的空间,因此不要访问。
int main() {//指针变量p指向内存地址编号为0x1100的空间int * p = (int *)0x1100;//访问野指针报错 cout << *p << endl;system("pause");return 0;
}
7.3 const修饰指针
const修饰指针有三种情况:
- const修饰指针 — 常量指针 : 指针指向可以改,指针指向的值不可以更改
- const修饰常量 — 指针常量 : 指针指向不可以改,指针指向的值可以更改
- const即修饰指针,又修饰常量 : 指针指向和指针指向的值都不可以改
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; //错误system("pause");return 0;
}
7.4 指针、数组
通过指针访问数组内的元素:
int main() {int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int * p = arr; //指向数组的指针cout << "第一个元素: " << arr[0] << endl;cout << "指针访问第一个元素: " << *p << endl;for (int i = 0; i < 10; i++){//利用指针遍历数组cout << *p << endl;p++;}system("pause");return 0;
}
7.5 指针、函数
利用指针作函数参数,可以修改实参的值:
//值传递
void swap1(int a ,int b)
{int temp = a;a = b; b = temp;
}
//地址传递
void swap2(int * p1, int *p2)
{int temp = *p1;*p1 = *p2;*p2 = temp;
}int main() {int a = 10;int b = 20;swap1(a, b); // 值传递不会改变实参swap2(&a, &b); //地址传递会改变实参cout << "a = " << a << endl;cout << "b = " << b << endl;system("pause");return 0;
}
7.6 指针、数组、函数
当数组名传入到函数作为参数时,被退化为指向首元素的指针
//冒泡排序函数
void bubbleSort(int * arr, int len) //int * arr 也可以写为int arr[]
{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;}}}
}//打印数组函数
void printArray(int arr[], int len)
{for (int i = 0; i < len; i++){cout << arr[i] << endl;}
}int main() {int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };int len = sizeof(arr) / sizeof(int);bubbleSort(arr, len);printArray(arr, len);system("pause");return 0;
}
今天我们就到这里,明天继续努力!
若本篇内容对您有所帮助,请三连点赞,关注,收藏支持下。
创作不易,白嫖不好,各位的支持和认可,就是我创作的最大动力,我们下篇文章见!
Dragon少年 | 文
如果本篇博客有任何错误,请批评指教,不胜感激 !
熬夜爆肝!C++基础入门大合集【万字干货预警 建议收藏】相关推荐
- Python 基础入门大合集,新手小白必看!
Python 入门 一.第一个 Python 程序 >>> print("Hello world!") 二.变量和简单数据类型 >>> mess ...
- 23篇大数据系列(一)java基础知识全集(2万字干货,建议收藏)
大数据系列爽文,从技术能力.业务基础.分析思维三大板块来呈现,你将收获: ❖ 提升自信心,自如应对面试,顺利拿到实习岗位或offer: ❖ 掌握大数据的基础知识,与其他同事沟通无障碍: ❖ 具备一定的 ...
- 万字长文爆肝Python基础入门【巨详细,一学就会】
目录 数据的名字和种类--变量和类型 初探数据种类 数据类型 数值运算 比较运算 变量和赋值 变量的好处 用赋值更新变量 变量和数据类型的关系 总结 数据类型 数值运算 数值比较 变量和赋值 一串数据 ...
- 万字长文爆肝Python基础入门【第二弹、超详细数据类型总结】
目录 一.建立一个数据火车--列表 1.创建列表 2.列表元素的获取 3.列表元素的添加 4.列表元素的删除 5.列表元素的修改 二.列表的亲兄弟--元组 1.创建元组 2.元组元素的获取 3.元组和 ...
- Linux基础知识大合集
文章目录 1 Linux基础入门 1.1 基础知识 1.2 Linux基础入门 1.2.1 Linux文本编辑工具vi/vim 1.3 Linux系统管理 1.3.1 linux系统基础管理与维护 1 ...
- 熬夜爆肝!C++核心STL常用算法汇总整理【2W字干货预警 建议收藏】
前言 1 STL- 常用算法 1.1 常用遍历算法 1.1.1 for_each 1.1.2 transform 1.2 常用查找算法 1.2.1 find 1.2.2 find_if 1.2.3 a ...
- python基础篇大合集,进程、装饰器、列表详解篇!
进程以及状态 1. 进程 2. 进程的状态 进程的创建-multiprocessing 1. 创建进程 2. 进程pid 3. Process语法结构如下 4. 给子进程指定的函数传递参数 5. 进程 ...
- python基础篇大合集,进程、装饰器、列表详解篇
1. 进程 程序:例如xxx.py这是程序,是一个静态的 进程:一个程序运行起来后,代码+用到的资源 称之为进程,它是操作系统分配资源的基本单元. 不仅可以通过线程完成多任务,进程也是可以的 2. 进 ...
- 万字肝完nodejs入门教程,详解入口,建议收藏(更新中)
nodejs入门教程 1.前言 2.入门教程 2.1 命令行运行node.js脚本 2.2 退出node.js程序 2.3 如何使用 Node.js REPL 2.3.1 使用方式 2.3.2 点命令 ...
最新文章
- JavaSE基础笔记八
- java怎么导入一个项目到eclipse
- linux 导入函数,共享库 – Linux ELF文件:如何获取属于导入函数的共享对象
- 浙大网新实训项目介绍
- linux+svn+拉取版本_在linux客户端下管理svn版本库
- 事故频发,自动驾驶技术该何去何从?
- 2016HUAS暑假集训训练题 F - 简单计算器
- java成员方法tostring_Java 工具类-toString
- pdf文档统计字数的问题
- Video Caption Tutorial
- vue中audio实现微信语音播放动画
- cupsd进程_CUPS 简介
- 安卓动态调试七种武器之离别钩 – Hooking(上)
- 上海华谊(集团)公司-统一业务协同平台
- 通过全局钩子发送自定义消息,实现进程通信
- ubuntu 网速测试方法
- 基于蚁群结合遗传算法的路径规划问题附Matlab代码
- ESP8266之TFT_eSPI库的自定义字体
- 数学建模学习:岭回归和lasso回归
- Java培训实现月薪15k,我都经历了什么(绝不是广告)