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

最新推荐文章于 2024-07-25 23:22:43 发布

2401_84975843

最新推荐文章于 2024-07-25 23:22:43 发布

阅读量920

点赞数 27

文章标签： c语言 c++ 学习

本文链接：https://blog.csdn.net/2401_84975843/article/details/138983511

版权

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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
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
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
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
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
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
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;

}


执行过程：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210712190829569.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hobGFkbWluaGhs,size_16,color_FFFFFF,t_70)


### 4.3 循环控制语句




| 控制语句 | 描述 |
| --- | --- |
| break 语句 | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
| continue 语句 | 引起循环跳过主体的剩余部分，立即重新开始测试条件。 |
| goto 语句 | 将控制转移到被标记的语句，不建议在程序中使用 goto 语句。 |


**1. break：**

#include
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
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
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
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
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
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
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;
}



![img](https://img-blog.csdnimg.cn/img_convert/8414f74b28dd4f953cb4f87abd26bea7.png)
![img](https://img-blog.csdnimg.cn/img_convert/853c25dee6484c8911719376fa7bbf09.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

 表示指向 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;
}

[外链图片转存中…(img-bBfHGLiF-1715884722847)]
[外链图片转存中…(img-Gl9wAi9U-1715884722848)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取