C++教程从0到1入门编程中知识点记录！
C++教程从0到1入门编程中知识点记录！
一、C语言
1、冒泡排序
示例代码：
#include
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;
} 运行结果：
2、二维数组
示例代码：
#include
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;
} 代码结果：
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
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=" < 运行结果：
五、const 修饰指针
1、const 修饰指针 — 常量指针
2、const 修饰常量 — 指针常量
3、const 即修饰指针，又修饰常量
技巧：看“*”和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
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;
} 总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针！
运行结果：
七、用const来防止误操作!
示例代码：
#include
#include
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;
}总结：
示例代码：
#include
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;
}
运行结果：
九、类
类中的属性和行为 统一称为 成员
属性：成员属性、成员变量；
行为：成员函数、成员方法；
class/类 默认的权限为私有，所以才有了：public 、protected、private
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
- public 公共权限
- protected 保护权限
- private 私有权限
示例代码：
#include
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;
} 十、