面试荅案参考汇总

1. static全局变量与普通的全局变量有什么区别 ?

　全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。

　　全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。

　　这两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态

全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件

内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。 

static全局变量只初使化一次，防止在其他文件单元中被引用; 　 

2.  static局部变量和普通局部变量有什么区别 ？

 　　把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期，没有改变他的作用范围（本函数体有效）。把全局变量改变为静态变量后

是改变了它的作用域，限制了它的使用范围（只限本文件）。  

　　static局部变量只被初始化一次，下一次依据上一次结果值； 　 

3.  static函数与普通函数有什么区别？

　　 static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static修饰的函数)，内部函数应该在当前源文件中说明

和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件.

static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。

栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置

于处理器的指令集中，效率很高，但是分配的内存容量有限。

堆区：亦称动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在适当的时候用free或delete释放内存。

动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存。 但是，良好的编程习惯是：如果某动态内存

不再使用，需要将其释放掉，否则，我们认为发生了内存泄漏现象。

碎片问题：
   对于堆，频繁的new/delete会造成大量碎片，使程序效率降低。
   对于栈，它是一个先进后出的队列，进出一一对应，不会产生碎片。

生长方向：
   堆向上，向高地址方向增长。
   栈向下，向低地址方向增长。

分配方式：
   堆都是动态分配（没有静态分配的堆）。

   栈有静态分配和动态分配，静态分配由编译器完成（如局部变量分配），动态分配由alloca函数分配，但栈的动态分配的资源由编译器进行释放，

无需程序员实现。

分配效率：
   堆由C/C++函数库提供，机制很复杂。所以堆的效率比栈低很多。

   栈是极其系统提供的数据结构，计算机在底层对栈提供支持，分配专门寄存器存放栈地址，栈操作有专门指令

补充：网上一个很好的总结

 C语言中使用静态函数的好处：
      静态函数会被自动分配在一个一直使用的存储区，直到退出应用程序实例，避免了调用函数时压栈出栈，速度快很多。 
      关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。 使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。 
c语言中static的语义1.static变量:1).局部a.静态局部变量在函数内定义,生存期为整个源程序，但作用域与自动变量相同，只能在定义该变量的函数内使用。退出该函数后， 尽管该变量还继续存在，但不能使用它。b.对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。2).全局全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。但是他们的作用域，非静态全局 变量的作用域是整个源程序（多个源文件可以共同使用）； 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。2.static函数（也叫内部函数）只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用。区别于一般的非静态函数（外部函数）     static在c里面可以用来修饰变量，也可以用来修饰函数。         先看用来修饰变量的时候。变量在c里面可分为存在全局数据区、栈和堆里。其实我们平时所说的堆栈是栈而不包含对，不要弄混。

单链表逆置

#include "stdafx.h"
#include<iostream>  
using namespace std;  
const int N=6;  
typedef int DataType;//类型定义
typedef struct node{ //单链表  
	DataType data;  
	struct node* next;  
}LinkedNode,*LinkList;  
/****由数组创建单链表****/  
LinkList CreateList(DataType a[N])  
{   
	LinkedNode* ListHead=new LinkedNode();  
	ListHead->data=a[0];  
	ListHead->next=NULL;  
	for(int i=N-1;i>=1;i--)  
	{  
		LinkedNode* p=new LinkedNode();  
		p->data=a[i];  
		p->next=ListHead->next;  
		ListHead->next=p;  
	}  
	return ListHead;  
}  
/****输出单链表****/  
void PrintList(LinkList ListHead)  
{  
	if(NULL==ListHead)cout<<"The List is empty!"<<endl;  
	else  
	{  
		LinkedNode* p=ListHead;  
		while(p!=NULL)  
		{  
			cout<<p->data<<" ";  
			p=p->next;  
		}  
		cout<<endl;  
	}  
}  
void ReverseList(LinkedNode* pCur,LinkList& ListHead)  
{  
	if( (NULL==pCur)||(NULL==pCur->next) )  
	{  
		ListHead=pCur;  
	}  
	else  
	{  
		LinkedNode* pNext=pCur->next;  
		ReverseList(pNext,ListHead); //递归逆置后继结点  
		pNext->next=pCur;            //将后继结点指向当前结点。  
		pCur->next=NULL;  
	}  

	static int nihao;
}  
int _tmain(int argc, _TCHAR* argv[])
{  
	int a[N]={1,2,3,4,5,6};   
	LinkedNode* list=CreateList(a);  
	PrintList(list);  
	LinkedNode*pTemp=list;  
	ReverseList(pTemp,list);  
	PrintList(list); 

	int i,j;
	
	printf("\nthe stack top is near %p\n%p", &i,&j);

	//地址对齐
	union{
		char a[10];
		int i;
	}u;

	int *p = (int *)&(u.a[1]);
	*p = 17;
	int b = 10;
	int aa[3];
	int c = 11;
	cout<<endl;
	cout<<int(aa + 1) - int(aa)<<endl;
	cout<<int(&aa + 1) - int(aa)<<endl;
	cout<<"sizeof int(&aa + 1) = "<<int(&aa + 1)<<endl;
	cout<<"sizeof int(aa) = "<<int(aa)<<endl;
	cout<<"(&aa + 1) = "<<*(&aa + 1)<<endl;

	return 0;  
}  

最大熵阈值分割算法

熵代表了最不确定性的情况，众所周知，一般来说分类问题越靠近两类的边界，则分布的不确定性就越大。