c语言内存操作

① c语言内存怎么回收和代码是什么

在C语言中，使用malloc来动态申请内存，申请完后必须释放该空间。如果不手动释放，那么只能等程序运行结束后系统去回收，但在程序运行过程中容易造成内存溢出的问题，所以应该使用free(void*)来手动释放申请的空间，这样可以保证程序的健壮性。案例如下：x0dx0a #include "stdio.h"x0dx0a #include "stdlib.h"x0dx0a #include "string.h"x0dx0a void main()x0dx0a {x0dx0a //申请20个字节空间x0dx0a char *str = (char*)malloc(20);x0dx0a //将空间内容设置为\0x0dx0a memset(str, '\0', 20);x0dx0a //为每个字节空间赋值x0dx0a char *p = str;x0dx0a for (int i = 0; i < 10; i++)x0dx0a {x0dx0a *p++ = 'a' + i;x0dx0a }x0dx0a printf("str=%s\n",str);x0dx0a //释放申请的空间，交回给系统x0dx0a free(str);x0dx0a }x0dx0a运行结果为：x0dx0astr=abcdefghijx0dx0aPress any key to continuex0dx0a x0dx0a这个案例很简单，但也很能说明问题，我想应该对你帮助，呵呵。x0dx0a x0dx0a补充：在C++中，动态申请空间使用new方法（new方法底层调用的其实是malloc方法），释放时使用delete方法（底层调用的是free）。

② c语言 怎么读内存数据

分配内存空间然后读取

#include<stdio.h>

#include<stdlib.h>

intfilelength(FILE*fp);

char*readfile(char*path);

intmain(void)

{

FILE*fp;

char*string;

string=readfile("c:/c.c");

printf("读入完毕 按任意键释放内存资源 ");

//printf("%s ",string);

system("pause");

return0;

}

char*readfile(char*path)

{

FILE*fp;

intlength;

char*ch;

if((fp=fopen(path,"r"))==NULL)

{

printf("openfile%serror. ",path);

exit(0);

}

length=filelength(fp);

ch=(char*)malloc(length);

fread(ch,length,1,fp);

*(ch+length-1)='';

returnch;

}

intfilelength(FILE*fp)

{

intnum;

fseek(fp,0,SEEK_END);

num=ftell(fp);

fseek(fp,0,SEEK_SET);

returnnum;

}

(2)c语言内存操作扩展阅读

cLinux进程间通信共享内存：

#include"comm.h"

staticintcommShm(intsize,intflags)//创建共享内存

{

key_tkey=ftok(PATHNAME,PROJ_ID);

if(key<0){

perror("ftok");

return-1;

}

intshmid=shmget(key,size,flags);

if(shmid<0){

perror("shmget");

return-2;

}

returnshmid;

}

intcreateShm(intsize)

{

returncommShm(size,IPC_CREAT|IPC_EXCL);

}

intgetShm(intsize)//获取共享内存

{

returncommShm(size,IPC_CREAT);

}

intdestoryShm(intshmid)//销毁共享内存

{

if(shmctl(shmid,IPC_RMID,NULL)<0){

perror("shmctl");

return-3;

}

}

③ C语言中分配内存

要实现根据程序的需要动态分配存储空间，就必须用到以下几个函数
1、malloc函数
malloc函数的原型为：
void
*malloc
(u
igned
int
size)
其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。还有一点必须注意的是，当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为NULL并执行相应的操作。
下例是一个动态分配的程序：
#include
#include
main()
{
int
count,*array;
/*count是一个计数器，array是一个整型指针，也可以理解为指向一个整型数组的首地址*/
if((array(int
*)
malloc(10*sizeof(int)))==NULL)
{
printf("不能成功分配存储空间。");
exit(1);
}
for
(count=0;count〈10;count++)
/*给数组赋值*/
array[count]=count;
for(count=0;count〈10;count++)
/*打印数组元素*/
printf("%2d",array[count]);
}
上例中动态分配了10个整型存储区域，然后进行赋值并打印。例中if((array(int
*)
malloc(10*sizeof(int)))==NULL)语句可以分为以下几步：
1）分配10个整型的连续存储空间，并返回一个指向其起始地址的整型指针
2）把此整型指针地址赋给array
3）检测返回值是否为NULL
2、free函数
由于内存区域总是有限的，不能不限制地分配下去，而且一个程序要尽量节省资源，所以当所分配的内存区域不用时，就要释放它，以便其它的变量或者程序使用。这时我们就要用到free函数。
其函数原型是：
void
free(void
*p)
作用是释放指针p所指向的内存区。
其参数p必须是先前调用malloc函数或calloc函数（另一个动态分配存储区域的函数）时返回的指针。给free函数传递其它的值很可能造成死机或其它灾难性的后果。
注意：这里重要的是指针的值，而不是用来申请动态内存的指针本身。例：
int
*p1,*p2;
p1=malloc(10*sizeof(int));
p2=p1;
……
free(p2)
/*或者free(p2)*/
malloc返回值赋给p1，又把p1的值赋给p2，所以此时p1，p2都可作为free函数的参数。
malloc函数是对存储区域进行分配的。
free函数是释放已经不用的内存区域的。
所以由这两个函数就可以实现对内存区域进行动态分配并进行简单的管理了。

