<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[juicy_w的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/juicy_w</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; juicy_w]]></copyright><item><title><![CDATA[进程地址空间]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/86494653</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/86494653</guid><author>juicy_w</author><pubDate>Tue, 15 Jan 2019 16:21:19 +0800</pubDate><description><![CDATA[把物理地址暴露给外部是一件非常危险的事情，因此采用虚拟内存作为线性地址与物理地址的中间层。

32位地址总线保存0x00000000到0xffffffff所有的地址，转换为二进制就是32个0到32个1，也就是2^32 = 4G，因此虚拟内存大小为4G，其布局如下图所示：



一个可执行文件在运行时被装载到虚拟内存，那么他是怎么装载的呢？首先，每个进程都有一个PCB（进程描述符）来描述这个进程的状...]]></description><category></category></item><item><title><![CDATA[关于引用]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/84678345</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/84678345</guid><author>juicy_w</author><pubDate>Sat, 01 Dec 2018 21:29:11 +0800</pubDate><description><![CDATA[看过很多博客说引用是不开辟内存的，但经过实践，这一说法太过于表面。我通过代码转到反汇编，发现有开辟形参压栈的过程：


#include &amp;lt;iostream&amp;gt;

int sum(int&amp;amp; a,int&amp;amp; b)
{
	return a+b;
}

int main()
{
	int a = 10;
	int b = 20;

	int s = sum(a,b);

	std...]]></description><category></category></item><item><title><![CDATA[静态链表]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/84678099</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/84678099</guid><author>juicy_w</author><pubDate>Sat, 01 Dec 2018 20:42:41 +0800</pubDate><description><![CDATA[     静态链表依靠数组来实现链表的功能，他在物理上是顺序存储的：



如上图所示为一个静态链表，图示红色区域不作为有效存储单位，其余的未使用的单位简称为备用链表。

资源是要被利用起来的，所以：

1).最左边的红色单位用来存储备用链表的第一个单位的下标，我们可以简单理解为它是备用链表的头节点；

2).最右边单位指向已使用链表。

因为数组下表递增的特性，我们规定自左往右赋值即为链表头插，...]]></description><category></category></item><item><title><![CDATA[函数堆栈调用过程及总结（待完善）]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/84192326</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/84192326</guid><author>juicy_w</author><pubDate>Sat, 17 Nov 2018 20:30:12 +0800</pubDate><description><![CDATA[为了解函数调用的底层实现机制，通过visual studio 2010及一段代码来剖析，代码如下：


1.	#include &amp;lt;stdio.h&amp;gt;  
2.	  
3.	int GetSum(int a,int b)  
4.	{  
5.	    return a+b;  
6.	}  
7.	  
8.	int main()  
9.	{  
10.	    int a = 10;...]]></description><category></category></item><item><title><![CDATA[虚拟地址空间布局和编译链接运行原理]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/84192291</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/84192291</guid><author>juicy_w</author><pubDate>Sat, 17 Nov 2018 20:23:31 +0800</pubDate><description><![CDATA[一、

利用中间层访问物理内存，一是提高了内存使用效率和最优分配，二是提高了安全性。中间层又被称作虚拟地址空间，由此一来，程序访问的不再是实际的物理内存地址，而是访问虚拟地址，操作系统再将虚拟地址映射到物理内存上；linux系统下虚拟地址空间是这样划分的：



.data段和.bss段统称为数据段，不同之处为：

.data段存放已初始化且初始化不为0的数据

.bss段存放未初始化或初始化为0...]]></description><category></category></item><item><title><![CDATA[指针被强转为数字的应用]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/80336696</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/80336696</guid><author>juicy_w</author><pubDate>Wed, 16 May 2018 14:38:40 +0800</pubDate><description><![CDATA[有如下程序：#include &amp;lt;stdio.h&amp;gt;

int main()
{
	int arr[]={2,3,2,3};
	int *p2=(int *)((int)arr+1);    //arr被强转为int型数字，加上1，现在arr为首元素地址加1个字节

	printf(&quot;%x\n&quot;,*p2);

	return 0;
}在强转前，arr指向如下所示：强转后，arr指向如下所示...]]></description><category></category></item><item><title><![CDATA[判断结构体大小的方法]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/80207988</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/80207988</guid><author>juicy_w</author><pubDate>Sat, 05 May 2018 18:02:04 +0800</pubDate><description><![CDATA[1.创建一个结构体类型：typedef struct A
{
	char a;
	int b;
}A;Char类型占1个字节，int占4个，所以容易误判为struct A占五个字节。假如计算机是按照这个来在内存中存储数据：上方的数字代表了地址，每个格子代表一个字节；计算机是寻址访问数据的，在访问变量b时，它的首地址要能被4整除，才能被访问，以前这样存放是可以的，但是在如今内存很大的时代下，以这样的...]]></description><category></category></item><item><title><![CDATA[略谈typedef]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/80142368</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/80142368</guid><author>juicy_w</author><pubDate>Sun, 29 Apr 2018 12:42:35 +0800</pubDate><description><![CDATA[假如定义十个甚至更多这样类型的变量：unsigned long long int a;不停地写变量类型是一件很麻烦的事，极大地降低工作效率，typedef的存在就是解决这个问题！顾名思义，typedef就是：类型定义，给类型起别名。假如要定义一个无符号长长整型类型，用uint64来当做这个类型的别名，这时uint64就是这个类型本身，只需这样做：typedef unsigned long long...]]></description><category></category></item><item><title><![CDATA[魔方阵(奇数阶、单偶数阶、双偶数阶)]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/80099047</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/80099047</guid><author>juicy_w</author><pubDate>Thu, 26 Apr 2018 20:13:28 +0800</pubDate><description><![CDATA[#include &amp;lt;stdio.h&amp;gt;
#include &amp;lt;assert.h&amp;gt;
#include &amp;lt;stdlib.h&amp;gt;


int **Magic1(int n)    //奇数阶魔方阵
{
	assert(n%2 != 0);
	int **arr = (int **)malloc(sizeof(int *)*n);    //创建二维数组存放魔方阵
	for(...]]></description><category></category></item><item><title><![CDATA[free()崩溃原因总结]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/80044767</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/80044767</guid><author>juicy_w</author><pubDate>Sun, 22 Apr 2018 23:37:58 +0800</pubDate><description><![CDATA[       在使用动态内存分配malloc()后，若不及时释放内存free()，会造成内存泄漏；我总结了在释放时经常出现错误的原因，频率由高到低排序。（一） 越界、漏写sizeof()、realloc()第二个参数写错int main()
{
	int *arr=(int *)malloc(10*sizeof(int));   //分配10个单位的连续块，每个单位4个字节
	//for(int ...]]></description><category></category></item><item><title><![CDATA[递归详解]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/80012384</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/80012384</guid><author>juicy_w</author><pubDate>Thu, 19 Apr 2018 22:56:13 +0800</pubDate><description><![CDATA[用如下程序来解释递归：#include &amp;lt;stdio.h&amp;gt;

int Sum(int n)  //从1~n相加
{
		return n == 1 ? 1:Sum(n-1)+n;
}

int main()
{
	printf(&quot;%d\n&quot;,Sum(4));

	return 0;
}程序从main开始执行，当执行Sum(4)时的情况如下图所示：Sum(4)执行到最底下层虚线处，即re...]]></description><category></category></item><item><title><![CDATA[strlen.strcpy.strcmp.stratoi.stritoa的自己实现]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79968200</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79968200</guid><author>juicy_w</author><pubDate>Mon, 16 Apr 2018 23:02:08 +0800</pubDate><description><![CDATA[#include &amp;lt;stdio.h&amp;gt;
#include &amp;lt;string.h&amp;gt;

//1.字符串连接
char * Mystrcpy(char *des,const char *src,char *p)
{
	while(*p++ = *src++);      //指针p指向des的'\0'位置，从此处开始复制，即实现了字符串连接
	return des;
}

//2.字...]]></description><category></category></item><item><title><![CDATA[Const（定义常变量）的四个重要性质]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79967882</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79967882</guid><author>juicy_w</author><pubDate>Mon, 16 Apr 2018 22:43:40 +0800</pubDate><description><![CDATA[1.将变量变成只读 定义一个变量a，并赋初值10，变量a既可以被重新赋值，又可以被读取：int a= 10;
a = 20;
int b = a;
这时变量a被称为左值，它具有可以被赋值和读取两种属性倘若定义常变量a，试着重新赋值和读取：可以看到编译器报错，const将变量a变成了右值，即只可被读取，不能写入（重新赋值）2. 数据类型对于const而言是透明的观察1，const写在int后面，那么...]]></description><category></category></item><item><title><![CDATA[字符串常量高频错误]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79966944</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79966944</guid><author>juicy_w</author><pubDate>Mon, 16 Apr 2018 21:40:08 +0800</pubDate><description><![CDATA[当定义一个字符串常量：char *arr = &quot;aecd&quot;;
发现”aecd”的’b’错写成了’e’,当试图去更改的时候，程序会崩溃：char *arr = &quot;aecd&quot;;
arr[1] = 'b';这是因为字符串常量存储在常量区（静态存储区），这部分区域是不允许修改的，而指针arr指向的是”aecd”的地址，并不是这个值，如下所示：字符数组的值可以修改，例如：char arr[] = &quot;aecd...]]></description><category></category></item><item><title><![CDATA[假设在n进制下，下面的等式成立，567*456 = 150216，n的值是（）]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79927052</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79927052</guid><author>juicy_w</author><pubDate>Fri, 13 Apr 2018 12:22:31 +0800</pubDate><description><![CDATA[问题：假设在n进制下，下面的等式成立，567*456 = 150216，n的值是（）          A.9     B.10     C.12       D.18 1. 在六进制下有：15*4=112.    把这个等式转换为十进制：(1*6+ 5*6^0) *(4*6^0)=(1*6^2 + 1*6 + 2*6^0)2. 同理，对567*456=150216做如上变换：    (5*n^2...]]></description><category></category></item><item><title><![CDATA[C语言：指针学习（二）]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79796707</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79796707</guid><author>juicy_w</author><pubDate>Mon, 02 Apr 2018 23:15:12 +0800</pubDate><description><![CDATA[主函数调用子函数，子函数的改变要想影响影响主函数，必须：    1：传指针    2：解引用以下有三个案例是指针学习中最容易出现的问题（前提：交换两个变量a、b的值）（一）第一种情况是没有传指针，也没有解引用。#include &amp;lt;stdio.h&amp;gt;

void Swap_error1(int a,int b)
{
	int tmp;
	tmp = a;
	a = b;
	b = tmp;...]]></description><category></category></item><item><title><![CDATA[C语言：指针学习（一）]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79792546</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79792546</guid><author>juicy_w</author><pubDate>Mon, 02 Apr 2018 17:57:26 +0800</pubDate><description><![CDATA[ C语言这门课程里，初次接触到指针这一章节时，对于指针的理解我很模糊，所以就通过程序和调试来加深对指针的理解。Int a = 10;
Int *p = &amp;amp;a;1.为了理解p和*p到底代表了什么，调试得到如下结果：可以看到，指针变量p的值和变量a的地址相同，*p等于变量a的值。也就是说，指针等同于一个地址，解引用（*p）为该地址上内存单元存储的的值（a）。在此基础上，又有两个新问题：（1）解...]]></description><category></category></item><item><title><![CDATA[C语言：关于输入一个正整数的应用]]></title><link>https://blog.youkuaiyun.com/juicy_w/article/details/79728353</link><guid>https://blog.youkuaiyun.com/juicy_w/article/details/79728353</guid><author>juicy_w</author><pubDate>Wed, 28 Mar 2018 16:14:51 +0800</pubDate><description><![CDATA[1.求出它是几位数2.分别输出每一位数字3.按逆序输出各位数字，例如原数为123，应输出321#include &amp;lt;stdio.h&amp;gt;


int Getnums(int n)
{
	int count = 0;
	do
	{
		n /=10;
		count++;
	}while(n != 0);

	return count;
}


void Geteachnum(int n)
{...]]></description><category></category></item></channel></rss>