前言

前几天有粉丝问我，大一结束c++刚学完，不知道自己目前学得怎么样？要掌握的知识点有没有都弄懂了？是否基础入门了？

这就安排上，熬夜爆肝整理出来的C++基础入门知识！

一篇文带你入门C++！一篇文带你疏通C++基础入门知识点！

在这里插入图片描述

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 World
   return 0;  // 终止 main( )函数，并向调用进程返回0
}

1.2 注释

可以在代码片段中添加一些说明和解释，方便自己或别人阅读理解写的代码。

编译器在编译代码时，会忽略注释的内容。

注释方式：

扫描二维码关注公众号，回复： 14454768 查看本文章

单行注释： // 注释内容
通常放在一行代码上方或者末尾
多行注释： /* 注释内容 */
通常放在一段代码的上方，对该段代码做整体说明

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 7

int 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 ^ 2
	cout << "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; // 1

	flag = false;
	cout << flag << endl; // 0

	cout << "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范围0_9，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 + 1
	cout << 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 1101
   int c = 0;           
 
   c = a & b;             // 12 = 0000 1100
   cout << "Line 1 - c 的值是 " << c << endl ;
 
   c = a | b;             // 61 = 0011 1101
   cout << "Line 2 - c 的值是 " << c << endl ;
 
   c = a ^ b;             // 49 = 0011 0001
   cout << "Line 3 - c 的值是 " << c << endl ;
 
   c = ~a;                // -61 = 1100 0011
   cout << "Line 4 - c 的值是 " << c << endl ;
 
   // 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）
   c = a << 2;            // 240 = 1111 0000
   cout << "Line 5 - c 的值是 " << c << endl ;
   // 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。
   c = a >> 2;            // 15 = 0000 1111
   cout << "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 - 2
	cout << "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;
	// %=
	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++基础入门大合集【万字干货预警 建议收藏】

前言

目录

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 指针、数组、函数

猜你喜欢

熬夜爆肝！C++基础入门大合集【万字干货预警建议收藏】