关于内存面试题引发的思考

亦凉 2022-08-08 14:55 219阅读 0赞

题目如下，关于内存的题目一直迷糊：

牵涉知识点：

**1.**值传递，地址传递，引用传递；——C++中值传递，地址传递，引用传递的区别 - 陆郎 - 博客频道 - CSDN.NET  
http://blog.csdn.net/lushujun2011/article/details/6889347

**2.**内存管理方面知识：

内存分配方式有三种：

**从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。**

**从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new**申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活。  
  
**在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。**

1、静态全局变量
 
 在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下： 
 
 //Example 1#include void fn();static int n; //定义静态全局变量void main(){ n=20; cout<<n<<endl; fn();}void="" fn(){="" n++;="" cout<<n<<endl;}
 静态全局变量有以下特点：
 该变量在全局数据区分配内存； 
 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）； 
 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的； 
 静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的分布情况如下图：
 代码区 
 全局数据区 
 堆区 
 栈区 
 
 一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静 态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将 
 
 static int n; //定义静态全局变量
 改为
 int n; //定义全局变量
 程序照样正常运行。
 的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：
 静态全局变量不能被其它文件所用； 
 其它文件中可以定义相同名字的变量，不会发生冲突；
 您可以将上述示例代码改为如下：
 
 
 //Example 2//File1#include void fn();static int n; //定义静态全局变量void main(){ n=20; cout<<n<<endl; fn();}="" file2#include="" extern int n;void fn(){ n++; cout<<n<<endl;}
 编译并运行Example 2，您就会发现上述代码可以分别通过编译，但运行时出现错误。 试着将
 static int n; //定义静态全局变量
 改为
 int n; //定义全局变量
 再次编译运行程序，细心体会全局变量和静态全局变量的区别。
 2、静态局部变量
 
 在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。 
 
 我们先举一个静态局部变量的例子，如下： 
 
 //Example 3#include void fn();void main(){ fn(); fn(); fn();}void fn(){ static n=10; cout<<n<<endl; n++;}
 通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。
 但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。
 静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。
 静态局部变量有以下特点：
 
 该变量在全局数据区分配内存； 
 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化； 
 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0； 
 它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；
 3、静态函数
 
 在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
 
 静态函数的例子： 
 
 //Example 4#include static void fn();//声明静态函数void main(){ fn();}void fn()//定义静态函数{ int n=10; cout<<n<<endl;}
 定义静态函数的好处：
 静态函数不能被其它文件所用； 
 其它文件中可以定义相同名字的函数，不会发生冲突；

<n<<endl; fn();\}void="" fn()\{="" n++;="" cout<<n<<endl;\} 
<n<<endl; fn();\}="" file2\#include="" <n<<endl;\} 
<n<<endl; n++;\} 
<n<<endl;\}

3.**野指针——C语言之free函数及野指针 - hgj125073的专栏 - 博客频道 - CSDN.NET  
http://blog.csdn.net/hgj125073/article/details/8484504**

**何谓“野指针”，在这里补充一下。**

**野指针是指程序员或操作者不能控制的指针。野指针不是NULL指针，而是指向“垃圾”的指针。**

**造成“野指针”的原因主要有**

**1.指针变量没有初始化，任何[指针变量][Link 1]刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。在初始化的时候要么指向合法的指针，要么指向NULL。**

**2.指针变量被free或delete之后，没有设置为NULL。它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。通常会用语句if (p != NULL)进行防错处理。很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，它也不指向合法的内存块。上文DEMO则是这种情况。**

**3.指针操作超越了变量的作用范围。 注意其生命周期。**

试题1：请写一个C函数，若处理器是Big\_endian的，则返回0；若是Little\_endian的，则返回1

解答：

int checkCPU( )

union w

int a;

char b;

\} c;

c.a = 1;

return(c.b ==1);

剖析：

嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。例如，16bit宽的数0x1234在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：

而在Big-endian模式CPU内存中的存放方式则为：

32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：

而在Big-endian模式CPU内存中的存放方式则为：

联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写。如果谁能当场给出这个解答，那简直就是一个天才的程序员。

<table> 
 <tbody> 
 <tr> 
 <td> char str[] =&nbsp;“Hello”&nbsp;; char *p = str ; int n = 10; 请计算 sizeof (str ) = 6&nbsp;（2分） sizeof ( p ) = 4&nbsp;（2分） sizeof ( n ) = 4&nbsp;（2分） </td> 
 <td> void Func ( char str[100]) { 请计算 sizeof( str ) = 4&nbsp;（2分） } </td> 
 </tr> 
 <tr> 
 <td> void *p = malloc( 100 ); 请计算 sizeof ( p ) = 4&nbsp;（2分） </td> 
 </tr> 
 </tbody> 
