2023/3/27 作业

作业：多文件编译

1.在堆区申请2个字符类型的大小为20字节的空间。

1> 定义函数，实现在堆区申请空间

2> 定义函数，输入两个字符串

3> 定义函数，计算两个字符串的长度【非函数】

sizeof_t my_strlen(const char *s1) //注意：sizeof_t是unsigned int的别名

4> 定义函数，实现字符串连接

char *my_strcat(const char *dest,const char *src)

5> 定义函数，实现连接后字符串的冒泡排序【是对字符串的每一个字符进行排序】

void Bubble(char *s)

6> 实现字符串逆置

7> 调用函数释放空间

//头文件
#ifndef N
#define N
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char *create();
char *input(char *p);
int my_strlen(const char *s1);
char *my_strcat(char *dest, const char *src);
void Bubble(char *s);
void nizhi(char *p);
char * free_space(char *p);
#endif

//main 文件
#include "head.h"

int main()
{
	char *p = create();
	char *q = create();
	printf("%p %p\n", p, q);
	printf("请输入第一个字符串：");
	input(p);
	printf("请输入第二个字符串：");
	input(q);
	int len_p = my_strlen(p);
	int len_q = my_strlen(q);
	my_strcat(p, q);	
	Bubble(p);
	nizhi(p);	
	p = free_space(p);
	q = free_space(q);
}

//函数文件 
#include "head.h"
/*
 * function:    向内存申请20字节大小内存
 * @param [ in] 
 * @param [out] 
 * @return      返回申请成功的内存首地址
 */
char *create()
{
	char *p = (char *)malloc(sizeof(char)*20);
	if(p == NULL)
	{
		return NULL;
	}
	return p;
}
/*
 * function:    输入字符串
 * @param [ in] 
 * @param [out] 
 * @return      
 */
char *input(char *p)
{
	scanf("%s", p);
}
/*
 * function:    计算字符串长度
 * @param [ in] 
 * @param [out] 
 * @return      返回 长度
 */
int my_strlen(const char *s1)
{
	int len=0;
	while(*s1 !='\0')
	{
		len++;
		s1++;
	}
	return len;
}
/*
 * function:    连接字符串
 * @param [ in] 
 * @param [out] 
 * @return      返回连接成功后的字符串
 */
char *my_strcat(char *dest, const char *src)
{
	while(*dest !='\0')
	{
		dest++;
	}
	while((*dest = *src) !='\0')
	{
		dest++;
		src++;
	}
	return dest;
}
/*
 * function:    字符串冒泡排序
 * @param [ in] 
 * @param [out] 
 * @return      返回排序结果
 */
void Bubble(char *s)
{
	int len = 0;
	int i, j;
	char temp;
	len = my_strlen(s);
	for(i=1; i<len; i++)
	{
		for(j=0; j<len-i; j++)
		{
			if(s[j] > s[j+1])
			{
				temp = s[j];
				s[j] = s[j+1];
				s[j+1] = temp;
			}
		}
	}
	for(i=0; i<len; i++)
	{
		printf("%c\t", s[i]);
	}

}
/*
 * function:    逆置 
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void nizhi(char *p)
{
	int len = my_strlen(p);
	char *start = p;
	char *end = len-1+p;
	
	while(start < end)
	{
		char temp = *start;
		*start = *end;
		*end = temp;
		start++;
		end--;

	}
}
/*
 * function:    释放内存
 * @param [ in] 
 * @param [out] 
 * @return      
 */
char * free_space(char *p)
{
	if(p == NULL)
	{
		return NULL;
	}
	free(p);
	p = NULL;
	return p;
}