c学习笔记 更新中一、环境配置说明 你需要一个linux系统。如果只有windows可以尝试在win上使用WSL2, 比虚拟机更方便。具体怎么使用网上教程一大推Makefile学习Makefile 学习笔记-CSDN博客项目模板Makefile 编译c 调试模板 VScode_vscode makefile-CSDN博客1. 环境配置ubuntusudo apt-get update sudo apt-get install g sudo apt-get install gdb2. 项目模板尝试运行如果你有兴趣可以学习Makefile工具Makefile 学习笔记-CSDN博客Makefile 编译c 调试模板 VScode_vscode makefile-CSDN博客Makefile 编译c 调试模板 VScode_vscode makefile-CSDN博客二、基本语法1.hello world代码如下示例#include iostream using namespace std; int main() { // 单行注释用双斜杠多行注释用 /* 注释 */ cout hello world endl: system(pause); return 0; }2.变量与常量定义变量int a 15 float f1 3.14f double f2 3e2 //300定义字符与字符串char ch a //单引号只能放一个字符 (int)ch // 对用ASCII码 97 A:65 char str1[] hello world; //c风格 #includestring string str2 hello world; //c风格定义bool只要是非0值都代表真bool flag true; //占1字节标识符*由字母、数字、下划线组成*要避开关键字define 宏int a 15 //变量 //define 宏常量, 后续无法修改 #define Day 7 int main() { cout 一周有Day天endl;constint main() { const int a 15 //后续无法修改 cout 一周有Day天endl;3.转义字符换行符 \n 反斜杠 \ \ 水平制表符\t\t根据8字节对齐来设置空格数4.键盘输入cinint a 0; cout请输入整形变量endl; cina; coutaendl; //查看是否赋值成功5.数组定义# ------方式1----- int arr[5] ; arr[0] 10; arr[1] 20; # ------方式2----- int arr2[5] {102030}; //后续自动补0 int arr3[] {102030405060}查看大小sizeof(arr) / sizeof(arr[0]) //数组元素个数 cout数组首地址arrendl; //结果为16进制数 cout数组首元素地址(int)arr[0]endl; //结果为10进制数二维数组# ------方式1----- int arr[2][3]; arr[0][0] 1; arr[0][1] 2; # ------方式2----- int arr2[2][3] { {1,2,3}, {4,5,6} }; # ------方式3----- int arr3[2][3] {1,2,3,4,5,6}; int arr3[][3] {1,2,3,4,5,6}; cout二维数组行数 sizeof(arr) / sizeof(arr[0]) endl; cout二维数组列数 sizeof(arr[0]) / sizeof(arr[0][0]) endl; cout第二行首地址(int)arr[1]) endl; cout第一个元素首地址(int)arr[0][0]) endl;6.函数sizeofsizeof(short) //2 占用内存大小 sizeof(int) //4 sizeof(long) //4(windows) 8(linux64) sizeof(long long) //87.运算符算术运算符赋值运算符比较运算符逻辑运算符8.if、switch、while语句int score 0; cout请输入分数endl; cinscore; if (score600) { cout恭喜是一本endl; } else if(score700) { cout清华 endl; } else { cout是二本endl; }switch(score) { case 10: cout分数很高endl; break; case 9: cout分数很高endl; break; case 6: cout分数很高endl; break; default: cout低分endl; break;int main(){ int num 0; while(num 10) { coutnum numendl; num; } system(pause); return 0;int num 0; do { coutnumendl; num; } while(num 10) system(pause); return 0;9.指针1.空指针指针变量指向内存中编号为0空间0-255之间内存编号是系统占用不可访问int * p NULL; cout *p endl; //其内存不可访问 *p 100 报错野指针指针变量指向非法内存空间int * p (int *)0x1100; cout *p endl; //报错:没有访问权限const常量指针与指针常量# 1.const修饰指针指向可改指向的值不可改 const int * p1 a; p1 b //正确 *p1 100 //报错 # 2.const修饰常量指向不可改指向的值可改 int * const p2 a; p2 b //报错 *p2 100 //正确 # 3.const又修饰指针又修饰常量 const int * const p3 a; p3 b //报错 *p3 100 //报错3.指针访问数组int arr[] {1,2,3,4,5,6,7,8,9,10} int * p2 arr; for ( int i 0; i 10; i) { cout *p2 endl; p2; //向后跳4个字节 }4.指针函数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); //地址传递改变实参10.结构体1.自定义数据类型学生的姓名、年龄、分数等# ------1.创建学生数据类型------- struct Student { string name; int age; int score; }; # ------2.创建具体学生------- // 2.1 struct Student s1 #include string struct Student s1 # struct 关键字可以省略 s1.name 张三 s1.age 15; s1.score 100; cout 姓名 s1.name 年龄 s1.age endl; // 2.2 struct Student s2 {...} struct Student s2 {李四 , 19 , 80} // 2.3 创建结构体时顺便创建结构体变量 struct Student { string name; int age }s3; # ------3.创建结构体数组------- # 先定义结构体步骤如1.然后执行以下 struct Student stuArray[3] { {李四 , 19 ,80} {王五 , 16, 80} {赵四 , 20 ,80} }; # 重新或更改内容 stuArray[2].name 赵六2.结构体指针# 1.先定义结构体 # 2.创建结构体变量 student s {李四 , 19 ,80} # 3.指针 指向结构体变量 student *p s; # 4.通过指针访问结构体 cout 姓名 p-name 年龄 p-age endl;3.结构体嵌套结构体# 1.定义学生结构体 struct Student { string name; int age } # 2.定义老师结构体 struct teacher { int id: string name; int age; struct student stu; //辅导的学生 }; # 3.创建老师 teacher t; t.id 5685; t.name 老王 t.stu.name 小王; t.stu.score 60; cout t.stu.score;4.结构体中 const 使用# 1.定义结构体 # 2.const使用场景 void PrintStudent(const student *stu) //加const防止函数体中修改结构体内容 { cout 姓名 stu- name endl; } int main() { student stu {小明, 18, 100} PrintStudent(stu); system(pause);11. 文件读写C/C文件读写(最全方法多种实现)_c 写文件-CSDN博客#include iostream #include fstream // 必须包含 int main() { // 打开文件用于写入没有就创建有就覆盖 std::ofstream fout(test_write.txt); // 检查是否打开成功 if (!fout.is_open()) { std::cout 打开失败 std::endl; return 1; } // 写入内容 fout Hello, ofstream! std::endl; fout 这是第二行 std::endl; fout 123.456 std::endl; fout.close(); // 关闭文件 std::cout 写入完成 std::endl; return 0; } #include iostream #include fstream #include string int main() { // 打开文件用于读取 std::ifstream fin(test_write.txt); if (!fin.is_open()) { std::cout 文件不存在 std::endl; return 1; } // 逐行读取 std::string line; while (std::getline(fin, line)) { std::cout line std::endl; } fin.close(); return 0; } #include iostream #include fstream #include string int main() { // 打开文件用于读取 std::ifstream fin(test_write.txt); if (!fin.is_open()) { std::cout 文件不存在 std::endl; return 1; } // 逐行读取 std::string line; while (std::getline(fin, line)) { std::cout line std::endl; } fin.close(); return 0; }std::ofstream只写 →std::ifstream只读 →/ getlinestd::fstream可读可写 → 两者都能用三、进阶1 函数重载函数重载满足条件调用时会选择唯一满足的函数来进入执行同一个作用域下全局域等函数名称相同函数参数类型不同或者个数不同或者顺序不同//函数重载需要函数都在同一个作用域下 void func() { cout func 的调用 endl; } void func(int a) { cout func (int a) 的调用 endl; } void func(double a) { cout func (double a)的调用 endl; } void func(int a ,double b) { cout func (int a ,double b) 的调用 endl; } void func(double a ,int b) { cout func (double a ,int b)的调用 endl; } int main() { func(); func(10); func(3.14); func(10,3.14); func(3.14 , 10); system(pause); return 0; }函数重载注意事项引用作为重载条件函数重载碰到函数默认参数//1、引用作为重载条件 void func(int a) { cout 需要输入一个变量(int a) 调用 endl; } void func(const int a) { cout 需要输入常量 (const int a) 调用 endl; } //2、函数重载碰到函数默认参数 void func2(int a, int b 10) { cout func2(int a, int b 10) 调用 endl; } void func2(int a) { cout func2(int a) 调用 endl; } int main() { int a 10; func(a); //调用无const func(10);//调用有const func2(10); //碰到默认参数产生歧义报错 func2(1020); //正常执行 system(pause); return 0; }2 深拷贝浅拷贝深拷贝(在堆区重新申请空间进行拷贝操作)与浅拷贝涉及到堆区开辟的属性由于浅拷贝拷贝函数在栈区释放时会重复释放导致出错。如图class Person { public: //无参默认构造函数 Person() { cout 无参构造函数! endl; } //有参构造函数 Person(int age ,int height) { cout 有参构造函数! endl; m_age age; m_height new int(height); } //拷贝构造函数 Person(const Person p) { cout 拷贝构造函数! endl; //如果不利用深拷贝在堆区创建新内存会导致浅拷贝带来的重复释放堆区问题 m_age p.m_age; m_height p.m_height # 报错编译器默认实现代码导致堆区数据重复释放 m_height new int(*p.m_height); } //析构函数 ~Person() { cout 析构函数! endl; if (m_height ! NULL) { delete m_height; } } public: int m_age; int* m_height; }; void test01() { Person p1(18, 180); Person p2(p1); cout p1的年龄 p1.m_age 身高 *p1.m_height endl; cout p2的年龄 p2.m_age 身高 *p2.m_height endl; } int main() { test01(); system(pause); return 0; }在C中引用Reference和指针Pointer都是用于间接访问对象和数据的重要特性。虽然它们的作用相似都能实现对数据的间接操作但在语法和使用上有显著的区别。3 引用引用是某个变量的别名。一旦一个引用被初始化为一个变量它就与该变量绑定无法再指向其他变量。引用为我们提供了一种直接访问变量的方式而不需要通过指针的间接访问。特点必须在定义时初始化。一旦绑定不能再改变绑定对象。引用不能为NULL即引用必须绑定到合法的存储。引用提供了更简洁的语法。引用不占用额外内存引用是变量的别名编译器在使用引用时直接访问被引用对象的地址因此引用本身不会占用独立的内存空间。编译器优化编译器在处理引用时会生成直接访问被引用对象的代码而不会生成引用本身的地址。这使得引用在编译后的机器码中不占用额外的内存空间。共享内存地址引用与它所引用的变量共享相同的内存地址任何通过引用进行的操作都会直接影响到被引用的变量。案例引用的定义和初始化必须在同一行进行并且引用一旦绑定到一个变量就不能再改变绑定对象。可以观察到ref引用与a指向的是同一个地址值相同# include iostream void test(){ int a 10; int b 20; int ref a; // 初始化必须赋值 //int ref; //错误 printf(address of a : %p\n, a); printf(address of b : %p\n, b); printf(address of ref: %p\n, ref); } int main() { test(); return 0; } //address of a : 0x7ffd94579af0 //address of b : 0x7ffd94579af4 //address of ref: 0x7ffd94579af0 //value of a : 10 //value of ref: 104 指针指针是一个变量它存储另一个变量的内存地址。通过指针可以间接访问和操作该地址上的数据。指针的定义和初始化可以分开进行指针也可以被重新赋值以指向不同的变量特点可以在定义后再初始化。可以被重新赋值以指向不同的对象。可以为NULL即指向空地址。需要使用解引用操作符*来访问指向的对象。需要注意内存管理以防止内存泄漏和悬空指针。案例# include iostream void test(){ int a 10; int * p_a a; // pointer to a printf(value of a: %d\n, a); // a 的值 printf(value of a: %p\n, p_a); // p_a 的值 printf(value pointed by p_a: %d\n, *p_a); // p_a 指向的值也就是a的值 printf(value of p_a: %d\n, *p_a); // 使用指针对 a 1 printf(value of p_a: %d\n, a); // a 的值改变 printf(address of a : %p\n, a); // a 的地址 printf(address of *p_a: %p\n, (*p_a)); // p_a指向值的地址 printf(address of p_a : %p\n, p_a); // p_a 的地址 } int main() { test(); return 0; } // value of a: 10 // value of a: 0x7ffcb8d5e3dc // value of p_a: 11 // value of p_a: 11 // address of a : 0x7ffcb8d5e3dc // address of *p_a: 0x7ffcb8d5e3dc // address of p_a : 0x7ffcb8d5e3e0对于这个案例分析指针的值是一个地址指向a的地址指针的地址是随机的对指针取值 使用 * 符号对指针的值操作a也会改变指针和引用的使用swap案例# include iostream void swap1(int a, int b) {\ int temp a; a b; b temp; } void swap2(int* a, int* b) {\ int temp *a; *a *b; *b temp; } int main() { int a 5; int b 10; printf(a %d, b %d\n, a, b); swap1(a, b); printf(swap1: a %d, b %d\n, a, b); swap2(a, b); printf(swap2: a %d, b %d\n, a, b); return 0; }5 函数函数传参有三种传值传引用和传指针。#include iostream // 传值 值的传递复制一份value, 下面main函数调用的时候只是把value复制了一份传过来 // 效率是低的 void swap_value(int x 5, int y 10) { int temp; temp x; x y; y temp; return; } // 传引用, 下面main函数调用的时候a,x b, y 的数据是绑定在一起的 void swap_reference(int x, int y) { int temp; temp x; x y; y temp; return; } // 类型 int float map vector // * ** const static -- 饰词 void swap_ptr(int* x, int* y){ int temp *x; *x *y; *y temp; return; } int main() { int a 300, b 500; // swap_value(a, b); // std::cout swap_value value a is: a std::endl; // std::cout swap_value value b is: b std::endl; // swap_reference(a, b); // std::cout swap_reference value a is: a std::endl; // std::cout swap_reference value b is: b std::endl; swap_ptr(a, b); std::cout swap_ptr value a is: a std::endl; std::cout swap_ptr value b is: b std::endl; return 0; }6 数组所谓数组就是一个集合里面存放了相同类型的数据元素连续的内存位置组成的数组是可以写超的设置的是10个也可以遍历他第11个他也能写出来但是数值是不可控的C可以直接操作内存C是连续的内存所以我们拿到的是后面的值不能像python一样全部展示出来数组创建void test() { // 1. 创建数组 int arr1[5] {1, 2, 3, 4, 5}; // 2. 创建数组 int arr2[5]; for (int i 0; i 5; i) { arr2[i] i 1; } // 3. 创建数组 int arr3[] {1, 2, 3, 4, 5}; printf(valuevalue of arr1: %p\n, arr1); // 数组名就是数组第一个元素的地址 printf(address of arr1: %d\n, *arr1); printf(address of arr11: %d\n, *arr11); printf(address of arr12: %d\n, *arr12); printf(address of arr13: %d\n, *arr13); printf(address of arr14: %d\n, *arr14); }创建一个长度5的数组重点关注打印输出数组名就是数组的第一个元素的地址打印数组的三种方式# include iostream void printArray1(int arr[], int len) { for (int i 0; i len; i) { std::cout arr[i] ; } std::cout std::endl; } void printArray2(int arr[], int len) { int * p arr; // 指向数组第一个元素的地址 for (int i 0; i len; i) { std::cout *p ; } std::cout std::endl; } void printArray3(int* arr, int len) { for (int i 0; i len; i) { std::cout *arr ; } std::cout std::endl; } void test() { // 1. 创建数组 int arr1[5] {1, 2, 3, 4, 5}; printArray1(arr1, 5); printArray2(arr1, 5); printArray3(arr1, 5); } int main() { test(); return 0; }7 new和malloc的区别是什么malloc和free, 称作C的库函数new和delete是运算符malloc开辟内存失败通过返回值和nullptr来判断而new开辟内存失败是通过抛出bad_alloc类型的异常来判断的malloc是按照字节开辟的需要对返回值进行类型的转换new是指定类型开辟内存的不仅开辟内存还能给定初始值new 开辟的内存区域是一个连续的内存空间用来存储指定数量的同类型数据。为了引用这个内存空间需要使用一个指针变量来存储内存的首地址从而访问这个内存空间中的元素。因此把 new 开辟出来的内存赋给一个指针变量是一种常见的做法#include iostream #include new // bad_alloc int main() { // 使用 malloc 分配内存 int *p (int *)malloc(sizeof(int)); if (p nullptr) { std::cerr Memory allocation failed using malloc std::endl; return -1; } *p 10; // 初始化分配的内存 std::cout Value allocated by malloc: *p std::endl; // 使用 new 分配内存 int *p1 nullptr; try { int *p1 new int(20); // 初始化为 20 std::cout Value allocated by new: *p1 std::endl; } catch (const std::bad_alloc e) { std::cerr Memory allocation failed using new: e.what() std::endl; free(p); // 释放 malloc 分配的内存 return -1; } // 清理资源 free(p); // 释放 malloc 分配的内存 delete p1; // 释放 new 分配的内存 return 0; }开辟数组c 数组int main() { // C中开辟数组内存 int *q (int*)malloc(sizeof(int) * 20); if (q nullptr) { return -1; } free (q); return 0; }c数组int main() { // C中开辟数组内存 int *q new int[20]; // 没有初始值数组内存 int *q1 new int[20](); // 全部初始化为0 delete []q; delete []q1; return 0; }8 关键字staticstatic是 C/C中的关键字之一是常见的函数与变量C中还包括类的修饰符它常被用来控制变量的存储方式和作用范围。 在众多高级语言中都有其作为关键字或函数出现所以这也是应当被程序员熟知其各种含义的一个单词可以修饰1.局部变量2.全局变量3.函数1. static 修饰变量1static关键字修饰局部变量不改变作用域但是生命周期变长。2本质上static关键字修饰局部变量改变了局部变量的存储位置因为存储位置的差异使得执行效果不一样。普通的局部变量放在栈区这种局部变量进入作用域创建出作用域释放。局部变量被static修饰后成为静态局部变量这种变量放在静态区创建好后直到程序结束后才释放。#include stdio.h #include stdlib.h void test() { static int x 0; x; printf(%d , x); } int main() { int i 0; printf(%d\n, i); while (i 10) { test(); i; } printf(\n); return 0; }2.static在修饰局部变量和函数的作用⭐作用保持变量内容的持久static的第一个作用是保持变量内容的持久即static变量中的记忆功能和全局生存期。存储在静态数据区的变量会在程序刚开始运行时就完成初始化也是唯一的一次初始化。之后再次运行到含有 static 关键字的初始化语句时不会再执行该语句。共有两种变量存储在静态存储区全局变量和 static 变量只不过和全局变量比起来static 可以控制变量的可见范围。3.static修饰全局变量和函数在全局和/或命名空间范围 (在单个文件范围内声明变量或函数时) static 关键字指定变量或函数为内部链接即外部文件无法引用该变量或函数。针对上面这个概念的理解我们一次来解析以下1. 首先说一下全局变量全局变量的作用域十分的广只要在一个源文件中定义后这个程序中的所有源文件、对象以及函数都可以调用生命周期更是贯穿整个程序。文件中的全局变量想要被另一个文件使用时就需要进行外部声明以下用extern关键字进行声明。-----也即是说全局变量既可以在源文件中使用也可以在其他文件中使用只需要使用extern外部链接以下即可2. static修饰全局变量和函数时会改变全局变量和函数的链接属性-------变为只能在内部链接从而使得全局变量的作用域变小。