④ C语言问题：内存的分配方式有哪几种

1、静态存储区分配

内存分配在程序编译之前完成，且在程序的整个运行期间都存在，例如全局变量、静态变量等。

2、栈上分配

在函数执行时，函数内的局部变量的存储单元在栈上创建，函数执行结束时这些存储单元自动释放。

3、堆上分配

堆分配（又称动态内存分配）。程序在运行时用malloc或者new申请内存，程序员自己用free或者delete释放，动态内存的生存期由我们自己决定。

(4)c语言内存操作扩展阅读

栈上分配数组

#include<iostream>

usingnamespacestd;

voidmain()

{

int**arr=NULL;//int型二维数组

introws,columns;

cin>>rows;//2

cin>>columns;//3

//请在此处编写代码，根据rows和columns在栈上分配一个数组arr

...你的代码...

//赋值给数组元素

for(introwIndex=0;rowIndex<rows;rowIndex++)

{

for(intcolumnIndex=0;columnIndex<columns;columnIndex++)

{

arr[rowIndex][columnIndex]=columnIndex+(rowIndex+1)*1000+1;

}

}

//打印每个数组元素

for(rowIndex=0;rowIndex<rows;rowIndex++)

{

for(intcolumnIndex=0;columnIndex<columns;columnIndex++)

{

printf("%d",arr[rowIndex][columnIndex]);

}

printf(" ");

}

}

⑤ 内存释放的时候具体进行了什么操作（C语言）

当你用malloc或者calloc申请内存之后，这部分内存会用于存储特定的数据，而无法被其他的变量使用。而当你如果不释放，可能会引起内存占用过多。而如果内存占用过多的话，可能的结果就是电脑瘫痪。这也就是常说的“内存泄漏”。函数原型为：void
free
(void
*
p)，一般使用为free(p);（p为指向一个已分配空间的指针）。在执行这个语句时，电脑就可以把这部分内存分配给其他变量。也就算是释放了。

⑥ c语言怎么对程序内存进行读写

使用fopen的r方式可以实现读取，用w+方式可以实现写入。
1.fopen的函数原型：FILE * fopen(const char * path,const char * mode);
fopen函数的第一个参数是文件路径，第二个参数是打开方式，有以下几种方式：
r 以只读方式打开文件，该文件必须存在。
r+ 以可读写方式打开文件，该文件必须存在。
rb+ 读写打开一个二进制文件，允许读数据。
rw+ 读写打开一个文本文件，允许读和写。
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）
wb 只写打开或新建一个二进制文件；只允许写数据。
wb+ 读写打开或建立一个二进制文件，允许读和写。
wt+ 读写打开或着建立一个文本文件；允许读写。
at+ 读写打开一个文本文件，允许读或在文本末追加数据。
ab+ 读写打开一个二进制文件，允许读或在文件末追加数据。
上述的形态字符串都可以再加一个b字符，如rb、w+b或ab+等组合，加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。
返回值：文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno中。

⑦ c语言程序运行时 内存问题

以程序的具体执行过程为例来给你讲解，但愿你能理解：
1.程序被打开时，即程序开始运行时，会首先向操作系统请求独占内存空间（一段在程序整个执行过程中都不释放的空间），操作系统会应答请求并分配一段逻辑上连续（其实是将零散的内存空间映射为一段连续的空间）的内存空间给该程序，此时程序得到该段空间的逻辑地址信息，根据地址将程序代码段和数据段装入内存，此时程序载入完成。
2.程序运行中，当某一过程任务需要更大内存空间时，会再次向操作系统发出请求，操作系统会根据请求再次分配内存空间给该程序，当这一过程任务执行完毕后，该内存空间被释放。同时由于操作系统的存储保护，程序在运行过程中只能访问自己所申请的内存空间，不能访问其他程序的内存空间。
3.当程序执行完毕或关闭程序后，该程序所占的所有内存空间都被释放。
当你再次打开程序后，重复上面的过程。
下面对你的问题进行针对性回答：
1.当程序运行时，会调入内存，不同时间运行，程序放在内存的位置也可能不同：每运行一次程序，程序都会重新向操作系统申请内存空间，这时操作系统会分配一段全新的内存空间给程序，故不同时间运行程序，程序在内存中的位置是不同的。
2.使用内存中数据的位置也可能不同:当程序申请内存空间后，操作系统会将所申请的内存空间的地址传给程序，尽管数据的位置不同，但程序知道数据的地址，故程序依然可以根据地址来找到所需要的数据。

⑧ C语言-动态分配内存 malloc & free

需要用一个数组来保存用户的输入，但是却不知道用户会输入多少条数据。

(1) 如果设一个太大的数组，则显得浪费内存
(2) 如果设得太小，又怕不够

问题：如何做到恰好够用、又一点不浪费呢？

系统中存在一个内存管理器(MM, Memory Manager)，它负责管理一堆闲置内存。它被设计用于解决此类问题。

