<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[LinYang_code的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/LinYang_code</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; LinYang_code]]></copyright><item><title><![CDATA[map和unordered_map]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108416598</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108416598</guid><author>LinYang_code</author><pubDate>Sat, 05 Sep 2020 10:58:55 +0800</pubDate><description><![CDATA[对map和unordered_map的概念进行区分理解：
相同点：

都是STL提供的关联式容器
放置的元素都是键值对，并且要求key是唯一的

不同点：

map是在C++98中提出的，而unordered_map是在C++11中提出
模板参数列表不同：map有比较器（默认是按照less的方法对key进行排序）unordered_map哈希函数参数（底层有默认的哈希函数）
插入方式不同：map----&gt;按照二叉搜索树先插入元素，然后对树进行调整（颜色更改+旋转处理），unordered_map---]]></description><category></category></item><item><title><![CDATA[重载、同名以及重写]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108393747</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108393747</guid><author>LinYang_code</author><pubDate>Thu, 03 Sep 2020 22:05:07 +0800</pubDate><description><![CDATA[重载概念：
重载就是在同一作用域中，函数的名字相同，但参数列表不同，参数列表不同体现在，参数的名字、参数的类型、类型的次序，与函数返回值类型是否相同无关
同名隐藏和重写：
相同点：都是在继承体系中
不同点：

同名隐藏可以是函数名相同，也可以是成员变量名相同；但是重写只能是函数名相同
对成员的要求不一样，重写对于成员的要求比较严格：对于重写来说，要求基类函数必须是虚函数，而同名隐藏不要求；其次对于函数原型来说：同名隐藏只要求基类和子类的函数名一样，而对于重写来说必须要求基类和子类的函数原型一致
可以进行举例]]></description><category></category></item><item><title><![CDATA[面向对象之---封装、继承、多态]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108381533</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108381533</guid><author>LinYang_code</author><pubDate>Thu, 03 Sep 2020 15:51:46 +0800</pubDate><description><![CDATA[在学习C++时，我们都知道C++三大特性：封装、继承、多态
今天来整体进行复习一下：
首先来看封装：
封装的概念：将数据和数据的方法进行有机结合，隐藏对象中的属性和实现细节，仅对外公开接口和对象进行交互—例如电脑的充电口
封装的实现：通过类将对象的属性和接口进行有机结合，然后通过访问权限决定各个类成员的访问权限。public、protected、private
接下来理解一下继承：
继承的概念：继承就是为了实现代码的复用以及体现C++面向对象程序设计的层次结构
继承的作用：

起到代码复用，子类可以继承父类]]></description><category></category></item><item><title><![CDATA[浅谈类和对象整体概念]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108278773</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108278773</guid><author>LinYang_code</author><pubDate>Sun, 30 Aug 2020 00:40:18 +0800</pubDate><description><![CDATA[***面向对象和面向过程的区别：
***在C++中class和struct的区别
在C++中class和struct几乎是一样的，也就是struct定义的结构体就是类
默认的访问权限不同、默认的继承权限不同
在写类模板类型的代码时，class可以出现在模板参数类表中用来声明类型，但是struct不行
***C++的三大特性：封装、继承、多态
***什么是封装？C++中是如何实现封装的特性？
封装的概念：将数据和数据的方法进行有机结合，隐藏对象中的属性和实现细节，仅对外公开接口和对象进行交互------电脑的]]></description><category></category></item><item><title><![CDATA[内联函数详解！！！]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108275938</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108275938</guid><author>LinYang_code</author><pubDate>Sun, 30 Aug 2020 00:22:10 +0800</pubDate><description><![CDATA[内联函数的概念：
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈开销，提高运行效率
为什么要有内联函数：
1.内联函数在编译时会进行替换，少了函数的压栈开销，提高运行效率
2.宏函数的缺点：在预处理时展开了，因此不会进行参数类型检测，并不能进行调试，实现要求严格（参数要求带括号）
内联函数和宏函数的区别：
C++中有哪些方式可以替代宏：
1.宏常量：const类型的常量来进行替换，因为在C++中，被const修饰的变量是常量，const修饰的变量在编译期间会]]></description><category></category></item><item><title><![CDATA[引用&指针]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108274681</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108274681</guid><author>LinYang_code</author><pubDate>Sun, 30 Aug 2020 00:12:39 +0800</pubDate><description><![CDATA[引用的概念：不是新定义一个变量，而是给已存在的变量取个别名，它和引用的尸体共用一块内存空间。
引用的特性：
1.引用在定义时必须初始化（要存在引用的实体）
2.一个实体可以有多个引用
3.引用一旦引用一个实体，再不能引用其他实体
引用的分类：
1.普通类型的引用：可以通过引用修改其引用的实体
2.const类型的引用：主要在函数传参时使用的比较多
引用的应用场景：
1.按照概念，直接给实体取别名，让代码书写更加简单，比如—在学生结构体S中又套了一个T结构体，T中有一个整形常量a，想要引用a，就可以给其取一个]]></description><category></category></item><item><title><![CDATA[C++函数重载]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108274194</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108274194</guid><author>LinYang_code</author><pubDate>Sun, 30 Aug 2020 00:05:31 +0800</pubDate><description><![CDATA[函数重载知识点复习
函数重载的概念：在相同的作用域，函数名字相同，参数列表必要不同，这个不同体现在：参数的类型或参数的额个数或类型的次序，注意：与函数返回值类型是否相同无关
函数重载的调用原理：
1.在编译阶段，编译器会对实参的类型 进行推演，根据推演的结果选择合适的函数进行调用
2.如果在工程中找到对应类型的重载函数，则直接调用。
3.如果没找到，编译器会尝试进行隐式类型转化，如果隐式类型转化后有合适的函数调用，则直接调用，否则，编译失败。
函数重载的实现原理：主要是取决于编译器对函数名的修饰规则。
1.]]></description><category></category></item><item><title><![CDATA[顺序表和链表的区别]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/108286394</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/108286394</guid><author>LinYang_code</author><pubDate>Fri, 28 Aug 2020 20:36:48 +0800</pubDate><description><![CDATA[复习了数据结构后，发现，顺序表和链表的区别是一个非常重要的概念
接下来详细讲解一下：
1.存储数据的结构：顺序表：底层采用连续的地址空间
链表：底层采用链式结构
2.随机访问：顺序表支持随机访问
链表不支持随机访问
3.插入和删除：顺序表一般的的插入和删除需要搬移大量的元素，尾插和尾删不需要搬移元素，并且当插入元素时要考虑是否扩容问题，时间复杂度为O(n)
链表的插入和删除不需要搬移元素，只需要修改一下指针的指向，不需要考虑扩容问题，时间复杂度为O(1)
4.元素查找方面：两个的效率是一样的，时间复杂度为O]]></description><category></category></item><item><title><![CDATA[数据库索引和事务理解]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107933881</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107933881</guid><author>LinYang_code</author><pubDate>Tue, 11 Aug 2020 14:15:25 +0800</pubDate><description><![CDATA[在我学习数据库时，有两个概念是非常重要的，在面试中很有可能被问到：
就是索引和事务的概念。
一、索引
通俗理解一下，我们每本书都有一个目录，通过这个目录我们很快的可以找到自己需要的某一章节，那么在数据库中就有一个索引，索引可以帮我们快速的找到数据的位置，提高数据海量数据的查询效率。
索引概念：索引是一种特殊的文件，包含着对数据表里所有记录的引用指针。可以对表中的一列或多列创建索引，并指定索引的类型，各类索引有各自的数据结构实现。
索引的作用：

数据库中的表、数据、索引之间的关系，类似于书架上的图书、书籍内]]></description><category></category></item><item><title><![CDATA[mysql免密登录出现2003错误]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107933570</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107933570</guid><author>LinYang_code</author><pubDate>Tue, 11 Aug 2020 13:48:07 +0800</pubDate><description><![CDATA[昨天把防火墙恢复了默认，导致好多程序无法连接，比如mysql数据库。
我的启动服务器没有问题，但接下来使用免密登录：
mysql -uroot;//免密登录

报错了，错误码2003。。。。。。。。。。。

这里我们发现并不是服务器未启动的原因，并且我也反复试了重新开启，都无法成功。
后来发现是因为防火墙设置问题，默认阻止了3306端口。而mysql的默认端口号就是3306,。
于是在win7系统下，我打开防火墙里的3306端口就解决了。
过程如下：







这样就解决啦！！！！

...]]></description><category></category></item><item><title><![CDATA[线程安全的单例模式]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107871659</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107871659</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 22:36:09 +0800</pubDate><description><![CDATA[何为单利模式和设计模式
单例模式：就是是一经典的、常见的、常考的设计模式
设计模式：根据一些经典常见的场景，给定了一些解决办法，这就是设计模式
分类
饿汉模式（空间换时间）：不考虑线程安全问题—&gt;在程序初始化阶段就完成资源申请初始化
代码！！！！
template &lt;typename T&gt;
class Singleton {
 static T data;
public:
 static T* GetInstance() {
  return &amp;data;
}
};

懒汉模式（时]]></description><category></category></item><item><title><![CDATA[死锁和银行家算法的理解]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107871451</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107871451</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 22:21:01 +0800</pubDate><description><![CDATA[死锁的概念：死锁是指一组进程中的各个进程都占有不会释放的资源，但因相互申请其他进程不会释放的资源而处于一种永久等待状态。（请求与保持 和 循环等待撞在一块）
请求与保持通俗来讲：我加了A，然后去加B，如果不能加B，我也不释放A
循环等待通俗来讲：我加了A锁，然后去加B锁，对方加了B锁，对方想加A锁。（加锁顺序不当）
这样就陷入了一个回路，死锁就产生了。
产生死锁的条件（四个缺一不可）
1.互斥条件：一个资源每次只能被一个执行流使用
2.不可剥夺条件：一个执行流在未释放资源之前，不能强行剥夺
3.请求与保持：]]></description><category></category></item><item><title><![CDATA[线程安全与同步互斥]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107871403</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107871403</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 22:08:03 +0800</pubDate><description><![CDATA[线程安全的实现：同步与互斥
同步：通过条件判断实现对资源访问的合理性
互斥：通过同一时间只有一个执行流能够访问资源，实现资源访问的安全性
互斥的实现—&gt;互斥锁
互斥锁概念：就是一个 只有0/1的计数器，描述临界资源的两种访问状态（可访问/不可访问），一个执行流在访问期间需要将资源状态标记为不可访问，访问完毕后，将状态标记为可访问，这些访问同一临界资源的执行流都要在访问资源之前，先去访问互斥锁判断访问状态
过程
1.定义互斥锁变量：pthread_mutex_t mutex = PTHREAD_MUTE]]></description><category></category></item><item><title><![CDATA[线程的创建、终止、等待和分离]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107871270</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107871270</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 22:03:48 +0800</pubDate><description><![CDATA[线程控制：包括线程的创建、终止、等待和分离
一、线程创建
操作系统并没有提供创建线程的系统调用接口，通过库函数创建线程，其实是创建了一个用户态线程，并在内核中创建了一个轻量级进程pcb实现线程的调度
pthread_create函数
功能：创建一个新的线程
原型
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *
(*start_routine)(void*), void *arg);
参数
thread:返回线程]]></description><category></category></item><item><title><![CDATA[进程与线程]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107870597</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107870597</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 21:32:26 +0800</pubDate><description><![CDATA[在学习Linux时，遇到了进程和线程的概念，总是分不清楚，经过学习研究后，将自己的总结写出啦
在学习进程时，认为进程是pcb，pcb是操作系统对程序运行动态的描述，通过pcb实现对程序运行的调度管理；
在学习线程时，认为pcb是一个轻量级进程，是一个运行中程序的一条执行流。
我们在Linux中使用pcb实现了进程中的执行流，一个进程可以有多个pcb，也就是可以有多个执行流，创建线程就是在内核中创建一个pcb作为一条执行流，来实现程序的运行调度管理。
所以：
进程的概念：进程是操作系统对程序运行动态的描述，在]]></description><category></category></item><item><title><![CDATA[Linux下信号的生命周期]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107859448</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107859448</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 12:04:55 +0800</pubDate><description><![CDATA[信号概念理解：信号就是一种中断，通知我们发生了某件事情，打断我们当前的操作，让我们去处理这个事情。信号能够通知事件的发生，进程必须能够识别这个信号，并且信号与事件一一对应
查看信号：kill -l
信号的分类：62种
非可靠信号：1~31信号，从Unix就有的信号，每个信号在系统中都有对应的事件，不可靠的，有可能会丢失的事件
可靠信号：34~64信号，后来扩充的32种信号，扩充定义的时候并没有具体对应的事件，可靠的不会丢失的事件
信号的生命周期，有四个阶段：信号的产生–&gt;信号的注册–&gt;信号的注销]]></description><category></category></item><item><title><![CDATA[进程间通信方式的理解]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107852476</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107852476</guid><author>LinYang_code</author><pubDate>Fri, 07 Aug 2020 00:17:27 +0800</pubDate><description><![CDATA[首先来讲解一下有关此的概念理解
进程间通信的原因：因为进程间具有独立性，每个进程都有自己的独立虚拟地址，访问的都是虚拟地址，因此无法直接访问，所以需要操作系统给进程间提供通信方式
进程间通信的目的：
1.数据传输：一个进程需要将它的数据发送给另一个进程
2.资源共享：多个进程之间共享同样的资源。
3.通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件（如进程终止时要通知父进程）。
4.进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程]]></description><category></category></item><item><title><![CDATA[文件系统]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107848686</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107848686</guid><author>LinYang_code</author><pubDate>Thu, 06 Aug 2020 20:37:04 +0800</pubDate><description><![CDATA[我们先来看一下Linux下的磁盘分区：

磁盘中的分区：
swap：作为交换内存使用。
filesystem：文件系统分区，用于文件存储，文件系统分区可以有多个，各自有各自的文件系统
由此引入了文件系统这个概念：用于磁盘中文件管理的系统，称为Linux ext2文件系统。
磁盘文件系统图：

创建一个inode{包含文件的大小、权限信息、实践属性、数据地址、文件元信息}
文件系统的参数介绍：
Block Group：ext2文件系统会根据分区的大小划分为数个Block Group。而每个Block Grou]]></description><category></category></item><item><title><![CDATA[进程创建、终止和等待]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107837317</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107837317</guid><author>LinYang_code</author><pubDate>Thu, 06 Aug 2020 13:40:27 +0800</pubDate><description><![CDATA[首先我们来看一下进程的创建，有两种方式：fork( )和vfork( )
**fork( )：**代码共享，数据独有，是写时拷贝技术
代码共享：代码是只读的，不能发生改变
数据独有：某一块物理内存中的数据即将发生改变，则给子进程数据重新开辟物理空间，将数据拷贝过来
写时拷贝技术：子进程创建出来后，各个虚拟地址在物理内存中的指向完全与父进程相同，提高子进程的创建效率
**返回值：**子进程返回0；父进程返回子进程的pid
**vfork( )：**父子进程共用虚拟地址空间，父进程阻塞，避免调用栈混乱
int ]]></description><category></category></item><item><title><![CDATA[操作系统的内存管理方式]]></title><link>https://blog.youkuaiyun.com/LinYang_code/article/details/107836618</link><guid>https://blog.youkuaiyun.com/LinYang_code/article/details/107836618</guid><author>LinYang_code</author><pubDate>Thu, 06 Aug 2020 12:40:49 +0800</pubDate><description><![CDATA[操作系统的内存管理方式有三种：分段式、分页式、段页式。
首先介绍分段式：
**概念：**将地址空间进行分段，代码段/数据段/堆/栈/参数/环境变量。根据使用一个空间的性质，在不同的分段，分配虚拟地址，有助于编译器内存管理
**虚拟地址组成：**段号+段内偏移量
**过程：**在操作系统中，有一个段表，段表中包含：虚拟段号+物理内存段起始地址，通过虚拟地址中的段号，在段表中找到相应的段表项，得到物理起始地址，加上段内偏移量最终得到物理地址。

分页式：
**虚拟地址的组成：**页号+页内偏移量
**过程：**]]></description><category></category></item></channel></rss>