C++教程从0到1入门编程中知识点记录！

向右看齐 2023-01-01 05:00 196阅读 0赞

> C++教程从0到1入门编程中知识点记录！

# 一、C语言 #

## 1、冒泡排序 ##

示例代码：

#include <iostream>
    using namespace std;
    int main() {
    //冒泡排序
    	int arr_num[] = {4,2,8,0,5,7,1,3,9};
    	for (int i = 0; i < 9; i++) {
    		cout << arr_num[i] << " ";
    	}
    	cout << endl;
    	//冒泡
    	for (int j = 0; j < 9 - 1; j++) { //总共排序的轮数为元素个数减 1
    		for (int k = 0; k < 9 - 1 - j; k++) { //内层循环对比 次数=元素个数-当前轮数-1
    			//交换数字
    			if (arr_num[k] > arr_num[k + 1]) {
    				int temp = arr_num[k];
    				arr_num[k] = arr_num[k + 1];
    				arr_num[k + 1] = temp;
    			}
    		}
    	}
    	//排序后的结果
    	//int arr_num[] = { 4,2,8,0,5,7,1,3,9 };
    	for (int l = 0; l < 9; l++) {
    		cout << arr_num[l] << " ";
    	}
    	cout << endl;
    	system("pause");
    	return 0;
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70][]

## 2、二维数组 ##

示例代码：

#include <iostream>
    using namespace std;
    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;
    }

代码结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 1][]

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

## 4、指针所占的内存空间 ##

总结：所有指针类型在32位操作系统下是4个字节！

示例代码：

#include <iostream>
    using namespace std;
    int main() {
    
    	int a = 10;
    	//指针的定义：数据类型 *变量名
    	int *p;
    	//指针变量赋值
    	p = &a;
    	cout << "&a=" << &a << endl;
    	cout << "p=" << p << endl;
    	//指针的使用
    	cout << "*p=" << *p << endl;
    	cout << "a=" <<a << endl;
    	//指针所占内存空间
    	cout << "sizeof(p)=" << sizeof(p) << endl;
    	cout << "sizeof(int *)=" << sizeof(int *) << endl;
    	cout << "sizeof(float *)=" << sizeof(float *) << endl;
    	cout << "sizeof(double *)=" << sizeof(double *) << endl;
    	cout << "sizeof(char *)=" << sizeof(char *) << endl;
    	system("pause");
    	return 0;
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 3][]

## 五、const 修饰指针 ##

### 1、const 修饰指针 — 常量指针 ###

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 4][]   2、const 修饰常量 — 指针常量 ###

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 5][]   3、const 即修饰指针，又修饰常量 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 6][]

> 技巧：看“\*”和const的位置；把英文翻译成中文，从左到右：
> 
> 例如：常量指针 const int \*p 即：值不可更改，但是指针的指向可以更改！

示例代码：

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

## 六、指针、数组、函数 ##

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组： int arr\[10\]=\{4,3,6,9,1,2,10,8,7,5\}

代码示例：

#include <iostream>
    using namespace std;
    //冒泡函数
    void BubbleSort(int *arr, int len) { //int *arr ,也可以写为 int arr[]
    
    	for (int i = 0; i < len-1; i++) {
    		for (int j = 0; j < len - i - 1; j++) {
    			//如果 arr[j]>arr[j+1],进行交换
    			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] << " ";
    	}
    	cout << endl;
    }
    int main() {
    	
    	//1.输入一个数组
    	//2.冒泡函数
    	//3.打印升序数组
    	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
    	int len = sizeof(arr) / sizeof(arr[0]);
    	//打印数组
    	PrintArray(arr, len);
    	//执行冒泡函数
    	BubbleSort(arr, len);
    	//打印数组
    	PrintArray(arr, len);
    
    	system("pause");
    	return 0;
    }

> 总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针！

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 7][]

## 七、用const来防止误操作! ##

示例代码：

