<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Vcrossover的博客]]></title><description><![CDATA[我的第一篇博客！]]></description><link>https://blog.csdn.net/Vcrossover</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; Vcrossover]]></copyright><item><title><![CDATA[【Linux】grep命令使用场景]]></title><link>https://blog.csdn.net/Vcrossover/article/details/115444549</link><guid>https://blog.csdn.net/Vcrossover/article/details/115444549</guid><author>Vcrossover</author><pubDate>Mon, 05 Apr 2021 16:55:54 +0800</pubDate><description><![CDATA[grep命令是文本搜索命令，它可以正则表达式搜索文本，也可从一个文件中的内容作为搜索关键字。
grep的工作方式是这样的，它在一个或多个文件中搜索字符串模板。如果模板包括空格，则必须被引用，模板后的所有字符串被看作文件名。搜索的结果被送到标准输出，不影响原文件内容。
参数：
-a   --text   #不要忽略二进制的数据。

-A&lt;显示行数&gt;   --after-context=&lt;显示行数&gt;   #除了显示符合范本样式的那一列之外，并显示该行之后的内容。

-b   --byte]]></description><category></category></item><item><title><![CDATA[【Linux】基础指令]]></title><link>https://blog.csdn.net/Vcrossover/article/details/115444537</link><guid>https://blog.csdn.net/Vcrossover/article/details/115444537</guid><author>Vcrossover</author><pubDate>Mon, 05 Apr 2021 16:46:46 +0800</pubDate><description><![CDATA[文章目录一、Linux介绍Linux发展Linux特点CentOS二、基础命令目录相关命令文件相关命令压缩解压缩的命令匹配查找命令（常用）其他命令
一、Linux介绍
Linux发展
  操作系统，英语Operating System简称为OS。说道操作系统就需要先讲一讲Unix，UNIX操作系统，是一个强大的多用户、多任务操作系统，支持多种处理器架构，按照操作系统的分类，属于分时操作系统，最早由KenThompson、Dennis Ritchie和Douglas McIlroy于1969年在AT&amp;]]></description><category></category></item><item><title><![CDATA[【C++】虚函数表存放在哪里?]]></title><link>https://blog.csdn.net/Vcrossover/article/details/115101870</link><guid>https://blog.csdn.net/Vcrossover/article/details/115101870</guid><author>Vcrossover</author><pubDate>Mon, 22 Mar 2021 22:04:33 +0800</pubDate><description><![CDATA[1.虚函数表是全局共享的元素,即全局仅有一个.