</table>

3、在C++程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？ （5分）

答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y);

该函数被C编译器编译后在库中的名字为\_foo，而C++编译器则会产生像\_foo\_int\_int之类的名字。

C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。

4.有关内存的思考题

<table style="color:rgb(102,102,102)"> 
 <tbody> 
 <tr> 
 <td> void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } 请问运行Test函数会有什么样的结果？ 答:程序崩溃。 因为GetMemory并不能传递动态内存， Test函数中的&nbsp;str一直都是&nbsp;NULL。 strcpy(str, "hello world");将使<a href="http://www.xker.com/article/articlelist/article_5_adddate_desc_1.htm" style="color:rgb(25,89,155)" rel="nofollow">程序</a>崩溃。 </td> 
 <td> char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); } 请问运行Test函数会有什么样的结果？ 答：可能是乱码。 因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是NULL，但其原现的内容已经被清除，新内容不可知。 </td> 
 </tr> 
 <tr> 
 <td> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; void GetMemory2(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *str = NULL; GetMemory(&amp;str, 100); strcpy(str, "hello"); printf(str); } 请问运行Test函数会有什么样的结果？ 答： （1）能够输出hello （2）内存泄漏 </td> 
 <td> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; void Test(void) { char *str = (char *) malloc(100); strcpy(str,&nbsp;“hello”); free(str); if(str != NULL) { strcpy(str,&nbsp;“world”); printf(str); } } 请问运行Test函数会有什么样的结果？ 答：篡改动态内存区的内容，后果难以预料，非常危险。 因为free(str);之后，str成为野指针， if(str != NULL)语句不起作用。 </td> 
 </tr> 
 </tbody> 
</table>

解释：

**《程序员面试宝典》**

**1 What will happen after running the "Test"?**

**\#include<iostream.h>** 
 
 **void GetMemory(char\*p, int num) 
\{ 
p = (char\*)malloc(sizeof(char) \* num); 
\} 
 
int main() 
\{ 
char\*str = NULL; 
 
GetMemory(str, 100); 
strcpy(str, "hello"); 
 
return0** **; 
\}**

分析：由于void GetMemory(char \*p, int num)中的\*p实际上是主函数中的一个str的一个副本，编译器总是要为函数的每个参数制作临时副本。在本倒中，p申请了新的内存，只是把p把指的内存地址改变了，但str丝毫未变。因为GetMemory没有返回值，因此str并不指向p所申请的那段内存，所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会申请一块内存，但申请的内存却不能有效释放，结果是内存一直被独占，最终造成内存泄露。

答案：程序崩溃。因为GetMemory并不能传递动态内存，Test函数中的str一直都是NULL。

//---------------------------------------------------------------------------------------------------

以下是正常的申请方式：

**方法一：**用指针参数去申请内存时，应用**采用指向指针的指针**，把str的地址传给函数GetMemory

**\#include <iostream.h>** 
 
 **void GetMemory(char\*\*p, int num) 
\{ 
\*p = (char\*)malloc(sizeof(char) \* num); 
\} 
 
int main() 
\{ 
char\*str = NULL; 
 
GetMemory(&str, 100); 
strcpy(str, "hello"); 
 
std::cout <<\*str << std::endl; 
std::cout << str << std::endl; 
std::cout <<&str << std::endl; 
 
return0** **; 
\}**

**方法二：**用**函数返回值为指针类型**来传递动态内存

**\#include<iostream>** 
 
**char\*GetMemory(char\*p, int num) 
\{ 
return p = (char\*)malloc(sizeof(char) \* num); 
\} 
 
int main() 
\{ 
char\*str = NULL; 
 
str = GetMemory(str, 100); 
strcpy(str, "hello"); 
 
std::cout <<\*str << std::endl; 
std::cout << str << std::endl; 
std::cout <<&str << std::endl; 
 
return0****; 
\}**

//------------------------------------------------------------------------------------------------

**What will happen after running the "Test"?**

**\#include<iostream>** 
 
**char\*GetMemory(void) 
\{ 
char p\[\] ="hello world"; 
return p; 
\} 
 
int main() 
\{ 
char\*str = NULL; 
str = GetMemory(); 
std::cout << str << std::endl; 
 
return0****; 
\}**

答案：可能是乱码，也有可能是正常输出。因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是NULL，但其原来的内容已经被清除，新内容不可知。

//------------------------------------------------------------------------------------------------

【内存操作及问题相关知识点】为了能彻底解决动态内存传递的问题,我们回顾一下内存管理的知识要点.  
内存分配方式有三种：

**从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。**

[Link 1]: http://baike.baidu.com/view/379211.htm