经典的4道笔试题

————经典的笔试题
————1请问运行Test 函数会有什么样的结果？
//#include<stdio.h>
//#include<stdlib.h>
//void GetMemory(char* p)//1.改为char**p,也可以不传参，将对应代码块的p改为char**p//2.void改为char*
// //p为形参（形式参数）只可作用于所属函数内部，出了函数外，就被收回。但是malloc开辟的空间并没有被释放，导致内存泄漏
//{
//?? ?p = (char*)malloc(100);//1.改为*p
?return p;//2
//}
//void Test(void)
//{
//?? ?char* str = NULL;
//?? ?GetMemory(str);//改为&str//2.改为str=GetMemory(str)
//?? ?strcpy(str, "hello world");//此时str仍为NULL，因此不可以对其进行解引用，会导致系统崩溃。
//?? ?printf(str);
// ? ?//还要添加释放//1.2
// // free(str);
// // str=NULL;
//}
//int main()
//{
//?? ?Test();
//?? ?return 0;
//}

//——改法1(不传参)
//#include<stdio.h>
//#include<stdlib.h>
//char* GetMemory()
//{
//?? ?char* p = (char*)malloc(100);
//?? ?return p;//2
//}
//void Test(void)
//{
//?? ?char* str = NULL;
//?? ?str = GetMemory();
//?? ?strcpy(str, "hello world");
//?? ?printf(str);
//?? ?free(str);
//?? ?str = NULL;
//}
//int main()
//{
//?? ?Test();
//?? ?return 0;
//}

//——改法2（传参采取返回p地址，并定义变量接收地址）
//#include<stdio.h>
//#include<stdlib.h>
//char* GetMemory(char*p)
//{
//?? ?p = (char*)malloc(100);
//?? ?return p;
//}
//void Test(void)
//{
//?? ?char* str = NULL;
//?? ?str = GetMemory(str);
//?? ?strcpy(str, "hello world");
//?? ?printf(str);
//?? ?free(str);
//?? ?str = NULL;
//}
//int main()
//{
//?? ?Test();
//?? ?return 0;
//}

//——改法3（传参，采取二级指针）
//#include<stdio.h>
//#include<stdlib.h>
//char* GetMemory(char** p)
//{
//?? ?*p = (char*)malloc(100);
//?? ?return p;
//}
//void Test(void)
//{
//?? ?char* str = NULL;
//?? ?GetMemory(&str);
//?? ?strcpy(str, "hello world");
//?? ?printf(str);
//?? ?free(str);
//?? ?str = NULL;
//}
//int main()
//{
//?? ?Test();
//?? ?return 0;
//}
解决办法：把开辟的空间放到str中，之后拷贝就没问题了。而开辟的地址想放到外面的str里去，
? ? ? ? ? ? ?/* 就要把str的地址传给GetMeory函数中。而char*类型的地址就应该放到char**的二级指针里面去，
? ? ? ? ? ? ? p里放的是str的地址，*p就指的是str，即函数GetMeory函数调用完之后，
? ? ? ? ? ? ? str里存放的就是动态开辟的100字节的地址*/

//————2请问运行Test 函数会有什么样的结果？
//#include<stdio.h>
//char* GetMemory()
//{
//?? ?char* p[] = { "hello world" };//p为局部数组，当return p时，表示返回p的首元素地址，
//?? ?//而不是p所指向的内容，即打印时并没有可打印的元素，因为结束结束GetMemory()函数时，
//?? ?// p就不存在了，即p已经将自己的内容归还给系统。从而str中只剩下p的首元素地址，而指向那块内容就不清楚了。
//?? ?return p;//返回栈空间地址的问题
//}
//void Test(void)
//{
//?? ?char* str = NULL;
//?? ?str = GetMemory();//此处的str为野指针，因为str指向的空已经不属于我们了
//?? ?printf(str);
//}
//int main()
//{
//?? ?Test();
//?? ?return 0;
//}
//#include<stdio.h>
//int test()
//{
//?? ?int a = 10;//局部变量放在栈区
//?? ?return &a;//返回栈区空间上的地址，均为临时的，进行返回时的操作是很危险的//返回栈空间地址的问题
//}
//int main()
//{
//?? ?int *p= Test();
//?? ?printf("hehe");//在没有此句调用printf函数时，打印*p还有可能是10.但是此处调用printf时，
//?? ?//就开辟了新的空间，而原始的空间就被覆盖了
//?? ?printf("%d\n", *p);
//?? ?return 0;
//}

//————3请问运行Test 函数会有什么样的结果？
//#include<stdio.h>
//#include<stdlib.h>
//void GetMemory(char** p, int num)
//{
//?? ?*p = (char*)malloc(num);
//}
//void Test(void)
//{
//?? ?char* str = NULL;
//?? ?GetMemory(&str, 100);
//?? ?strcpy(str, "hello");
//?? ?printf(str);
// ?//free(str);//未释放
// ?//str=NULL;
//}
//int main()
//{
//?? ?Test();
//?? ?return 0;
//}
//————4请问运行Test 函数会有什么样的结果？
#include<stdio.h>
#include<stdlib.h>
void Test(void)
{
?? ?char* str = (char*)malloc(100);
?? ?strcpy(str, "hello");
?? ?free(str);//此时只是把str申请的空间释放，但是str的内容并未改变。
?? ?if (str != NULL)//因此此处可进入循环
?? ?{
?? ??? ?strcpy(str, "world");//但是此处的str只含有内容，并没有地址（或空间），即str为野指针
?? ??? ?printf(str);//野指针不可以进行任何操作。
?? ?}
?? ?str = NULL;
}
int main()
{
?? ?Test();
?? ?return 0;
}
?