MM提供的服务：应用程序可以向MM申请（借出）一块指定大小的内存，用完之后再释放（还回）。

应用程序在使用malloc时，要把返回值转换成目标类型。

这块内存和数组没有本质区别，用法完全相同。

需要先计算需要多少字节的内存空间

数组举例子：

释放的时候需要注意， 因为在for循环执行之后，p的地址往前移动了10， 所以需要减去10， 然后再释放p，不然会有问题

// 当销毁时只需要free一次，malloc了几个字节就会free几个字节，和char类型还是int类型无关
free(p);

在一个函数中动态分配的内存,在另一个函数中操作这块内存

(1) MM是一个系统级的东西，所有的应用程序都向同一个MM申请内存。

(2) 何为借出？实际上，在内存被借出时，MM只是把它管理的内存标记了一下，表示该段内存已经被占用。比如，它把每一段被占用的内存给记录下来（首地址，长度)
(p0,n0) (p1, n1) (p2, n2) ...

(3) MM非常慷慨：①只要有人 malloc ，它都同意借出 ②你不归还，它永远不会主动要求你 free 。

(4) MM管理的内存区域称为“堆”Heap

这意味着，用户程序应该自觉得及时 free ，以便不耽误别的应用程序的使用。如果有个应用程序不停地 malloc ，而不 free ，那最终会用光MM的内存。当MM没有更多闲置内存时， malloc 返回 NULL ，表示内存已经用完。

再次重申： 应用程序在malloc之后，应该尽早free !

使用原则：需要的时候再申请，不需要的时候立即释放

实际上，MM对借出的内存块进行标识
(p0, n0) (p1, n1) (p2, n2) ...
它内部已经保证任意两块内存不会“交叠”，即不会重叠，不会把一块内存同时借给两个应用程序使用。

所以，每块内存的首地址都是不同的，在 free 的时候只需要指明首地址即可。

对象指的一块内存

示例：用Citizen表示一个市民，用Car表示一个辆车。他起初没有车，但未来可能有一辆车。

怎么样才算“及时”？ “不及时”会怎样？

MM里可用的内存是有限的，你用完了就得尽快还，因为别的应用程序也需要MM的内存。

只借不还，积累到一定程度，MM没有更多内存可用，于是malloc返回NULL。

要还就得全还，否则MM那边处理不了

原因是：MM可能此时没有闲置内存可用。（虽然这种情况一般不会发生）

free之后，该内存交还给MM，该内存不再可用（失效）

不一定要在相同的函数里释放，在应用程序的任意一个角落释放都是有效的。

也就是说：这一块内存被malloc出来之后，完全交给你处置

功能：将 s 中当前位置后面的 n 个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s

参数：

参数：

功能：由 src 所指内存区域复制 n 个字节到 dest 所指内存区域。

memmove() 功能用法和 memcpy()） 一样，区别在于： dest
和 src 所指的内存空间重叠时， memmove() 仍然能处理，不过执行效率比 memcpy() 低一些

⑨ c语言内存有几种分配方式

基本上C程序的元素存储在内存的时候有3种分配策略：
静态分配
如果一个变量声明为全局变量或者是函数的静态变量，这个变量的存储将使用静态分配方式。静态分配的内存一般会被编译器放在数据段或代码段来存储，具体取决于实现。这样做的前提是，在编译时就必须确定变量的大小。 以IA32的x86平台及gcc编译器为例，全局及静态变量放在数据段的低端；全局及静态常量放在代码段的高端
自动分配
函数的自动局部变量应该随着函数的返回会自动释放（失效），这个要求在一般的体系中都是利用栈（Stack）来满足的。相比于静态分配，这时候，就不必绝对要求这个变量在编译时就必须确定变量的大小，运行时才决定也不迟，但是C89仍然要求在编译时就要确定，而C99放松了这个限制。但无论是C89还是C99，都不允许一个已经分配的自动变量运行时改变大小。
所以说C函数永远不应该返回一个局部变量的地址。
要指出的是，自动分配也属于动态分配，甚至可以用alloca函数来像分配堆（Heap）一样进行分配，而且释放是自动的。
动态分配
还有一种更加特殊的情况，变量的大小在运行时有可能改变，或者虽然单个变量大小不变，变量的数目却有很大弹性，不能静态分配或者自动分配，这时候可以使用堆（Heap）来满足要求。ANSI C定义的堆操作函数是malloc、calloc、realloc和free。
使用堆（Heap）内存将带来额外的开销和风险。

⑩ C语言中是如何释放内存单元的；原理又是什么

C管理内存大致可以理解为两种，分配在栈上的，一个是分配在堆上的。

临时变量，动态变量，分配在栈上，运行完，直接弹出栈，就没了。
分配在堆上的内存，释放的时候，基本上可以理解为，指针不指这里了。也就失去了对这块内存的控制。其实所谓的释放。字面意思容易让人理解错。
有些机器有些操作系统，会在释放的时候清空这段内存，但是这种做法效率不高，但是安全，很少有机器这么做，多数都是所谓释放，就是不让你控制这块内存了而已。