C语言学习记录—进阶作业5（动态内存函数）

1. 关于动态内存相关函数说法错误的是：（    ）

A.malloc函数和calloc函数的功能是相似的，都是申请一块连续的空间。
B.malloc函数申请的空间不初始化，calloc函数申请的空间会被初始化为0
C.realloc函数可以调整动态申请内存的大小，可大可小
D.free函数不可以释放realloc调整后的空间
答案：D - 上面提到的3个开辟空间的函数都可以使用free释放
 

2. 关于动态内存函数的说法错误的是：（   ）

A.malloc函数向内存申请一块连续的空间，并返回起始地址
B.malloc申请空间失败，返回NULL指针
C.malloc可以向内存申请0字节的空间
D.malloc申请的内存空间，不进行释放也不会对程序有影响
答案：CD - C选项申请0字节是标准未定义的，取决于编译器；D选项不释放会造成内存泄漏
 

3. 动态申请的内存在内存的那个区域？（ ）

A.栈区
B.堆区
C.静态区
D.文字常量区
答案：B 栈区放局部变量；静态区放静态变量和全局变量；文字常量区放常量、机器指令
 

4. 关于下面代码描述不正确的是：

void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}
//A.上面代码没问题
//B.上面代码存在内存泄露
//C.上面代码可能会崩溃，即使GetMemory函数返回，str依然为NULL
//D.GetMemory函数无法把malloc开辟的100个字节带回来
//答案：A
//B选项因为malloc开辟后没有free释放；
//C、D选项str指针传进去，形参p是临时拷贝，所以改变p不会影响str，所以str依然为空指针

5. 以下哪个不是动态内存的错误（ ）

A.free参数为NULL
B.对非动态内存的free释放
C.对动态内存的多次释放
D.对动态内存的越界访问
答案：A - 如果参数 ptr 是NULL指针，则函数什么事都不做

6. 关于下面代码描述正确的是（ ）

char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
}
//A.printf函数使用有问题
//B.程序正常打印hello world
//C.GetMemory函数返回的地址无法正常使用
//D.程序存在内存泄露
//答案：C - 数组p是函数内的局部变量，出了函数就销毁了，所以返回的地址是无效地址，即野指针
//D选项没有使用动态内存开辟，不存在泄漏

7. 模拟实现strncpy

#include <assert.h>
#include <string.h>
char* my_strncpy(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;

	while (*dest = *src)
	{
		dest++;
		src++;
		count--;
		if (count == 0)
		{
			break;
		}
	}
	while (count)
	{
		*dest = '\0';
		dest++;
		count--;
	}
	return ret;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "123";

	char* p = my_strncpy(arr1, arr2, 5);
	//char* p = strncpy(arr1, arr2, 5);
	printf("%s\n", p);

	return 0;
}
//库函数实现
char* std_strncpy(char* dest, const char* source, size_t count)
{
	char* start = dest;

	//count为0时表示拷贝完，源字符串拷贝到\0时，说明拷贝完

	while (count && (*dest++ = *source++) != '\0')    
		count--;
	//上方已经把\0拷贝了，所以下面循环需要--count(先--后使用)，即少循环一次(count-1次)
	if (count)                              
		while (--count)
			*dest++ = '\0';

	return(start);
}

8. 模拟实现strncat

#include <assert.h>
char* my_strncat(char* front, const char* back, size_t count)
{
	assert(front && back);
	char* ret = front;
	while (*front != '\0')
	{
		front++;
	}

	while (count != 0 && (*front = *back))
	{
		front++;
		back++;
		count--;
	}
	return ret;
}
int main()
{
	char arr1[20] = "abcdef";
	char arr2[] = "123";
	char* p = my_strncat(arr1, arr2, 2);
	//char* p = std_strncat(arr1, arr2, 5);
	printf("%s\n", p);
	return 0;
}
//库函数实现
char* std_strncat(char* front, const char* back, size_t count)
{
	char* start = front;
	//找到目标字符串的\0。虽然指向\0为假，循环停止，但front指针依然++
	while (*front++)
		;
	//所以这里要让front指针退回一格，指向\0的位置
	front--;

	//循环count次，如果count为0，循环停止，接着在目标字符串末尾加\0
	//如果count不为0，但源字符串的\0赋值给目标字符串，循环也停止
	while (count--)
		if ((*front++ = *back++) == 0)
			return(start);

	*front = '\0';
	return(start);
}

9. 模拟实现atoi

#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <limits.h>
//1. 空指针
//2. 空字符串
//3. 空格
//4. +-
//5. 越界
//6. 非数字字符