2.虚函数表类似一个数组,类对象中存储vptr指针,指向虚函数表.即虚函数表不是函数,不是程序代码,不肯能存储在代码段.
3.虚函数表存储虚函数的地址,即虚函数表的元素是指向类成员函数的指针,而类中虚函数的个数在编译时期可以确定,即虚函数表的大小可以确定,即大小是在编译时期确定的,不必动态分配内存空间存储虚函数表,所以不再堆中.
根据以上特征,虚函数表类似于类中静态成员变量.静态成员变量也是全局共享,大小确定.
所以我推测虚函数表和静态成员变量一样,存放在全局]]></description><category></category></item><item><title><![CDATA[【C++】智能指针（史上最详细！）]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114767164</link><guid>https://blog.csdn.net/Vcrossover/article/details/114767164</guid><author>Vcrossover</author><pubDate>Sun, 14 Mar 2021 17:11:56 +0800</pubDate><description><![CDATA[智能指针为什么要有智能指针？智能指针的使用及原理RAII智能指针的原理auto_ptrunique_ptrshared_ptrshared_ptr的线程安全问题shared_ptr的循环引用循环引用分析
为什么要有智能指针？
下面我们先分析一下下面这段程序有没有什么内存方面的问题？提示一下：注意分析MergeSort函数中的问题。
void MergeSort(int* a, int n) {
 int* tmp = (int*)malloc(sizeof(int)*n);
 _MergeSort(a, 0]]></description><category></category></item><item><title><![CDATA[【C++】小知识---i++是不是原子操作？]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114792414</link><guid>https://blog.csdn.net/Vcrossover/article/details/114792414</guid><author>Vcrossover</author><pubDate>Sun, 14 Mar 2021 16:32:30 +0800</pubDate><description><![CDATA[1.不是原子操作
理由：
1.i++分为三个阶段：
内存到寄存器
寄存器自增
写回内存
这三个阶段中间都可以被中断分离开.
举个例子，现有A,B两个线程，初始i=2；A线程完成1,2步后被切换到B线程，在B线程中执行完这3步，再切换回来，此时A寄存器中的i=3写回内存，故最后i=3，而不是正常的4；所以不是原子操作。
2.++i呢
在多核的机器上，cpu在读取内存i时也会可能发生同时读取到同一值，这就导致两次自增，实际只增加了一次。
3.如何实现i++和++i的原子性呢？
在多核CPU的复杂内存操作中，处理]]></description><category></category></item><item><title><![CDATA[【C语言】模拟实现memcpy、memmove、memset函数]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114749526</link><guid>https://blog.csdn.net/Vcrossover/article/details/114749526</guid><author>Vcrossover</author><pubDate>Sat, 13 Mar 2021 17:09:38 +0800</pubDate><description><![CDATA[memcpy原型
void* (void* dest,const void* src,size_t len)
为什么是void呢？，因为memcpy支持任何匀速类型的拷贝，所以给成void类型，然后在进行强制类型转化即可达到任意类型的拷贝。
这同样也是strcpy和memcpy的一个差别，这里mempy是对内存进行操作的所以无论你是什么类型，都可以对其进行操作。
memcpy模拟实现
void *my_memcpy(void *det, const void *src, int num)
 
{
 
cha]]></description><category></category></item><item><title><![CDATA[【C语言】内存重叠详解]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114714899</link><guid>https://blog.csdn.net/Vcrossover/article/details/114714899</guid><author>Vcrossover</author><pubDate>Sat, 13 Mar 2021 00:35:48 +0800</pubDate><description><![CDATA[什么是“内存重叠”？
当我们进行内存拷贝（memcpy函数）时，目标地址在原地址的范围内就造成了内存重叠。
这么说可能会比较抽象，下面我们借助于memcpy函数通过一个例子说明。
memcpy(void *dest, void *src, size_t num)是将src指向的地址中的num=5个字节拷贝到dest目标地址中。根据dest和src的关系，可以分为以下三类：
case1:
目标地址与源地址没有任何重叠(dest &gt; src + 5或者dest &lt; src - 5)

时，可以直接从]]></description><category></category></item><item><title><![CDATA[【C语言】strncpy详解]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114712850</link><guid>https://blog.csdn.net/Vcrossover/article/details/114712850</guid><author>Vcrossover</author><pubDate>Fri, 12 Mar 2021 23:50:59 +0800</pubDate><description><![CDATA[1.不考虑内存重叠的strncpy
网上很多博客也写了这个函数，面试也常常会遇到，但是，我发现网上的很多代码都是有问题的，我们先看下大部分网上博客的实现：
char *strncpy(char *dst, const char *src, size_t len)
{
	assert(dst != NULL &amp;&amp; src != NULL);
	char *res = dst;
	while (len--)
	{
		*dst++ = *src++;
	}
	return res;
}

看着好]]></description><category></category></item><item><title><![CDATA[【C语言】strcpy函数的缺点]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114711269</link><guid>https://blog.csdn.net/Vcrossover/article/details/114711269</guid><author>Vcrossover</author><pubDate>Fri, 12 Mar 2021 23:09:12 +0800</pubDate><description><![CDATA[用法
这是C语言里面复制字符串的库函数, 函数声明包括在专门处理字符串的头文件&lt;string.h&gt;中:
char * strcpy( char * dst, const char * src );
这个函数把字符串src复制到一分配好的字符串空间dst中，复制的时候包括标志字符串结尾的空字符一起复制。操作成功，返回dst，否则返回NULL.
需要注意的问题
函数里的局部变量一般都是按序排放的，并且因为是分配在堆栈之中，它们的地址是向下“增长”，即向低地址方向增长。比如下面的程序：
   int ]]></description><category></category></item><item><title><![CDATA[【C++】四种类型转换]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114686485</link><guid>https://blog.csdn.net/Vcrossover/article/details/114686485</guid><author>Vcrossover</author><pubDate>Fri, 12 Mar 2021 10:27:58 +0800</pubDate><description><![CDATA[C语言的类型转换
void Test ()
{
 int i = 1;
 // 隐式类型转换
 double d = i;
 printf("%d, %.2f\n" , i, d);
 int* p = &amp;i;
 // 显示的强制类型转换
 int address = (int) p;
 printf("%x, %d\n" , p, address);
}

缺陷： 转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换
C++强制类型转换
标准C++为了加强类型转换的可视性，]]></description><category></category></item><item><title><![CDATA[【操作系统】并发和并行的区别]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114658467</link><guid>https://blog.csdn.net/Vcrossover/article/details/114658467</guid><author>Vcrossover</author><pubDate>Thu, 11 Mar 2021 11:51:31 +0800</pubDate><description><![CDATA[学习多线程的时候会遇到一个名词：并发。这是属于操作系统中的词汇，需要了解并发和并行的区别，从网上搜集了几种说法帮助理解。
一：
并发是指一个处理器同时处理多个任务。
并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。
并发是逻辑上的同时发生（simultaneous），而并行是物理上的同时发生。
来个比喻：并发是一个人同时吃三个馒头，而并行是三个人同时吃三个馒头。
二：
并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑]]></description><category></category></item><item><title><![CDATA[【C++】lambda表达式详解]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114654688</link><guid>https://blog.csdn.net/Vcrossover/article/details/114654688</guid><author>Vcrossover</author><pubDate>Thu, 11 Mar 2021 10:42:59 +0800</pubDate><description><![CDATA[lambda表达式语法
lambda表达式书写格式：[捕获列表] (参数列表) mutable -&gt; 返回值类型 { 函数体}
lambda表达式各部分说明:

[] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
()：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable]]></description><category></category></item><item><title><![CDATA[【C++】如何更改const修饰的变量？]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114651989</link><guid>https://blog.csdn.net/Vcrossover/article/details/114651989</guid><author>Vcrossover</author><pubDate>Thu, 11 Mar 2021 09:23:15 +0800</pubDate><description><![CDATA[一、结论
在定义变量的时候加上volatile关键字
const volatile int i = 10；

但是在我看来，程序员既然用const来修饰变量，那么就不希望其被修改，根据C++标准，对于修改const变量，属于：未定义行为。所以其实不建议这么做的。
volatile关键字详解
二、分析
#include &lt;stdio.h&gt;
int main()
{
    const volatile int i = 10;
    int* pi = (int*)(&amp;i);
    *p]]></description><category></category></item><item><title><![CDATA[【C++】关联式容器（map）详解]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114639675</link><guid>https://blog.csdn.net/Vcrossover/article/details/114639675</guid><author>Vcrossover</author><pubDate>Wed, 10 Mar 2021 16:50:59 +0800</pubDate><description><![CDATA[map
概念
如果说set对应数学中的“集合”，那么map对应的就是“映射”。map是一种key-value型容器，其中key是关键字，起到索引作用，而value就是其对应的值。与set不同的是它支持下标访问。头文件是
特点

增加和删除节点对迭代器的影响很小(高效的插入与删除)
快速的查找（同set）
自动建立key-value的对应，key和value可以是任何你需要的类型
可以根据key修改value的记录
支持下标[]操作

声明
map&lt;T1,T2&gt; m
其中T1是key类型，T2是v]]></description><category></category></item><item><title><![CDATA[【C++】关联式容器（set）详解]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114639198</link><guid>https://blog.csdn.net/Vcrossover/article/details/114639198</guid><author>Vcrossover</author><pubDate>Wed, 10 Mar 2021 16:42:22 +0800</pubDate><description><![CDATA[关联式容器
  关联容器与序列容器有着根本性的不同，序列容器的元素是按照在容器中的位置来顺序保存和访问的，而关联容器的元素是按关键元素来保存和访问的。关联容器支持高效的关键字查找与访问。两个主要的关联容器类型是map与set。
set


概念：
set里面每个元素只存有一个key，它支持高效的关键字查询操作。set对应数学中的“集合”。


特性

储存同一类型的数据元素（这点和vector、queue等其他容器相同）
每个元素的值都唯一（没有重复的元素）
根据元素的值自动排列大小（有序性）
无法直接修改]]></description><category></category></item><item><title><![CDATA[【C++】左值右值]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114607459</link><guid>https://blog.csdn.net/Vcrossover/article/details/114607459</guid><author>Vcrossover</author><pubDate>Tue, 09 Mar 2021 23:25:52 +0800</pubDate><description><![CDATA[左值右值
什么是左值？什么是右值？左边的值和右边的值？不不不，这样不全面，先给你一个浅显的解释吧，左值就是可以被赋值的类型，右值就是不可以被赋值的值
int a = 2;

这个代码中a位于等于运算符左边，数值2位于等于运算符右边，所以a是左值，2是右值。问题来了：那我要是把2放在左边，2是不是就成左值了呢？刚入门的c语言程序员都知道这是不可能的，但是我们还是来写一下，看看编译器报错了什么。
int a = 1;
2 = a;

当编译之后，给出以下报错：
[Error] lvalue required a]]></description><category></category></item><item><title><![CDATA[【C语言】strcpy和strncpy的缺陷！]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114602719</link><guid>https://blog.csdn.net/Vcrossover/article/details/114602719</guid><author>Vcrossover</author><pubDate>Tue, 09 Mar 2021 22:53:21 +0800</pubDate><description><![CDATA[strcpy()函数应该是我们用的比较常用的一个函数，基本功能是将一个字符串拷贝到我指定的内存空间。但是要复制的字符串长度超过这段内存空间的话，结果可能是未知的。
strcpy用法
这是C语言里面复制字符串的库函数, 函数声明包括在专门处理字符串的头文件&lt;string.h&gt;中:
char * strcpy( char * dst, const char * src );
这个函数把字符串src复制到一分配好的字符串空间dst中，复制的时候包括标志字符串结尾的空字符一起复制。操作成功，返回dst，]]></description><category></category></item><item><title><![CDATA[【C++】memcpy能比较结构体吗？]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114602576</link><guid>https://blog.csdn.net/Vcrossover/article/details/114602576</guid><author>Vcrossover</author><pubDate>Tue, 09 Mar 2021 21:34:48 +0800</pubDate><description><![CDATA[比较两个结构体时， 若结构体中含有大量的成员变量， 为了方便， 程序员往往会直接使用memcmp对这两个结构体进行比较， 以避免对每个成员进行分别比较。 这样的代码写起来比较简单， 然而却很可能深藏隐患。 请看下面的示例代码：
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
typedef struct padding_type {
	short m1;
	int m2;
}padding_type_t]]></description><category></category></item><item><title><![CDATA[【C++】memset的坑！]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114602511</link><guid>https://blog.csdn.net/Vcrossover/article/details/114602511</guid><author>Vcrossover</author><pubDate>Tue, 09 Mar 2021 21:33:32 +0800</pubDate><description><![CDATA[memset函数常被我们用来初始化数组，然而有个坑可能会被我们踩到。
静态数组初始化
#include &lt;cstring&gt;
int main()
{
    // 静态数组arr
    int arr[10];
    
    // 将数组所有元素初始化为0
    memset(arr,0,sizeof(arr));
        
   	// 遍历输出数组元素
    for(int i=0;i&lt;10;++i){
        cout &lt;&lt; arr[i] &lt]]></description><category></category></item><item><title><![CDATA[【C++】继承详解，菱形继承问题]]></title><link>https://blog.csdn.net/Vcrossover/article/details/114373228</link><guid>https://blog.csdn.net/Vcrossover/article/details/114373228</guid><author>Vcrossover</author><pubDate>Thu, 04 Mar 2021 17:46:51 +0800</pubDate><description><![CDATA[继承体系概念继承方式赋值兼容规则同名隐藏子类对象的构造过程菱形继承
概念
是面向对象程序设计是代码可以复用的最重要的手段，它允许程序员在保持原有的类的特性的基础下进行拓展，增加功能。 这样产生的类被称为派生类；
class Person
{
public:
void Print()
{
cout &lt;&lt; "name:" &lt;&lt; _name &lt;&lt; endl; cout &lt;&lt; "age:" &lt;&lt; _age &lt;&lt; endl;
}
protecte]]></description><category></category></item></channel></rss>