&&&&&&&&&&&
一. 在c中分为这几个存储区1.栈 - 由编译器自动分配释放2.堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放4.另外还有一个专门放常量的地方。- 程序结束释放&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的"adgfdf"这样的字符串存放在常量区。比如：
//main.cpp
int a = 0;
// 全局初始化区
// 全局未初始化区
void main()
char s[] = "abc"; // 栈区
char *p2; // 栈区
char *p3 = "123456"; // p3在栈区;
"" 在常量区，
static int c =0;
// 全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20); // 分配得来的10和20字节的区域就在堆区
strcpy(p1, "123456");
// "" 放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
二.在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）
三、堆和栈的理论知识 申请方式 stack: 由系统自动分配。 & 例如，声明在函数中一个局部变量 & int & & 系统自动在栈中为b开辟空间 heap: 需要程序员自己申请，并指明大小，在c中malloc函数 如p1&&= & (char & *)malloc(10); 在C++中用new运算符 如p2&&= & (char & *)malloc(10);
但是注意p1、p2本身是在栈中的。
阅读(...) 评论()匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。下次自动登录
现在的位置:
& 综合 & 正文
C++常识之——C++中堆和栈的区别，自由存储区、全局/静态存储区和常量存储区
文章来自/elva/archive//93774.html
在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的（初始化的全局变量和静态变量在一块
区域，未初始化的全局变量与静态变量在相邻的另一块区域，同时未被初始化的对象存储区可以通过void*来访问和操纵，程序结束后由系统自行释放），在
C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）
明确区分堆与栈
在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：
void f() { int* p=new int[5]; }
这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：
在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator
new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
operator new ()
dword ptr [ebp-8],eax
eax,dword ptr [ebp-8]
dword ptr [ebp-4],eax
这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
好了，我们回到我们的主题：堆和栈究竟有什么区别？
主要的区别由以下几点：
1、管理方式不同；
2、空间大小不同；
3、能否产生碎片不同；
4、生长方向不同；
5、分配方式不同；
6、分配效率不同；
管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：
打开工程，依次操作菜单如下：Project-&Setting-&Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，
因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的
可以参考数据结构，这里我们就不再一一讨论了。
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比
较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的（具体的算法可以参考数据结构/操作系统）在堆
内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分
到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态
和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地
址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就
算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）
对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？
static用来控制变量的存储方式和可见性
函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题:
如果想将函数中此变量的值保存至下一次调用时，如何实现？
最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此
函数控制）。
需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。
static的内部机制：
静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。这样，它的空间分配有三
个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数
据声明和定义处。
静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声
明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态
数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。
static的优势：
可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的
值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。引用静态数据成员时，采用如下格式：
&类名&::&静态成员名&
如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式
来引用静态数据成员。
(1)类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。
(2)不能将静态成员函数定义为虚函数。
(3)由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针 ，函数地址类型是一个“nonmember函数指针”。
(4)由于静态成员函数没有this指针，所以就差不多等同于nonmember函数，结果就产生了一个意想不到的好处：成为一个callback函数，使得我们得以将c++和c-based x window系统结合，同时也成功的应用于线程函数身上。
(5)static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。
(6)静态数据成员在&定义或说明&时前面加关键字static。
(7)静态数据成员是静态存储的，所以必须对它进行初始化。
(8)静态成员初始化与一般数据成员初始化不同:
初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；
初始化时不加该成员的访问权限控制符private，public等；
初始化时使用作用域运算符来标明它所属类；
所以我们得出静态数据成员初始化的格式：
&数据类型&&类名&::&静态数据成员名&=&值&
(9)为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有
重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
【转】全局变量静态变量
static 声明的变量在C语言中有两方面的特征：
　　1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
　　2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。
　　A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
　　B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
　　C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题；
D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数)
E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。
函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。
展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后，static在C中有
了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。最后，C++重
用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。
全局变量、静态全局变量、静态局部变量和局部变量的区别
变量可以分为：全局变量、静态全局变量、静态局部变量和局部变量。
按存储区域分，全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。
按作用域分，全局变量在整个工程文件内都有效；静态全局变量只在定义它的文件内有效；静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；局部变量在定义它的函数内有效，但是函数返回后失效。
局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，
当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效，
在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，
因此可以避免在其它源文件中引起错误。
　　从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。
　　static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件
　　static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
　　static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
全局变量和静态变量如果没有手工初始化，则由编译器初始化为0。局部变量的值不可知。
&&&&推荐文章:
【上篇】【下篇】72被浏览4205分享邀请回答*((int*)0xCCCCCCCC) = 100;
或者像评论里提醒到的，如果要强制保证这个操作不被优化掉的话，加volatile：*((volatile int*)0xCCCCCCCC) = 100;
GCC在x64上生成的代码会是：（AT&T语法）movl $, %eax
movl $100, (%rax)
对应回Intel语法的话：mov
eax, 0xCCCCCCCC
dword ptr [rax], 0x64
但是题主想要的是单条指令形式的：c7 05 cc cc cc cc 64 00 00 00
dword ptr ds:[0xCCCCCCCC],0x64
没找到啥编译选项能逼GCC生成这种单条指令形式的mov。至于说x86不支持赋值目标和源都是立即数的同学们，你们真的用过opcode为C7的mov指令么？C7 /0 MOV r/m32,imm32
好吧是因为NASM不支持所以就以为x86不支持么。GNU as支持的喔。1113 条评论分享收藏感谢收起C语言的内存管理分析
栈区 代码区 堆区 静态区 常量区
时间： 00:11:54
&&&& 阅读：1331
&&&& 评论：
&&&& 收藏：0
标签：&&&&&&&&&&&&
系统为了管理内存 把内存划分了几个区域
&& & 栈区之中的数据在栈区之中以栈的形式进行存储.
&& & 栈区的特点:数据是先进后出,
&& & 放在栈区里面存放的是局部变量.(例如定义在函数内部的变量)
&& & 栈区之中的数据(局部变量)的作用范围过了之后,系统就会回收自动管理栈区的内存(分配内存
, 回收内存),不需要开发人员来手动管理
&& & 高效的使用内存
&& & 这里的内存可以由程序员自己手动管理
高效的使用内存& 例如:
申请内存 释放内存.优化内存 ARC
申请内存的函数 malloc()& memary alloc&
申请内存空间
&& & void *mallc(size_t);
函数名:malloc
返回值: void * & (泛指针类型
可以轻松的转换为任意类型的指针) & &
&& & & & & & & & & &
返回一个指向新开辟的的存空间的首地址&
&& & & & & & & & & &
类型是一个泛指针(可以根据接受者
动态的转换).
&& & 参数: size_t&
申请动态空间的字节数的大小. 即:你要开辟多大的空间.
例如开辟一个整形的变量的存储空间(在堆区之中)& malloc(4);
& & &int *p = malloc(4);
释放内存的函数 free(p);// p 是你 刚刚使用 开辟空间函数返回的内存空间首地址的的指针接受者
& & &最后还要将 p = NULL; 否则会出现野指针错误!&
&& & void *calloc(unsigned n,unsigned size);(10 * 4)
申请 count * size
个字节& count 是个数 size
是每一个占用的字节数&
&& & 并且将申请到的内存之前的残留数据清空,效率比malloc
要低,但是更安全.
&& & 例如 :开辟十个整型数据的空间
&& & int *p = calloc(10,sizeof(int));
&& & void * realloc(&#void *#&, &#size_t#&);&
重新分配内存空间.
&& & realloc(p, size);
&& & 从指针p的位置
重新申请size个字节.
返回一个 泛类型的指针.
& & & 从p的位置开始申请,如果后面有size
个字节可以使用,就直接申请;如果没有,就去内存之中找一块连续的size字节,找到就直接申请,并且在申请之前,释放掉以前申请到的内存.
返回新的指针.
&& & memset(void *,int ,size_t);
&& & memset(p,c,n);
&& & 从指针的p的位置开始,初始化n个字节的内容并且把内容改为 C;
&& & //memccpy(&#void *#&, &#const void *#&, &#int#&, &#size_t#&)
&& & & memccpy(dest, source, &#int#&, &#size_t#&)
& & & &memcpy(dest, source, n);
&& & 从指针source
的位置开始,向指针dest的位置,拷贝n个字节的内容.
静态区(全局区)
&& & 静态区存放的是:
全局变量(定义在函数外部的变量
例如在主函数上面 定义的变量)
和 静态变量
&& & static
类型的变量有什么特点:(只初始化一次(初始化是 在定义的时候辅助),不初始化的话,默认为零.)
&& & 静态区内存是由系统管理的.&
&& & 一旦静态区的内存被分配,
静态区的内存直到程序全部结束之后才会被释放
常量区存放:
常量(程序在运行的期间不能够被改变的量
例如: 10 ‘a‘ 1.12 &ios&, 数组的名字)
&& & 常量区的内容是只能读的
不能被修改的的.
&& & 区别一下下面的代码:
&& & char *p = &kpkoj&;
等价于 char *p; p = &kpkoj&;
&& & 此时char类型的指针p存放的是常量字符串的首地址 (&kpkoj&(存放在常量区)的首地址)
&& & 所以此时p指向的内容不能够被修改,只能被读取&
即*p的值只能被读取,不能被修改.但是可以重新的将指针变量p指向新得地址.&
&& & 例如在上面这个的操作的基础之上
在将p赋上新的值 p = &ddvdd&;(拷贝的是地址此时又指向了一个新的常量的首地址)
这个情况:& char str[] = &iOS&;
&& & 这个是字符数组
是将常量字符串&iOS&的内容拷贝到栈区的字符数组之中 ,所以
可以修改数组内的内容.例如: str[0]= ‘d‘;
&& & 但是str(数组名)
是一个常量的地址已经初始化,就不能被重定向(更改他的指向),所以只能通过下标或者什么的对其数组中的某个元素进行修改,区别上面的的指针情况.
&& & 常量的内存也是由系统管理的.
&& & 内存还是由系统控制的
&& & 代码区的存放 :程序中的函数编译后cpu指令
&& & 代码区的地址:函数的地址,程序的入口地址.程序的名字.
&& & 栈区内存地址编号由高到低(栈区 -&
//& & int *h = malloc(4);//开辟一个堆区的地址
//& & *h = 1024;//向堆区内存空间之中写入数据 1024
//& & printf(&堆区的地址%p,& %d\n& , h , *h);
//& & //在堆区之中
存入 &iphone 6s&;
//& & char *ch = malloc(sizeof(&iphone 6s&));
////& & ch = &iphone 6s&;
////& & ch = &dddd&;//这样只是将指针重新指向.而,新开辟的内存空间已经没有指向,造成内存没有指向&
//& & strcpy(ch , &iphone 6s&);//将常量区的内容拷贝到指向的刚刚开辟的内存区域!.
////& & ch[0] = ‘1‘;//这里可以被修改
因为他指向的内存区域是栈区&不是&
////& & ch = &iphone 6s&;//指向常量区的地址.
////& & ch[0] = ‘1‘;//这样就不能修改 ch[0]的内容
因为 ch指向的是一块常量地址,不能被修改.
上面已经有详细的阐述了.
//& & printf(&%s \n& , ch);
//& & strcpy(ch, ch + 2);
//& & printf(&%s\n&,ch);
//& & int *p3 = malloc(4);
//& & printf(&%p\n& , p3);//申请内存的堆区地址.
//& & printf(&%p\n& , &p3);//指针变量的栈区的地址
//& & //同样的
开辟内存之后一定要记得释放 否则容易造成
//& & //内存泄露:
内存一直被占用 得不到释放.
//& & free(p3);//内存释放函数 free(开辟的内存的首地址)&
只是将内存标记为可用而没有将里面的内容抹掉
//& & p3 = NULL;//记得安全的做法
将指针指向空 NULL
要不是就是野指针了.错误了
//& & // 使用动态内存分配的知识,在内存存放10个整数,随机数范围[2 , 399];
//& & int *open = malloc(sizeof(int) * 10);//分配一段连续的空间.
//& & int *lh =
//& & for (int i = 0; i & 10; i++)
//& & *(open + i) = arc4random() % (399 - 2 + 1) + 2;//向下偏移就可以了,因为下面的也是开辟的动态内存空间
open++;
//& & & & open[i] = arc4random() % (399 - 2 + 1) + 2;
// & & & &
//& & & & printf(&%d& &,*(open + i));
//& & printf(&\n&);
//& & BOOL flags = YES;
//& & for (int o = 0; o & 9 && o++)
//& & & & flags = NO;
//& & & & for (int i = 0; i & 9 - i++)
//& & & & {
//& & & & & & if (*(open + i) & *(open + 1 + i) )
//& & & & & & {
//& & & & & & & & temp = *(open + i);
//& & & & & & & & *(open + i) = *(open + 1 + i );
//& & & & & & & & *(open + i + 1) =
//& & & & & & & & flags = YES;
//& & & & & & }
//& & & & }
//& & for (int i = 0; i & 10; i++)
//& & & & printf(&%d& & , open[i]);
//& & printf(&\n&);
//& & free(open);
//& & open = NULL;
//& & const int b = 0;
//& & char *p = &iOS&; //定义了一个栈区的指针变量
常量区的地址.
////& & p[0] = ‘f‘;
////& & *p = ‘m‘;
//& & p = &ddd&;
//& & puts(p);
//& & printf(&常量去的地址%p \n&,p);
//& & int a = 10;
//& & static int k = 20;//静态变量.
//& & printf(&静态变量的地址& p & %p\n& , &k);
//& & printf(&静态区的地址:%p\n& , &b);
//& & printf(&栈区的地址:%p\n& , &a);
//& & printf(&代码区的地址:%p\n& , main);
//& & for(int i = 0 ; i & 100 ; i++ )
////& & & & int n =
////& & & & static int n = 1; //只能被
定义和初始化一次.& 存放在静态区 &
没有赋初值. 而且初始化的时候一定要
赋一个常量 不能赋值一个
////& & & & printf(&%d \n&,n);
//& & char ch[] = &jkjl3jo342pook25l414fe4op0kfe1&;
//& & int i ,
//& & i = sum = 0;
//& & while (ch[i] != ‘\0‘)
//& & & & if (ch[i] &= ‘0‘ && ch[i] &= ‘9‘)
//& & & & {
//& & & & & & sum++;
//& & & & }
//& & & & i++;
//& & printf(&%d\n\n& , sum);
//& & //数组定义的时候,元素的个数必须是确定的值&
不能出现变量的不确定
//& & char *p = malloc(sum + 1);
//& & i = sum = 0;
//& & while (ch[i] != ‘\0‘)
//& & & & if (ch[i] &= ‘0‘ && ch[i] &= ‘9‘)
//& & & & {
//& & & & & & *(p + sum) = ch[i];
//& & & & & & sum++;
//& & & & }
//& & & & i++;
//& & p[sum] = ‘\0‘;
//& & printf(&%s \n& , p);
//& & free(p);
//& & p = NULL;
//& & memccpy(&#void *#&, &#const void *#&, &#int#&, &#size_t#&)
//& & memcpy(&#void *#&, &#const void *#&, &#size_t#&)
//& & char *p = malloc(4);
//& & memset(p, 66, 2);
//& & printf(&%s \n&,p);
//& & char str1[] = &sdfsafdaf&;
//& & char str2[] = &&;
//& & memcpy(str1, str2, 3);
//& & printf(&%s \n& ,str1);
//& & memcmp(p1, p2, n);
//& & 内存的比较.
比较p1和p2
指向的内存之中的内容是否相等 ,比较n个字节的长度
相同的返回0,不同的返回差值.
//& & int *p1 = malloc(4);
//& & *p1 = 8 ;
//& & int *p2 = malloc(4);
//& & *p2 = 3;
//& & int result = memcmp(p1, p2, 1);
//& & printf(&%d \n&,result);
& & int *p1 , *p2;
& & p1 = malloc(3 * sizeof(int));
& & p2 = calloc(3 , sizeof(int));
& & memset(p1, 0, 3*sizeof(int));
& & for (int i = 0; i & 3; i++)
& & & & *(p1 + i) = arc4random()%(3 - 1 + 1) + 1;
& & & & *(p2 + i) = arc4random()%(3 - 1 + 1) + 1;
& & & & printf(&%d& %d&,*(p1 + i),*(p2 + i));
//& & & & *(p1 + i) = 1;
//& & & & *(p2 + i) = 1;
& & & & printf(&\n&);
& & if (memcmp(p1, p2, 16)==0)
& & & & printf(&good\n&);
& & & & printf(&Failed\n&);
& & free(p1);
& & free(p2);
& & p1 = p2 = NULL;
版权声明：本文为博主原创文章，未经博主允许不得转载。
标签：&&&&&&&&&&&&
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！