<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[m0_63089723的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/m0_63089723</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; m0_63089723]]></copyright><item><title><![CDATA[【无标题】基于Huffman和LZ77的GZIP压缩]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/126206045</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/126206045</guid><author>m0_63089723</author><pubDate>Sun, 07 Aug 2022 08:49:39 +0800</pubDate><description><![CDATA[Gzip压缩]]></description><category></category></item><item><title><![CDATA[基于TCP的聊天系统]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/126068536</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/126068536</guid><author>m0_63089723</author><pubDate>Fri, 05 Aug 2022 19:33:55 +0800</pubDate><description><![CDATA[基于TCP的聊天系统]]></description><category></category></item><item><title><![CDATA[多种智能指针]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/125519682</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/125519682</guid><author>m0_63089723</author><pubDate>Wed, 29 Jun 2022 12:55:38 +0800</pubDate><description><![CDATA[智能指针的作用实现原理加指针指针的种类]]></description><category></category></item><item><title><![CDATA[线程安全----＞互斥]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/124255440</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/124255440</guid><author>m0_63089723</author><pubDate>Mon, 18 Apr 2022 17:55:24 +0800</pubDate><description><![CDATA[线程安全
	什么是线程不安全
		1.多个线程并行或者并发运行时,会导致结果的二义性
		2.假设有两个线程,线程A和线程B有一个cpu.同时++
		
	怎么解决二义性
		互斥锁
		
	线程不安全的代码演示
		例子:内存-&gt;寄存器-&gt;cpu-&gt;寄存器-&gt;内存,这个过程没有原子性,不能一步执行完,可能会被打断...存在二义性,所以就存在线程不安全.线程A刚拿到一个全局变量100,放在寄存器里.还没到写回内存这一步,被剥离处来了.线程B在内存里拿的话还是100,--之后是99,但]]></description><category></category></item><item><title><![CDATA[qsort和sort的比较器]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/124182667</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/124182667</guid><author>m0_63089723</author><pubDate>Thu, 14 Apr 2022 22:23:57 +0800</pubDate><description><![CDATA[c语言的qsort函数包含头文件#include&lt;stdlib.h&gt;

函数原型:void qsort(void*base,size_t num,size_t size,int(*cmp)(const void*,const void *))

base:待排序的数组

num:数组长度

size:数组元素的大小

注意:qsort函数的参数必须是void*,必须是void*,必须是void*




#include&lt;stdio.h&gt;
#include&lt;stdlib.h&.]]></description><category></category></item><item><title><![CDATA[c++ list]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/124177204</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/124177204</guid><author>m0_63089723</author><pubDate>Thu, 14 Apr 2022 17:27:11 +0800</pubDate><description><![CDATA[迭代器失效:erase会导致失效,resize()把list的长度减少,可能就会失效..解决方式就是用之前重新赋值
	底层为非连续空间,erase之后当前迭代器失效,但是后面的迭代器不会失效
	list的构造和析构
	list( ) | list(size_t n,const T&amp; value=T()) | list(const list&lt;T&gt;&amp; L) | list(Iterator first,Iterator last) | list&lt;int&gt; L{1,2,3,5]]></description><category></category></item><item><title><![CDATA[linux--＞多线程]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/124155918</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/124155918</guid><author>m0_63089723</author><pubDate>Wed, 13 Apr 2022 19:39:40 +0800</pubDate><description><![CDATA[线程概念
	进程中的主线程在执行代码,执行流.
	线程只是在进程虚拟地址空间中拥有相对独立的一块空间,线程包含cpu现场，但是线程只是进程中的一个执行流,进程是资源分配的基本单位，线程是调度的基本单位,每个线程在进程虚拟地址空间中拥有独立的栈空间,线程有自己的独立栈空间且共享数据,,,由于线程没有独立的地址空间.进程比线程安全的原因是每个进程由独立的虚拟地址空间，具有独立性
	同一个进程中线程的切换不会引起进程的切换,由一个进程的线程切换到另一个线程的进程时才引起进程的切换
	其中有一个主线程来调用本进程中]]></description><category></category></item><item><title><![CDATA[c++---＞string的细节加模拟实现string]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123999544</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123999544</guid><author>m0_63089723</author><pubDate>Wed, 06 Apr 2022 20:48:59 +0800</pubDate><description><![CDATA[namespace A
{
	class string
	{
	public:
		//迭代器
		typedef char* iterator;//string里的迭代器本质指针,以后迭代器就不一定是指针了
		typedef const char* const_iterator;//const类型的迭代器
		const_iterator begin()const
		{
			return _str;
		}
		iterator begin()
		{
			return _str;
		}
...]]></description><category></category></item><item><title><![CDATA[[c++]new和malloc的细节]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123837916</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123837916</guid><author>m0_63089723</author><pubDate>Wed, 30 Mar 2022 09:23:19 +0800</pubDate><description><![CDATA[New和malloc的区别
	new是操作符，malloc是函数
	New不需要包含头文件,不需要判空,不用强转,new出来的空间直接初始化
	在类里:Malloc不会调构造,只是开辟一块类类型大小的空间,free也不会调用析构.new会调构造函数,指针会指向堆上的一个对象.delete会调析构
	New里调用了malloc,如果没申请成功,会循环申请.
	New先调用operator new函数,这个函数里调用了malloc,申请成功后返回指针,然后调用类的初始化函数,这是申请一个类.要是申请多个类,调用]]></description><category></category></item><item><title><![CDATA[进程信号的深度剖析]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123773909</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123773909</guid><author>m0_63089723</author><pubDate>Sun, 27 Mar 2022 23:47:39 +0800</pubDate><description><![CDATA[1.信号量概念

	临界资源:供多个进程访问的资源(例如:管道,共享内存,消息队列)
	临界区:访问临界资源时的代码
	信号量:本质是资源计数器(资源计数器为1表示可以访问,为0表示不能访问)
		互斥访问:同一个时刻,多个进程当中只有一个进程可以访问临界区资源
		多个进程通过信号量保证互斥的时候需要先获取信号量,如果能够获取信号量,才能访问支援,如果获取不了,则阻塞等待.
		如果不互斥访问导致的结果:复习:(程序计数器(保存下一步执行的指令),上下文信息(保存寄存器中的内容))会产生二义性:如果两..]]></description><category></category></item><item><title><![CDATA[所有的运算符重载]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123701909</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123701909</guid><author>m0_63089723</author><pubDate>Thu, 24 Mar 2022 08:54:30 +0800</pubDate><description><![CDATA[class Date
{
	friend ostream&amp; operator&lt;&lt;(ostream&amp; _cout, const Date&amp; d);  //设置&lt;&lt;重载运算符为友元函数
public:
	//获取某年是不是闰年
	bool GetYear(int year)
	{
		if ((year % 4 == 0 &amp;&amp; year % 100 != 0) || year % 400 == 0)
		{
			return true;
		}.]]></description><category></category></item><item><title><![CDATA[c++类和对象-----成员函数和注意事项]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123647232</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123647232</guid><author>m0_63089723</author><pubDate>Mon, 21 Mar 2022 22:53:13 +0800</pubDate><description><![CDATA[1.c++类里默认生成的成员函数(特性:用户没有定义,编译器自动生成)

	构造函数:
		1. 函数名与类名相同。
		2. 无返回值。
		3. 对象实例化时编译器自动调用对应的构造函数。
		4. 构造函数可以重载。
		5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成.
		6.用户自定义的构造函数可以有参数也可以没有参数,无参的构造函数和全缺省的构造函数都称为默认构造函数(编译器自己能调用)，并且默认构造函数只能有一个。注意：..]]></description><category></category></item><item><title><![CDATA[进程间通信 消息队列基础]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123585880</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123585880</guid><author>m0_63089723</author><pubDate>Sat, 19 Mar 2022 21:25:34 +0800</pubDate><description><![CDATA[1.消息队列的介绍

1.1消息队列是采用链表的形式实现的队列,该链表由系统内核进行维护

1.2系统中[有很多个消息队列,每个消息队列用消息队列描述符(消息队列的ID:qid)来区分,qid是唯一的,用来区分不同的消息队列

1.3在进行进程间通信的时候,一个进程将消息加到队列的尾端,另一个进程从队列头部读(不一定是只能读取队列的头部消息,只是从头部开始读,通俗来讲就是从头部开始往下挑)

2.消息队列的接口函数

2.1创建消息队列



key:消息队列的标识符

msgflg:创建的标志,例如 IP]]></description><category></category></item><item><title><![CDATA[c实现力扣95题(不同的搜索二叉树)]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/121877881</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/121877881</guid><author>m0_63089723</author><pubDate>Thu, 17 Mar 2022 19:21:47 +0800</pubDate><description><![CDATA[二叉树递归的基本思想:无论什么二叉树都先看作是只有根左右三个节点,先找出对这三个节点的操作规律,然后再递归.


]]></description><category></category></item><item><title><![CDATA[内联函数的用法,,,auto注意事项]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123477027</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123477027</guid><author>m0_63089723</author><pubDate>Mon, 14 Mar 2022 14:42:58 +0800</pubDate><description><![CDATA[以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压

栈的开销， 内联函数提升程序运行的效率。




inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜 使用作为内联函数。 




inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等 等，编译器优化时会忽略掉内联。




1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add(这个就]]></description><category></category></item><item><title><![CDATA[进程间通信(命名管道)(共享内存)]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123435631</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123435631</guid><author>m0_63089723</author><pubDate>Sat, 12 Mar 2022 22:45:38 +0800</pubDate><description><![CDATA[1.命名管道

1.1,命名管道的创建


命令创建命名管道:mkfifo+命名管道的文件名



函数创建:int mkfifo(const char *pathname,mode_t mode);


参数:pathname:要创建的命名管道文件的路径以及文件名

mode:命名管道文件的权限,八进制数组(例如0644)0是八进制数的起手式

特点:升级了匿名管道,支持不同进程间通信,不再依赖亲缘关系.

命令创建和函数创建都是生成一个文件,这个文件就能代表内核里的缓冲区.

代码验证:

生成代表管道]]></description><category></category></item><item><title><![CDATA[预处理编译汇编链接(程序运行过程中的细节)]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123348051</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123348051</guid><author>m0_63089723</author><pubDate>Wed, 09 Mar 2022 23:15:55 +0800</pubDate><description><![CDATA[1.预处理过程

2主要处理那些源代码文件中的以“#”开始的预编译指令。如“#include”、“#define”等，主要处理规则如下:
将所有的“#define”删除，并且展开所有的宏定义。
处理所有条件预编译指令，比如“#if”、“#ifdef”、“#elif”、“#else”、“#endif”
处理“#include”预编译指令，将被包含的文件插入到该预编译指令的位置。注意，这个过程是递归进行的，也就是说被包含的文件可能还包含其他文件。
删除所有的注释“//”和“/* */”。
添加行号和文件名标识，]]></description><category></category></item><item><title><![CDATA[页表和多级页表]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123321577</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123321577</guid><author>m0_63089723</author><pubDate>Tue, 08 Mar 2022 09:19:47 +0800</pubDate><description><![CDATA[我们在c和c++里看到的地址都是操作系统虚拟出来的,%p打印出来的也是虚拟地址,物理内存由操作系统统一管理.操作系统负责把虚拟地址映射到物理内存.

那么为什么要用到虚拟内存呢:

1,因为如果每个进程都访问物理内存的话,造成不可控性.如果进程有访问内存的权力,他就会把自己的数据存到内存上,但是他并不知道哪片内存被使用,那一片未被使用.所以在多个进程的情况下,数据会混乱,所以物理内存由操作系统管理,进程没有权限访问.

2,操作系统并不能预先知道这个进程有多大,这个进程运行多少时间,应该给他分配多少空间(如]]></description><category></category></item><item><title><![CDATA[文件流指针和文件描述符]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123302874</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123302874</guid><author>m0_63089723</author><pubDate>Sun, 06 Mar 2022 21:26:44 +0800</pubDate><description><![CDATA[1.文件流指针和文件描述符的产生

fopen函数打开文件成功后会返回文件流指针,open函数打开文件成功后返回的是文件描述符.他俩的相同点是通过文件流指针和文件描述符都可以对文件进行操作.

2.fopen函数和open函数的介绍

fopen函数(库函数)



path:带有的路径的文件名,如果没有路径默认在当前文件下.

mode:

'r' 只读方式打开，将文件指针指向文件头，如果文件不存在，则返回空。
'r+' 读写方式打开，将文件指针指向文件头，如果文件不存在，则返回空。
'w' 写入方式打开]]></description><category></category></item><item><title><![CDATA[进程间通信(匿名管道)pipe函数]]></title><link>https://blog.youkuaiyun.com/m0_63089723/article/details/123287202</link><guid>https://blog.youkuaiyun.com/m0_63089723/article/details/123287202</guid><author>m0_63089723</author><pubDate>Sat, 05 Mar 2022 09:49:04 +0800</pubDate><description><![CDATA[1.进程间通信简单来说就是让两个或者两个以上的进程能够相互交换数据

2.一般的进程是独立的,一个进程的PCB(struct task_struct结构体)也叫进程控制块里只保存了本进程的信息,虚拟地址空间通过页表映射的物理内存也是只有自己通过操作系统能访问到,他只是能访问到,他自己是不知道数据存储在物理内存的什么位置.而操作系统只会让他访问到属于他自己的空间,不会让他访问到别的进程所保存的数据的地方.

3.为了让进程之间能交流,就有了管道,下面是有关管道的介绍



1.管道符号 | ;

管道的本质是]]></description><category></category></item></channel></rss>