<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[tusdddd的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/tusdddd</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; tusdddd]]></copyright><item><title><![CDATA[Socket]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/114701794</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/114701794</guid><author>tusdddd</author><pubDate>Fri, 12 Mar 2021 17:40:23 +0800</pubDate><description><![CDATA[套接字Socket
套接字用于两个进程之间互相通信，与其他所有进程间通信方式不同的是，这两个进程可以分别位于两台不同的用网络连接的计算机。同时，Socket也可以用来连接同一台计算机上的两个进程。
套接字使用流程
首先，服务器应用会使用Socket()创建一个套接字，它是系统分配给该服务器进程的类似文件描述符的资源，不能与其他进程共享。接下来，服务器进程会给套接字起个名字。本地套接字的名字是Linux文件系统中的文件名，一般放在/tmp或/usr/tmp中。对于网络套接字，它的名字是与客户端连接的特定网络有]]></description><category></category></item><item><title><![CDATA[IPC]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/114404297</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/114404297</guid><author>tusdddd</author><pubDate>Fri, 05 Mar 2021 17:18:15 +0800</pubDate><description><![CDATA[进程之间的通信(System V IPC)
在系统运行的过程中，常常需要让多个进程互相通信。实现这样功能的方式有很多种，例如文件锁和管道，这里介绍一组由Linux系统提供的机制，称为System V IPC。这一组机制中包含了三种方式，他们分别是信号量，共享内存和消息队列。
信号量
信号量用来实现系统资源的互斥访问，这里讲的是进程之间的资源互斥访问，线程之间的互斥访问不能使用这样的方式，关于如何使用线程之间的信号量，可以看[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pZE6]]></description><category></category></item><item><title><![CDATA[管道通信]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/114298491</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/114298491</guid><author>tusdddd</author><pubDate>Wed, 03 Mar 2021 08:01:47 +0800</pubDate><description><![CDATA[管道通信
进程之间可以互相交换数据，其工作方式是通过管道来实现。在Linux环境中，很多时候可以使用管道符|来让不同进程之间通过管道通信。例如命令ls | cat。这个命令使命令ls的标准输出内容通过管道传达给cat命令的标准输入。
C标准管道操作
C语函数库&lt;stdio.h&gt;中提供了比较高级的函数来打开和关闭管道，它们是：
#include &lt;stdio.h&gt;
FILE * popen(const char * command, const char * open_mode);
i]]></description><category></category></item><item><title><![CDATA[POSIX线程]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/112838425</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/112838425</guid><author>tusdddd</author><pubDate>Tue, 19 Jan 2021 15:22:51 +0800</pubDate><description><![CDATA[POSIX线程
有时候一个应用程序可能需要同时执行多个任务，但是这几个任务又相互协作，需要共享一些数据。这个时候就适合使用多线程来编写程序。线程是任务粒度划分中比进程更小的单元，两个线程可以属于同一个进程，并且两个线程可以同时执行。因为创建线程的目的只是让程序可以同时做多件事情，所以组成一个线程所需的资源只需要能让他正确执行即可，也就是说一个线程所需的资源是足够自己运行的最少资源。所以创建一个线程所需要的系统开销比创建一个进程小很多，并且由于线程之间共享程序的全局变量，所以线程之间更方便相互协作。基于上面的]]></description><category></category></item><item><title><![CDATA[处理信号]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/112055472</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/112055472</guid><author>tusdddd</author><pubDate>Thu, 31 Dec 2020 20:32:38 +0800</pubDate><description><![CDATA[处理信号
信号是在程序运行过程中系统突然发生一些特殊事件时，用来通知正在运行的程序的手段。例如当shell中有一个程序正在运行时，用户突然按下了ctrl + C，系统就会想正在运行的程序发送SIGINT信号，该信号表示一个中断。系统用这种方式告诉正在运行的程序，当前正发生的一些事件，便于程序对这些突发时间进行处理。
信号的定义在头文件signal.h中，其中常用的有：




信号
含义




SIGABORT
进程异常终止


SIGALRM
超时警告


SIGFPE
浮点运算异常


SIGHUP
]]></description><category></category></item><item><title><![CDATA[C语言创建子进程]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111936284</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111936284</guid><author>tusdddd</author><pubDate>Tue, 29 Dec 2020 20:12:16 +0800</pubDate><description><![CDATA[C语言创建子进程
程序运行的时候，可以创建与自己关联的子进程，创建了这个子进程之后，可以选择等待这个子进程执行完毕，也可以让子进程与自己并行执行，还可以终止自己转而执行子进程。这些操作都是通过一系列相似而又有细微区别的库函数来实现。下面对这些可以使用的库函数进行介绍。
system()
它的函数定义如下：
#include &lt;stdlib.h&gt;

int system(const char * string);

这个进程会在系统中另外启动一个shell，并在新的shell中执行参数string]]></description><category></category></item><item><title><![CDATA[调试程序]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111873770</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111873770</guid><author>tusdddd</author><pubDate>Mon, 28 Dec 2020 20:01:04 +0800</pubDate><description><![CDATA[调试程序
在Linux环境下编程时，系统提供了调试程序的工具，也可以设置断点，从而查看程序在运行中的状态。Linux下最常用的调试工具就是gdb，此外还有一些另外的调试工具，例如断言和内存调试。
用gdb调试程序
这里使用一个有问题的排序算法实现来演示用gdb调试程序的过程，其排序算法的代码如下：
#include &lt;stdio.h&gt;

typedef struct{
	//不能使用char * data;
	char data [4096];
	int key;
} item;

item a]]></description><category></category></item><item><title><![CDATA[Makefile基础]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111795079</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111795079</guid><author>tusdddd</author><pubDate>Sun, 27 Dec 2020 13:58:13 +0800</pubDate><description><![CDATA[Makefile基础
当一个应用程序有很多源文件的时候，因为源文件之间存在互相依赖，所以在编译的时候必须要按照一定的先后顺序来进行。手动编译这些源文件太过繁琐，且容易出错。所以Makefile就是定义了源文件编译行为的文件，有了Makefile文件，在执行make命令的时候，系统就会自动寻找Makefile文件，并按照文件中定义的行为对源文件进行编译。
一个Makefile文件由两个主要组成部分，它们分别是目标和规则。目标表示编译过程中的一个编译步骤，通常会生成一个文件，但也有例外。规则则是达到该目标要进行]]></description><category></category></item><item><title><![CDATA[文件锁定]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111632629</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111632629</guid><author>tusdddd</author><pubDate>Thu, 24 Dec 2020 15:21:08 +0800</pubDate><description><![CDATA[文件锁定
当多个进程需要同时操作一个文件的时候，为了互相协调，防止出现文件不一致的情况，就需要使用系统提供的文件锁定特性。
创建锁文件
创建锁文件的方式类似操作系统中的二进制信号量机制。这个锁文件是一个空文件，它的作用仅仅是作为一个标志，表示当前有一个进程正在使用文件。
注意这种机制只是一种建议锁，而不是强制锁。一个应用程序在明知道锁文件存在(有一个进程正在访问文件)的时候还是可以强行访问文件，这种行为不会引起程序异常，但是会使文件混乱。这种进程之间的协调需要程序员来完成。
因为这个锁文件是用来控制进程之间]]></description><category></category></item><item><title><![CDATA[文件处理]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111597497</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111597497</guid><author>tusdddd</author><pubDate>Wed, 23 Dec 2020 19:39:45 +0800</pubDate><description><![CDATA[底层文件访问
每个进程都会有一些自己的文件描述符，这些文件描述符表示当前进程正在操作的文件。在一个进程打开一个文件的时候，实际上就是在自己的文件表中创建该文件的文件描述符，创建文件描述符之后，可以通过该描述符对文件进行操作。
当一个程序开始运行的时候，一般都会有三个默认存在的文件描述符。他们分别是：

0：标准输入
1：标准输出
2：标准错误

write系统调用
系统调用write的作用是把缓冲区buf的前nbytes个字节写入与文件描述符fildes关联的文件，并返回实际写入的字节数。如果函数返回0，表]]></description><category></category></item><item><title><![CDATA[选项处理]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111588024</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111588024</guid><author>tusdddd</author><pubDate>Wed, 23 Dec 2020 13:27:58 +0800</pubDate><description><![CDATA[程序参数
当我们用C语言写好一个程序并成功编译出可执行的二进制文件之后，可以通过终端进行调用。并且在调用的时候，通常会传入一些参数，这些传入的参数会被存储到一个字符串数组中，并且该数组会被作为main()函数的参数，以便程序对这些参数进行处理。例如
int main(int argc, char *argv[]){
	for(int i = 0; i &lt; argc; i++){
		printf("%s\n", argv[i]);
	}
	return 0;
}

这个main函数中有两个参数，第一个]]></description><category></category></item><item><title><![CDATA[ShellProgramming]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111498485</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111498485</guid><author>tusdddd</author><pubDate>Mon, 21 Dec 2020 20:35:55 +0800</pubDate><description><![CDATA[这个文档用于记录自己在学习shell编程时的一些心得，还有一个示例以及对其的解读，以便日后的查阅。
文件基本结构
一个完整的shell文件中可能有的部分为：

#!/bin/sh，第一行的这个命令告诉系统应该用哪个程序来运行这个shell文件。
代码，shell程序将要执行的代码部分
注释，注释以#开头，#的后面皆为注释内容

shell中的变量
在shell中定义变量的格式为：
var1="Hello"
var2=13

代码第一行定义了一个var1变量，并将其赋值为Hello，第二行则定义了一个var2]]></description><category></category></item><item><title><![CDATA[vim命令]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/111315946</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/111315946</guid><author>tusdddd</author><pubDate>Thu, 17 Dec 2020 15:12:16 +0800</pubDate><description><![CDATA[vim命令
学习vim的时候找到的一个文档，存一下
			       Lesson 1 SUMMARY


  1. The cursor is moved using either the arrow keys or the hjkl keys.
	 h (left)	j (down)       k (up)	    l (right)

  2. To start Vim from the shell prompt type:  vim FILENAME &lt;ENTER&gt;

  3. To]]></description><category></category></item><item><title><![CDATA[友元]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110849855</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110849855</guid><author>tusdddd</author><pubDate>Tue, 08 Dec 2020 09:01:07 +0800</pubDate><description><![CDATA[友元
对于一个类来说，类外部的对象想要访问类中的private成员只有通过公共访问函数来实现。这在有些时候会很不方便，这个时候就可以使用友元的方式使一些特定的外部对象也能访问类内的private成员。友元分为三种，分别为友元函数，友元类和友元成员函数。
友元函数
如果一个类将一个函数声明为自己的友元函数，则表示该函数能够直接访问本类中的私有成员。声明函数为友元函数在类的声明中完成，而函数的定义跟普通函数一样，不需要额外修改。并且同一个函数可以同时是多个类的友元函数，例如：
class Fractor;	//]]></description><category></category></item><item><title><![CDATA[模板类]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110825171</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110825171</guid><author>tusdddd</author><pubDate>Mon, 07 Dec 2020 19:08:10 +0800</pubDate><description><![CDATA[模板类
跟之前介绍过的模板函数类似，模板类并不是一个类，而是像编译器解释了如何生成一个类。所以，声明一个模板类的时候是不会占用内存的，只有在将模板具体化，形成真正可以使用类时，才会为该类分配内存。
基本语法
template &lt;typename T&gt;
class stack{
	private:
		static int num = 0;	
		int cap;
		T * st;
};

注意，当类模板中存在静态变量的时候，并不是所有由该模板初始化出来的类都共享这一个变量。而是所有由相同参数具]]></description><category></category></item><item><title><![CDATA[多重继承]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110640303</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110640303</guid><author>tusdddd</author><pubDate>Fri, 04 Dec 2020 14:39:21 +0800</pubDate><description><![CDATA[多重继承
多重继承就是一个派生类同时继承多个基类，同样也分为公有继承，私有继承和保护继承三种，这三种继承可以实现的关系跟单继承一样，但是多重继承会带来很多新的问题，这里以公有继承为例：
假设我们要实现下面的继承关系：

这会带来一个问题。前面说到，使用单继承的时候，派生类之中会有一个基类，派生类只是在基类的数据上额外增加了一些数据。也就是说每一个从基类派生出来的派生类对象都会维护一个基类对象，这就是问题所在。在上面的继承关系中，Worker和Adult都继承了同一个基类，而Singer同时继承了Worker]]></description><category></category></item><item><title><![CDATA[多态继承11]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110630071</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110630071</guid><author>tusdddd</author><pubDate>Fri, 04 Dec 2020 10:29:08 +0800</pubDate><description><![CDATA[多态继承
多态继承是C++中实现代码重用的一个重要方法。例如最刚开始的时候定义了一个基础类Base：
class Base{
	private:
		string name;
	public:
		Base(string n): name(n){}
		void show(){
			cout &lt;&lt; "Using base function: " &lt;&lt; name &lt;&lt; endl;
		}
};

这个类只是实现了最基本的功能，但是如果临时想为该类添加一个新的功能，就要在B]]></description><category></category></item><item><title><![CDATA[多态继承]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110499406</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110499406</guid><author>tusdddd</author><pubDate>Wed, 02 Dec 2020 21:03:22 +0800</pubDate><description><![CDATA[多态继承
多态继承是C++中实现代码重用的一个重要方法。例如最刚开始的时候定义了一个基础类Base：
class Base{
	private:
		string name;
	public:
		Base(string n): name(n){}
		void show(){
			cout &lt;&lt; "Using base function: " &lt;&lt; name &lt;&lt; endl;
		}
};

这个类只是实现了最基本的功能，但是如果临时想为该类添加一个新的功能，就要在B]]></description><category></category></item><item><title><![CDATA[构造函数初始化列表]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110247067</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110247067</guid><author>tusdddd</author><pubDate>Fri, 27 Nov 2020 21:18:51 +0800</pubDate><description><![CDATA[构造函数初始化列表
与普通构造函数的区别
构造函数初始化列表用于在显式初始化类成员。在平常的使用构造函数创建对象时，如果对象中将另一个对象作为成员，那么在调用构造函数之前，编译器会用成员对象的默认构造函数进行初始化。如果不想让编译器用默认的构造函数进行初始化，就要使用构造函数初始化列表来显式规定成员对象的初始化形式。
构造函数进行的操作是，将成员先初始化，再用给定值赋值给初始化后的成员，而构造函数初始化列表则是直接对成员进行初始化，两者之间的区别跟下面两种创建变量的方式区别类似：
//在创建的时候直接初始化]]></description><category></category></item><item><title><![CDATA[定位New与对象]]></title><link>https://blog.youkuaiyun.com/tusdddd/article/details/110222412</link><guid>https://blog.youkuaiyun.com/tusdddd/article/details/110222412</guid><author>tusdddd</author><pubDate>Fri, 27 Nov 2020 10:11:32 +0800</pubDate><description><![CDATA[定位new与对象
当使用定位new运算符为对象分配内存时，注意调用对象的析构函数。因为delete运算符必须跟new配套使用，而不是跟定位new配套使用。所以使用定位new为对象分配空间并初始化对象之后，不能用delete清除对象。这时如果对象的构造函数中使用new申请了内存，就会导致内存泄漏，因为不能使用delete清除对象。例如：
class BadString{
	private:
		int len;
		char * str;
	public:
		BadString();
		BadString]]></description><category></category></item></channel></rss>