#include <iostream>
    #include <string>
    using namespace std;
    
    //学生结构体定义
    struct student
    {
    	//成员列表
    	string name;  //姓名
    	int age;      //年龄
    	int score;    //分数
    };
    
    //const使用场景
    void printStudent(const student *stu) //加const防止函数体中的误操作
    {
    	//stu->age = 100; //操作失败，因为加了const修饰
    	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;
    
    }
    
    int main() {
    
    	student stu = { "张三",18,100 };
    
    	printStudent(&stu);
    
    	system("pause");
    
    	return 0;
    }

## 八、内存分区模型 ##

> 程序运行前：代码区、全局区；
> 
> 程序运行后：栈区、堆区；

栈区： （1）由编译器自动分配释放, 存放函数的参数值,局部变量等；（2）注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放！

堆区：（1）由程序员分配释放,若程序员不释放,程序结束时由操作系统回收；（2）在C++中主要利用new在堆区开辟内存！

int *func() {
    	//此处的指针a 本质也是局部变量；放在栈上，指针保存的数据是放在堆区
    	int *a = new int(10);
    	return a;
    }

### 总结： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 8][]

示例代码：

#include <iostream>
    using namespace std;
    //全局变量
    int g_a = 10;
    int g_b = 10;
    // const 修饰的全局变量;全局常量
    const int c_g_a = 10;
    const int c_g_b = 10;
    int* fun() {
    	int a = 10;
    	return &a;
    }
    
    int main() {
    
    	//全局区
    
    	//全局变量、静态变量、常量
    
    	//创建普通局部变量
    	int a = 10;
    	int b = 10;
    	cout << "局部变量a的地址为" << (int)&a << endl;
    	cout << "局部变量b的地址为" << (int)&b << endl;
    
    	cout << "全局变量a的地址为" << (int)&g_a << endl;
    	cout << "全局变量b的地址为" << (int)&g_b << endl;
    	
    	//静态变量 ,在普通变量的前面加上static，属于静态变量
    	static int s_a = 10;
    	static int s_b = 10;
    	cout << "静态变量a的地址为" << (int)&s_a << endl;
    	cout << "静态变量b的地址为" << (int)&s_b << endl;
    	//常量：
    	//字符串常量 ""
    	cout << "字符串常量的地址：" << (int)&"hello world" << endl;
    	//const 修饰的变量
    	//const 修饰的全局变量、const修饰的局部变量
    	cout << "全局常量 c_g_a的地址为：" << (int)& c_g_a << endl;
    	cout << "全局常量 c_g_b的地址为：" << (int)& c_g_b << endl;
    	//
    	const int c_l_a = 10;
    	const int c_l_b = 10;
    	cout << "局部常量 c_l_a的地址为：" << (int)& c_l_a << endl;
    	cout << "局部常量 c_l_b的地址为：" << (int)& c_l_b<< endl;
    	//栈区
    	int *p = NULL;
    	p = fun();
    	cout << "返回函数中，变量的值：" << *p << endl;
    	cout << "返回函数中，变量的值：" << *p << endl;
    
    	system("pause");
    	return 0;
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 9][]

## 九、类 ##

类中的属性和行为 统一称为 成员

属性：成员属性、成员**变量**；

行为：成员**函数**、成员方法；

**class/类 默认的权限为私有，所以才有了：public 、protected、private**

> 类在设计时，可以把属性和行为放在不同的权限下，加以控制  
> 访问权限有三种：
> 
>  *  public 公共权限
>  *  protected 保护权限
>  *  private 私有权限

示例代码：

#include <iostream>
    using namespace std;
    //struct 和 class 区别
    //struct 默认权限是 公共 public
    //class  默认权限是 私有 private
    class C1 {
    	int m_a;
    };
    struct C2 {
    	int m_a;
    };
    
    int main() {
    
    	C1 c1;
    	c1.m_a = 100; //在class 默认的权限是私有，因此类外不可以访问；
    	C2 c2;
    	c2.m_a = 100; //在struct 默认的权限是公共，因此可以访问；
    	system("pause");
    	return 0;
    }

## 十、 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70]: /images/20221120/d5e64da091e940e7b4f15d110d7e99ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020123116511980.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210101144616154.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210101144652714.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210101151054385.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210101151343233.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210101151524401.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210101172218267.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210104082729415.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210104082945324.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1d3VrdTEyMw==,size_16,color_FFFFFF,t_70