enum Status
{
	VALID,
	INVALID
}sta = INVALID;//默认非法
int my_atoi(const char* str)
{
	int flag = 1;//标记，控制正负号
	//1.空指针
	assert(str);
	//2.空字符串
	if (*str == '\0')
		return 0;//这里返回的是非法0
	//3.空格
	while (isspace(*str))
	{
		str++;
	}
	//4.+-
	if (*str == '+')
	{
		flag = 1;
		str++;
	}
	else if (*str == '-')
	{
		flag = -1;
		str++;
	}
	//6.非数字字符
	//ret如果为整形，那么存进ret的值必然在整型最大最小范围内(超出范围会发生截断)，所以判断超出整形范围无意义
	//int ret = 0;
	long long ret = 0;
	while (*str)
	{
		//判断是否为数字字符
		if (isdigit(*str))//转换过程中，是数字字符才继续转换
		{
			//判断越界
			ret = ret * 10 + flag * (*str - '0');//因为int有正负数，所以flag应该放在这里才能判断负越界
			if (ret > INT_MAX || ret < INT_MIN)
			{
				return 0;
			}
		}
		else
		{
			return (int)ret;//遇到非数字字符，停下，返回已经转换的数字字符
		}
		str++;
	}
	if (*str == '\0')//遇到字符串末尾说明正常转换完
	{
		sta = VALID;
	}
	return (int)ret;
}
int main()
{
	char arr[200] = "-1345";
	int ret = my_atoi(arr);
	if (sta == INVALID)
	{
		printf("非法返回：%d\n", ret);
	}
	else if (sta == VALID)
	{
		printf("合法转换：%d\n", ret);
	}

	//int i = atoi(arr);
	//printf("%d\n", i);
	return 0;
}

10. 找单身狗数

自己方法：

//自己方法：用一个数逐个和其他比较
void Find(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz; i++)
	{
		int count = 0;
		for (j = 0; j < sz; j++)
		{
			if (arr[i]==arr[j])
			{
				count++;
			}
		}
		if (count == 1)
		{
			printf("%d\n", arr[i]);
		}
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Find(arr, sz);
	return 0;
}

老师方法：

思路：
1. 所有数据异或，得到的结果是两个单身狗数按位异或的结果。因为其他相同数据按位异或后结果为0。
2. 查看两个单身狗数按位异或的结果中，从最右边(即最低位)开始找第一次出现不同的是哪一位。以该位作为分组依据。
两个单身狗数按位异或的结果中，0说明两个数该位相同，1说明不同(按位异或，相同为0，相异为1)
将异或后的结果按位与1，如果不等于1就向右移动一位，直到找到1。(按位与同时为1才是1)

假设数据 1, 2, 3, 4, 5, 1, 2, 3, 4, 6
将数据分为两组
1 1 3 3 5
2 2 4 4 6
两组数据分别异或，得到的两个数就是单身狗数

void find_single_dog(int arr[], int sz, int* pd1, int* pd2)
{
	//1. 所有数据异或
	int i = 0;
	int ret = 0;
	for (i = 0; i < sz; i++)
		ret ^= arr[i];

	//2. 计算ret二进制中最右边第几位为1
	int pos = 0;//二进制序列 位
	for (pos = 0; pos < 32; pos++)
        //两个单身狗数按位异或后的第pos位等于1(即最右边开始最低位为1的那一位)
        //找异或后的1目的是找到两个二进制序列不相同的那一位（即第一次出现不同的那一位）
        if (((ret >> pos) & 1) == 1)
			break;
	
	//3. 分组：找到两个单身狗数二进制序列最右边(即最低位)第一次出现不同的那一位。所有数据该位为1的分一组，为0的分一组
	//两个组分别异或，最后结果就是不同的那个数，因为相同数异或为0，任何数异或0等于它本身
	for (i = 0; i < sz; i++)
	{    
        //数组所有元素向右移动pos位（即两个单身狗数二进制序列第一次不同的最低位），
        //等于1的分一组(该位的二进制相异)，等于0的分一组
		if (((arr[i] >> pos) & 1) == 1)
			//分组以后把所有元素异或，得到的就是单身狗数
			*pd1 ^= arr[i];
		else
			*pd2 ^= arr[i];
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int dog1 = 0;//第一个只出现一次的数
	int dog2 = 0;//第2个只出现一次的数
	find_single_dog(arr, sz, &dog1, &dog2);
	printf("%d %d\n", dog1, dog2);

	//先把数组所有数据按位异或，最后得到结果是(5^6)，因为其他数字异或后结果是0（按位异或，相同为0，相异为1）
	//5^6
	//101 - 5 B组 1 1 3 3
	//110 - 6 A组 2 2 4 4
	//011 - 5^6
	//1.最低位分法：看异或后的结果哪一位为1，5^6最低位为1。那么把最低位 为0的分一组，为1的分一组
	//2.第二位分法：5^6第二位为1，说明5和6第二位不同，可以按照第二位是1或是0分法
	//101 - 5 B组 1 1 4 4
	//110 - 6 A组 2 2 3 3
	
	//分组：
	//1. 所有数字异或
	//2. 找出异或的结果数字中哪一位为1，假设这位为n，以这一位分组
	//3. 以第n位为1，分一组；第n位为0分一组

	return 0;
}