1、内存是进程范围or线程范围；____
CPU调度时，针对进程or线程；____（内核线程）
函数调用堆栈，针对进程or线程。____
2、写出内存拷贝函数memcpy的功能实现代码
#include <stdio.h>
#include <assert.h>
void*mymemcpy(void *dest,const void *src,size_t count)
{
char*dest_t=(char*)dest;
char*src_t=(char*)src;
assert(dest!=NULL&&src!=NULL);
if(dest_t>=src_t+count||src_t>=dest_t+count)
{
while(count--)
{
*dest_t++=*src_t++;
}
}
return dest_t;
}
int main(int argc, const char *argv[])
{
char buf[]={"i love"};
char buf1[20]={0};
mymemcpy(buf1,buf,5);
printf("%s\n",buf1);
return 0;
}
3、内存有哪些分配方式，他们的区别是什么？
内存有三种分配方式：
在堆区 程序运行的时候
在栈上 执行函数的时候
在静态区（程序编译时候分配）
栈------->局部变量，或函数参数
堆------->new/delete/malloc/free
.bss----->静态区（未初始化静态变量或全局变量）
.data---->静态区（已经初始化的静态变量或全局变量）
.rodata-->字符串常量
.text---->函数代码段
4、char a[]=”hello”,
int b[100]={0}；
void*p=malloc(sizeof(int)*100)；
const char *strstr(char str[100])
{
}
则下面结果是：
sizeof(a)=_6_
sizeof(b)=__400_
sizeof(p)=_4__
sizeof(str)=_4_.
5、栈与堆的区别
6、当你申请空间失败的时候，该怎么做
7、程序里如何保证内存不泄露
8、ptr1 = (char *)malloc(4);
ptr2= (char *)malloc(100);
ptr3 = (char *)malloc(400);
a = sizeof(ptr1);
b = sizeof(prt2);
c = sizeof(ptr3);问a =4 ，b =4 ，c =4
9、以下程序的正确与否？并说明原因
(1)void Memory_0（char *p）
{
p = (char *)malloc(100);
}
(2)Char *Memory_1(char *p)
{
char p[] = “abcdefgh”;
return p;
}
(3)void Memory_3(char **p)
{
*p = (char **)malloc(100);
}
下面4个例子中存在哪些问题，请一一指出：
(1)、
void GetMemory( char *p )
{
p = (char *) malloc( 100 );
}
void Test( void )
{
char *str = NULL;
GetMemory( str );
strcpy( str, "hello world" );
printf( str );
}
(2)、
char *GetMemory( void )
{
char p[] = "hello world";
return p;
}
void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
(3)、
void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}
void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, "hello" );
printf( str );
}
(4)、
void Test( void )
{
char *str = (char *) malloc( 100 );
strcpy( str, "hello" );
free( str );
... //省略的其它语句
}
(1)、GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完char *str = NULL;GetMemory( str );后的str仍然为NULL；
(2)、char p[] = "hello world"; return p;的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。
(3)、GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句*p = (char *) malloc( num );后未判断内存是否申请成功，应加上：
if ( *p == NULL )
{
...//进行申请内存失败处理
}
(4)、试题4存在与试题3同样的问题，在执行char *str = (char *) malloc(100);后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，导致可能变成一个“野”指针，应加上：
str = NULL;试题3的Test函数中也未对malloc的内存进行释放。
10、写一个安全的内存拷贝的函数
11、以下哪句说法是正确的。
A 在页式存储管理中，用户应将自己的程序划分成若干个相等的页。
B 所有进程都挂起时，系统陷入死锁。
C 执行系统调用可以被中断。
D 进程优先数是进程调度的重要依据，必须根据进程运行情况动态改变。
12、内存对齐指的是什么
(1)内存对齐的主要作用：
1、平台原因(移植原因)
A 不是所有的硬件平台都能访问任意地址上的任意数据的；
B 某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因：
A 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
B 原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
13、程序分析：
char g_c[6];
int g_i1;
int g_i2 = 10;
int main()
{
Int l_i = 89;
return 0;
}
请尝试说明。
（1） 变量g_c， g_il， g_i2, 以及 l_i各自在a.out中的那些段，（text， data， bss…等等…）？
（2） g_c, g_il, g_i2, l_i 各自运行在哪些地址空间中？
14、解答题
写出下面四个函数你认为有问题的地方，并说明原因
int tst_malloc_buf(char *buf)
{
buf = (char *)malloc(128);
if(buf != NULL)
return 0;
return -1;
}
int tst_fill_str(char *buf)
{
if(buf != NULL)
{
sprintf(buf,”hello world!\n”);
return 0;
}
return -1;
}
int tst_free_buf(char *buf)
{
if(buf != NULL)
{
free(buf);
buf = NULL;
}
return 0；
}
int main(int argc, char *argv[])
{
char *buf1 = malloc(128);
if(buf1 != NULL)
{
tst_fill_str(buf1);
printf(“%s\n”,buf1);
tst_free_buf(buf1);
}
char *buf2 = “wuhanzhihuibweiishen”;
tst_fill_str(buf2);
printf(“%s”,buf2);
char *buf3 = NULL;
if(tst_malloc_buf(buf3) == 0)
{
tst_fill_str(buf3);
printf(“%s”,buf3);
}
if(buf 1 != NULL)
{
free（buf1）；
buf1 = NULL;
}
}
15、自己编程实现memcpy函数，void *memcpy(void *dest, const void *src, size_t n)，注意不能产生数据覆盖;
16、数据库存满了，会怎样？
17、memcpy 与 memmove 区别
#include <stdio.h>
#include <assert.h>
void *memmove(void *dest,const void *src,size_t count)
{
char *dest_t=(char*)dest;
char *src_t=(char*)src;
assert(dest_t!=NULL&&src_t!=NULL);
if(dest_t>src_t&&src_t+count>dest_t)
{
dest_t=dest_t+count-1;
src_t=src_t+count-1;
while(count--)
{
*dest_t--=*src_t--;
}
}
else
{
*dest_t++=*src_t++;
}
return dest;
}
int main(int argc, const char *argv[])
{
char buf[]={"i love"};
char buf1[20]={0};
memmove(buf1,buf,6);
printf("%s\n",buf1);
return 0;
}
#include <stdio.h>
#include <assert.h>
void*mymemcpy(void *dest,const void *src,size_t count)
{
char*dest_t=(char*)dest;
char*src_t=(char*)src;
assert(dest!=NULL&&src!=NULL);
if(dest_t>=src_t+count||src_t>=dest_t+count)
{
while(count--)
{
*dest_t++=*src_t++;
}
}
return dest_t;
}
int main(int argc, const char *argv[])
{
char buf[]={"i love"};
char buf1[20]={0};
mymemcpy(buf1,buf,5);
printf("%s\n",buf1);
return 0;
}