C++|C++ 核心编程
0.前言
最近在做算法移植的时候，发现自己对c++的知识忘得很多，于是就计划重新捡起来。
纸上得来终觉浅，绝知此事要躬行
一直都是我学习和工作的原则，我比较喜欢动手。
于是我把c++的基础知识一行行代码敲了一遍，无论多简单！
为以后研究camera框架源码，写算法移植的框架打一下基础！
1.内存分区模型
c++内存分为4个区域：
- 代码区：存放函数体的二进制代码，由操作系统进行管理。
- 全局区：存放全局变量、静态变量、常量
- 栈区：由编译器自动分配释放，存放函数的参数值、局部变量等。
- 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。
1.1 程序运行前 在程序编译后，生产了exe可执行程序，未执行该程序前分为
代码区：
存放cpu执行的机器指令
1.共享：目的是对于频繁被执行的程序，只需内存中由一份代码即可。
2.只读：防止程序被随意修改指令
全局区：
全局变量包含常量区：字符串常量和其他常量
程序结束后，系统自己释放全局区的数据
const修饰的局部变量(局部常量),不放在全局区，而是放在栈区
int fun() {
const int a =10;
//局部常量
}
总结：
- c++在exe程序运行前分为全局区和代码区
- 代码区的特点是只读和共享
- 全局区中存放全局变量 静态变量 常量
- 常量区中存放const修饰的全局变量(即全局常量) 和 字符串常量
由编译器自动分配和释放，函数的参数，局部变量等
注意事项：不与返回局部变量的地址，栈区开辟的数据在函数结束后，编译器会自动释放
堆区
由程序员分别和释放，若程序员不释放，程序结束后，系统会自己释放，如果程序不结束，系统就永远不释放。
c++中主要用new在堆区申请内存
1.3 new的用法 new申请，务必使用delete释放
int *a = new int(10);
delete a;
int *b = new int [8];
delete [] b;
//数组释放要加[]
2.引用 2.1 引用的基本使用 作用：给变量起别名
语法：数据类型 &别名 = 原名
int a =10;
int &b = a;
(本质上：int *const b = &a)
2.2 引用的注意事项
- 1.引用必须要初始化
int &b; //错误 - 2.引用在初始化后，不可以改变
int a =10;
int &b = a;
int c =20;
b = c;
//赋值操作，而不是更改引用
2.3 引用做函数参数 作用:函数传参时，可以利用引用的技术，让形参修饰实参
优点：可以简化指针修改实参
void swap(int &a,int &b) {
int temp = a;
a = b;
b = temp;
}
2.4 引用做函数返回值 作用：引用可以作为函数的返回值
注意：不要返回局部变量的引用
用法：函数调用作为左值
int& fun()
{
static int a =10;
return a;
}int &ref = fun();
fun()= 100;
//函数调用可以作为左值 被赋值
2.5 引用的本质 本质：引用的本质在c++内部实现是一个指针常量（指向不变，里面的值可变）
//编译器发现这里是引用，转换位int * const ref = &a;
void func(int & ref) {
ref = 100;
//ref是引用，转换位*ref = 100
}int main(){
int a=10;
int& ref = a;
//自动转换为 int* const ref = &a;
//指针常量是指向不可更改，值可改，也说明为什么引用不可更改ref = 20;
//发现是引用，自动转换成 *ref =20
}
结论：c++途径用引用计数，因为语法方便，引用的本质是指针常量，但是所有指针的操作，编译器都帮我们做了
常量引用 作用：常量引用主要用来修饰形参，防止误操作
const int & a;
int &ref =10; //这是错误的，引用必须引用一块合法的内存,10在常量区，访问时必须加const
int &ref =10;
//这是错误的，引用必须引用一块合法的内存const int &ref =10；//合法
//加上const之后，编译器把代码修改成
/*
int temp =10;
const int &ref = temp;
*///常量引用使用场景：通常用来修饰形参，防止函数改值
void printValue(const int&a){
//a=20；报错
print("a=%d",a);
}
3.函数提高 3.1 函数的默认参数 在c++中，函数的形参是可以有默认值的。
语法： 返回值 函数名 (参数 = 默认值) { }
int func(int a,int b=1, int c =2) {}
- 如果形参中某个位置有了默认参数，从这个位置往后，从左往右都必须有默认参数
- 如果函数声明有默认参数，函数实现就不能有默认参数，否则会报错：重定义默认参数
int fun2(int a =10);
//声明
int func2(int a =10){//实现
}
这样会报错
3.2 函数占位参数 c++中的函数的形参是可以有占位参数的，用来做占位，调用函数时必须填补该位置。
语法： 返回值 函数名 （数据类型）{ }
//占位参数-第二个参数
void func(int a,int) {}
//占位参数 还可以有默认参数
void func2(int = 10){}int main(){
func(10,10);
}
3.3 函数重载 3.3.1 函数重载概述 作用：函数名可以相同，提高复用性
函数重载满足条件
- 同一个作用域下
- 函数名相同
- 函数参数 类型不同 或者 个数不同 或者 顺序不同
void fun();
void fun (int a,float b)
void fun (float b,int a)
//intfun (float b,int a) 这个会报错，二义性
3.3.2 函数重载注意事项
- 引用作为重载条件
//1.引用作为重载条件
void func(int &a){ //int& a =10 ；不合法}void func(const int &a){const int &a = 10 合法}
这两个是函数重载 int 和 const int算不同类型int main(){
int a =10;
func(a);
//此时调用第1个void func(int &a)，
//如果void func(int &a)没定义，就调用第2个
func(10);
//此时调用第2个void func(const int &a)
}- 函数重载碰到默认参数
void func(int a){ //int& a =10 ；不合法}
void func(int a,int b =10){
}fun(10);
//这里编译器不知道调用哪个了
这里函数会出现二义性，会报错，
一般写函数重载时，就别写默认参数了
4.类和对象 万事万物皆为对象，包含属性和行为
c++面向对象的三大特性：封装、继承、多态
4.1 封装
4.4.1 封装的意义 封装是c++面向对象的三大特性之一
意义：
- 将属性和行为作为一个整体，表现生活中的事物
- 将属性和行为加以权限控制f
在设计类的时候，属性和行为写一起，表现事物
语法：class 类名{访问权限： 属性/行为}；
设计一个圆类
//圆周率
const double PI = 3.14；class Circle
{
//访问权限
public://属性
int r;
//半径//行为
double calZC(){
return 2*PI*r;
}Circle c ;
//对象
c.r = 10;
c.calZC（）；}
封装的意义2：
将属性和行为加以权限控制
访问权限有3种
1.public：公共权限
成员 类内可以访问，类外可以
2.protected：保护权限
成员 类内可以访问，类外不可以
3.private：私有权限
成员 类内可以访问，类外不可以
4.1.2 struct 和 class区别 在c++中，struct和class的唯一区别：
默认访问权限不同
- struct 默认权限 公共
- class 默认权限 私有
class C1
{
int a;
//私有
}；struct C2 {
inta ;
//公共
}
4.1.3 成员属性设置为 私有
- 优点1：：将所有的属性设置成私有，可以自己控制读写权限
- 优点2：对于写权限，可以检测数据的有效性
对象没用初始状态，其后果是未知的
使用完对象没释放，也会造成安全难问题
- 构造函数：创建对象时，初始化属性
- 析构函数：销毁对象时，释放资源
2个函数都是系统自动调用！
1.构造函数没有返回值，也不写void
2.函数名和类名相同
3.构造函数有参数，可以函数重载
4.创建对象时，自动调用一次构造函数
析构函数语法：
1.析构函数没有返回值，也不写void
2.析构函数与类名相同，在名称前加上~
3.析构函数没用参数，无法重载
4.对象销毁前会自动调用一次析构函数
Class p{
//构造函数
p(){ }
//析构函数
~p(){
}
};
4.2.3构造函数的分类和调用 两种分类方式：
按照参数：有参构造和无参构造
按照类型：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
class Person {
public:
Person(){//无参构造
}
Person(int a){//有参构造
age = a；
}
//以上都是普通构造Person(constPerson &p){//拷贝构造
age = p.age;
}private：
int age；
}1.括号法
Person p1;
Person p2(10);
Person p3(p2);
2.显示法
Person p1;
Person p2= Person(10);
Person p3 = Person(p2);
Person(6);
//单独拿出来是 匿名对象
特点：当前行执行结束后，系统会立即回收匿名对象注意事项：
不要利用拷贝构造函数，初始化匿名对象
Person(p3);
编译器会认为Person(p3) == Person p3;
3.隐式转换法
Person p4 = 10;
//相当于 Person p4 = Person(10);
Person p5 = p4;
//相当于 Person p5 = Person(p4);
4.2.3 拷贝构造函数的调用时机
class Person{
public:
Person(){
无参构造
}Person(int a ){
有参构造
age =a;
}Person(const Person & p){
拷贝构造
age = p.age;
}~Person(){
析构函数
}private:
int age;
}
三种情况：
- 使用一个已经创建完的对象来初始化一个新对象
void test(){
Person p1(20);
Person p2(p1);
}
- 值传递的方式给函数参数传值
void doWork(Person p){//这里相当于Person p = my_p}
void test2(){
Person my_p;
doWork(my_p);
}
* 以值的方式返回局部对象
```c
Person doWork3(){
Person p;
return p;
//这里执行完后会释放p，系统会拷贝一个临时p返回
}
void test(){
Person p = doWrok3();
}
4.2.4 构造函数调用规则 默认情况下，c++编辑器会给一个类添加3个函数
1.默认构造函数(无参 函数体为空)
2.默认析构函数(无参 函数体为空)
3.默认拷贝构造函数(对所有属性进行值拷贝)
构造函数规则：
- 如果用户定义了有参构造，c++编辑器不在提共默认无参构造，但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数，c++不会提供其他构造函数
Person(const Person & p){
拷贝构造
age = p.age;
}
4.2.5 深拷贝和浅拷贝
- 浅拷贝：值拷贝
- 深拷贝: 在堆区重新申请一块内存空间，进行拷贝操作
#include
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Person
{
public:
Person()
{
cout<<"Person 默认构造函数"<
总结：如果成员变量有在堆区开辟内存的，一点要自己提供拷贝构造函数，防止浅拷贝代理的堆内存重复释放问题
4.2.6 初始化列表
作用
c++提供初始化列表的语法，用来初始化属性
【C++|C++ 核心编程】语法：构造函数():属性1(值1)，属性2(值2)···{}
#include
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Person
{
public:
Person():m_a(10),m_b(20)
{}Person(int a,int b):m_a(a),m_b(b)
{}
int m_a;
int m_b;
};
int main(int argc, char** argv) {
Person p;
cout<
4.2.7 类对象作为类的成员
构造时：当其他类对象作为本类成员时，构造时先构造出其他类的对象，在构造自身
析构时：先析构自己，再析构其他类。(因为加载函数是栈的形式 后进先出)
class Phone
{
public:
Phone(string name):name(name)
{
cout<<"Phone 有参构造函数调用"<
4.2.8 静态成员
在成员函数和成员变量前面加上static关键字，成为静态成员。
静态成员分为：
- 静态成员变量
- 所有对象共享一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
class A
{
public:
static int m_a;
//类内声明
}
int A::m_a = 100;
//类外初始化 要去掉static
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
- 类外无法访问私有的成员函数或者变量
class Person
{
public:
static void fun()
{
cout<<"静态成员函数"<
4.3 C++的对象模型和this指针
4.3.1 成员变量和成员函数分开存储
在c++中，类内的成员变量和成员函数是分开存储的，
只有非静态成员变量才属于类的对象上
- 空对象占用内存为1个字节
c++编译器会给每个空对象分配一个字节空间，是为了区分空对象占用内存的位置。
class Person
{} ;
void test()
{
Person p;
//空对象
cout<
- 只有非静态成员变量才属于类的对象上
class Person
{
int a;
//非静态成员变量 属于类的对象 此时p的内存为4 个字节static int b;
//静态成员变量 不属于类对象上void fun();
//非静态成员函数 不属于类对象上static void fun2();
//静态成员函数 不属于类对象上 } ;
void test()
{
Person p;
cout<
4.3.2 this指针的概念
this指针指向被调用的成员函数所属的对象
谁调用this，this就指向哪个对象
this是隐含在非静态成员函数内的一种指针
this指针的用途：
- 当形参和成员变量同名时，可以用this指针来区分
- 在类的非静态成员函数中返回对象本身，可以用return *this
class Person
{
public:
Person(int age)
{
this->age = age;
}//这里要返回Person&，如果返回Person，系统会创建一个临时变量返回
Person& addAge(Person &p)
{
this->age += p.age;
//this指向的是p2的指针，而*this指向的是p2对象本身
return *this;
}
int age;
} ;
this指向的是p2的指针，而*this指向的是p2对象本身
4.3.3 空指针访问成员函数
c++中空指针也是可以调用成员函数的，
如果要用到this指针，要加以判断，保证代码的健壮性
class Person
{
public:
void showName()
{
cout<<"this is Person class"<
- 类做友元
class Home
{
public:
friend class GoodGay;
Home():m_livingRoom("客厅"), m_bedRoom("卧室")
{}
public:
string m_livingRoom;
private:
string m_bedRoom;
};
class GoodGay
{
public:
GoodGay()
{
h = new Home;
}
void visit()
{
cout<<"好基友正在访问:"<< h->m_livingRoom<m_bedRoom<
- 成员函数做友元
class GoodGay;
class Home
{
//成员函数做友元
friend void GoodGay::visit();
public:
Home():m_livingRoom("客厅"), m_bedRoom("卧室")
{}
public:
string m_livingRoom;
private:
string m_bedRoom;
};
class GoodGay
{
public:
GoodGay()
{
h = new Home;
}
void visit()
{
cout<<"好基友正在访问:"<< h->m_livingRoom<m_bedRoom<
4.5 重载
ps:运算符重载跳过
4.6 继承
继承的好处
减少重复的代码
4.6.1 继承的基本语法
语法：
class 子类：继承方式 父类
子类也称为派生类
父类也成为基类
class BaspePage
{
public:
void header()
{
cout<<"首页 公开课 登录 注册"<
4.6.2 继承的方式
继承的方式一共有三种：
- 公共继承
- 保护继承
- 私有继承
文章图片
class Father
{
public:
Father():a(1),b(1),c(1)
{}
public:
int a;
protected:
int b;
private:
int c;
};
class Son1:public Father
{
public:
void fun()
{
a= 10;
b= 20;
//c= 30;
}
};
void test01()
{
Son1 s;
s.a = 100;
//s.b = 50;
保护权限类外无法访问
}
4.6.3 继承中的对象模型
问题：从父类继承过来的成员，哪些属于子类对象中？
私有成员也会被子类继承，只是被编译器隐藏了，无法访问
class Base
{
public:
int a;
protected:
int b;
private:
int c;
//私有成员也会被子类继承，只是被编译器隐藏了，无法访问
};
class Son:private Base
{
public:
int d;
};
int main(int argc, char** argv) {
Son s;
cout<
4.6.4 继承中构造和析构的顺序
子类继承父类后，当创建子类对象时，也会调用父类的构造。
先构造父类，在构造子类，析构相反：先析构子类，再析构父类
class Base
{
public:
Base()
{
std::cout<<"Base 的默认构造函数"<
4.6.5 继承中同名成员的处理方式
问题：当子类与父类出现同名成员，如何通过子类对象，访问子类或者父类的同名数据呢？
- 访问子类 同名成员，直接访问即可
- 访问父类 同名成员，需要加作用域
总结：
- 1.子类对象可以直接访问到子类中的同名成员
- 2.子类对象加作用域可以访问到父类同名成员
- 3.当子类和父类拥有同名的成员函数时，子类会隐藏父类中所有的同名函数，需要加作用域才可以访问父类的同名函数
class Base
{
public:
Base()
{
m_a = 100;
}void fun()
{
cout<<"Base - fun()"<
4.6.8 菱形继承
概念：
2个子类继承同一个父类
又有某个类统计继承2个子类
这种继承被称为菱形继承，或者钻石继承
class Animal
{
public:
int m_Age;
};
//继承前面加virtual关键字，变为虚继承
//此时公共父类Animal称为虚基类
class Sheep : virtual public Animal{};
//羊
class Camel : virtual public Animal{};
//骆驼
class Alpaca : public Sheep , public Camel{};
//羊驼
int main() {
Alpaca a;
a.Sheep::m_Age = 100;
a.Camel::m_Age = 200;
cout<<"a.Sheep::m_Age ="<
总结：
- 菱形继承带来主要问题是 子类继承多份相同的数据，导致资源浪费。
- 利用 虚继承 解决菱形继承问题
- 虚继承的本质是继承指针，通过指针去访问同一份数据(m_Age)
4.7 多态
多态是C++面向对象的三大特性之一
4.7.1 多态的基本概念
多态分为2类：
- 静态多态：函数重载和运算符重载 属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别：
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
静态多态
class Animal
{
public:
void speak()
{
cout<<"动物在说话"<
动态多态
class Animal
{
public:
//加上virtual，变成虚函数，就可以晚绑定 ，子类的函数可加virtual 或者不加
virtual void speak()
{
cout<<"动物在说话"<
重写： 函数返回值 参数列表完全相同
重载：函数参数列表不同，返回值相同
总结：
动态多态的满足条件
- 1.有继承关系
- 2.子类重写父类的虚函数
动态多态的使用
父类的指针或者引用，执行子类对象
class A
{
public:
int fun(){}
}
这里 sizeof(A)= 1
class A
{
public:
virtual int fun(){}
}
这里 sizeof(A)= 4,因为加上 virtual ，fun就变成了一个指针(指针都是4个字节)vfptr:虚函数指针
4.7.2 多态案例-计算器
普通代码实现计算器
//普通代码实现计算器
class NomalCal
{
public:
int getResutl(int oper)
{
switch(oper)
{
case '+' :
return m_a + m_b;
break;
case '-' :
return m_a - m_b;
break;
case '*' :
return m_a * m_b;
break;
//如果想扩展功能：除法，需要修改源码
//开发中提倡开闭原则：对扩展进行开放，对修改进行关闭
default:
return 0;
}
}
int m_a;
int m_b;
} ;
void test1()
{
NomalCal nc;
nc.m_a = 10;
nc.m_b = 10;
cout<m_b<<" = "<getResult()<
多态的优点：
- 代码结构清晰
- 可读性强
- 利于前期和后期的扩展以及维护，符合开闭原则
4.7.3 纯虚函数和抽象类
在多态中，通常父类中的虚函数是毫无意义的，主要调用子类的重写的函数。
因此可以把虚函数改为纯虚函数
语法：virtual 返回值类型 函数名(参数列表) = 0
当类中只要有1个纯虚函数，也把类称为抽象类
抽象类的特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
class Base//抽象类：类中只要有一个纯虚函数
{
public:
//纯虚函数
virtual void fun() = 0;
} ;
class Son : public Base
{
public:
virtual void fun(){}
};
4.7.4 多态案例2-制作饮品
1.茶的抽象类
class AbsDrinKing
{
public:
//1.煮水
virtual void boil() = 0;
//2.冲泡
virtual void brew() = 0;
//3.倒入杯中
virtual void pourInCup() = 0;
//4.加入辅料
virtual void putSomething() = 0;
void makeDrink()
{
boil();
brew();
pourInCup();
putSomething();
}
};
2.做咖啡
class CofferDrink : public AbsDrinKing
{
//1.煮水
virtual void boil()
{
cout<<"煮咖啡"<
3.做奶茶同理
省略···
4.制作函数
void doWork(AbsDringKing *abs)
{
abs->makeDrink();
}
4.7.5 虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
解决方式：将父类的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象的问题
- 都需要有具体的函数实现
虚析构和纯虚析构的区别：
- 如果是纯虚析构，则该类属于抽象类，无法实例化对象，而虚析构可以！
虚析构语法：
virtual 类名(){ }
纯虚析构语法:
virtual 类名() = 0;
类外还要写实现
类名：：~类名(){ }
可能出现内存泄漏
文章图片
解决办法：
1.父类析构函数加上virtual，变成虚析构
class Animal
{
public:
Animal(){cout<<"Animal 构造函数调用"<
2.纯虚析构
class Animal
{
public:
Animal(){cout<<"Animal 构造函数调用"<
总结：
- 1.虚析构和纯虚析构是用来解决 通过父类指针 释放子类对象的情况
- 2.如果子类中没有堆区数据，可以不写虚析构或者纯虚析构
- 3.拥有纯虚函数的类也属于抽象类
4.7.6 多态案例3-电脑组装
//抽象零件
//1.抽象CPU
class CPU
{
public:
virtual void cal() = 0;
};
//2.抽象显卡
class VideoCard
{
public:
virtual void display() = 0;
};
//3.抽象内存
class Memory
{
public:
virtual void storage() = 0;
} ;
//电脑类
class Computer
{
public:
Computer(CPU *cpu,VideoCard *vc,Memory * mem)
{
m_cpu = cpu;
m_vc = vc;
m_mem = mem;
cout<<"Computer 构造函数"<cal();
m_vc->display();
m_mem->storage();
}
private:
CPU *m_cpu;
VideoCard *m_vc;
Memory *m_mem;
};
//intel 电脑
class IntelCPU : public CPU
{
public:
void cal(){cout<<"Intel cpu 工作了"<doWork();
delete com1;
} int main(int argc, char** argv) {
test();
return 0;
}
5.文件操作
文件类型分为2类：
1.文本文件：文本以ASCII码形式存储在计算机中
2.二进制文件：文本以二进制形式存储在计算机中
头文件：
操作文件的三大类：
1.ofstream：写操作
2.ifstream：读操作
3.fstream：读写操作
5.1文本文件
5.1.1 写文件
写文件步骤：
1.包含头文件
#include
2.创建流对象
ofstream ofs;
3.打开文件
ofs.open("文件路径"，打开方式)
4.写数据
ofs<<"数据"；
5.关闭文件
ofs.close();
文件的打开方式：
打开方式
解释
ios::in
读
ios::out
写
ios::ate
初始位置：文件尾
ios::app
追加方式写文件
ios::trunc
如果文件存在，先删除 再创建
ios::binary
二进制形式
//文本文件 写文件
void test()
{
ofstream ofs;
ofs.open("test.txt",ios::out);
ofs<<"张三 18";
ofs.close();
}
5.1.2 读文件
读文件步骤：
1.包含头文件
#include
2.创建流对象
ifstream ifs;
3.打开文件
ifs.open("文件路径"，打开方式)
4.写数据
四种方式读取；
5.关闭文件
ifs.close();
void test()
{
ifstream ifs;
ifs.open("test.txt",ios::in);
if(!ifs.is_open())
{
cout<<"文件打开失败"<> buf)
//{
//cout<
5.2 二进制文件
以二进制的方式对文件进行读写操作，
打开方式要指定为ios::binary
5.2.1 二进制方式写文件
class Person
{
public:
char m_Name[64];
int m_age;
} ;
void test()
{
//1.引入头文件 #include //2.创建流对象
ofstream ofs;
//或者ofs("person.txt",ios::out|ios::binary);
//3.打开文件
ofs.open("person.txt",ios::out|ios::binary);
//4.写文件
Person p = {"张三",18};
ofs.write((const char*)&p,sizeof(Person));
//5.关闭文件
ofs.close();
}
5.2.2 二进制方式读文件
二进制方式读文件主要利用流对象的成员函数read
函数原型：istream& read(char *buffer,int len);
class Person
{
public:
char m_Name[64];
int m_age;
} ;
void test()
{
//1.引入头文件//2.创建流对象
ifstream ifs;
//3.打开文件
ifs.open("person.txt",ios::in);
if(!ifs.is_open())
{
cout<<"文件打开失败！"<
继续当一名咸鱼(￣︶￣)!
Stay hungry，Stay foolish！
推荐阅读
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 期刊|期刊 | 国内核心期刊之（北大核心）
- opencv|opencv C++模板匹配的简单实现
- C语言学习|第十一届蓝桥杯省赛 大学B组 C/C++ 第一场
- python青少年编程比赛_第十一届蓝桥杯大赛青少年创意编程组比赛细则
- 活跃社群的核心标准是什么（）
- VueX--VUE核心插件
- HTML基础--基本概念--跟着李南江学编程
- 我的软件测试开发工程师书单
- c++基础概念笔记
- 芯灵思SinlinxA33开发板Linux内核定时器编程