ds_day01

作业1

题目：

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

1. 定义函数，实现在堆区申请空间
2. 定义函数，输入两个字符串
3. 定义函数，计算两个字符串的长度【非函数】
   sizeof_t my_strlen(const char *s1) //注意：sizeof_t 是 unsigned int 的别名
4. 定义函数，实现字符串连接
   char *my_strcat(char *dest,const char *src)
5. 定义函数，实现连接后字符串的冒泡排序【是对字符串的每一个字符进行排序】
   void Bubble(char *s)
6. 实现字符串逆置
7. 调用函数释放空间

结果：

代码：

mian.c

#include <stdio.h>
#include "func.h"

int main(int argc, char const *argv[])
{
    // 定义函数，实现在堆区申请空间
    char *str1 = get_space(20);
    char *str2 = get_space(20);

    // 定义函数，输入两个字符串
    input_str(str1);
    input_str(str2);

    // 定义函数，计算两个字符串的长度【非函数】
    printf("str1 len =  %d\n",my_strlen(str1));
    printf("str2 len =  %d\n",my_strlen(str2));

    // 定义函数，实现字符串连接
    my_strcat(str1,str2);
    printf("After my_strcat: %s\n",str1);

    // 定义函数，实现连接后字符串的冒泡排序【是对字符串的每一个字符进行排序】
    Bubble(str1);
    printf("After bubble sort: %s\n",str1);

    // 实现字符串逆置 
    str_reverse(str1);
    printf("After str_reverse: %s\n",str1);

    // 调用函数释放空间
    str1 = free_space(str1);
    str2 = free_space(str2);

    return 0;
}

func.h

#ifndef N
#define N 5

#define sizeof_t unsigned  int

char *get_space(int n);
void input_str(char *p);
sizeof_t my_strlen(const char *s1);
char *my_strcat(char *dest,const char *src);
void Bubble(char *s);
void str_reverse(char *s);
char *free_space(char *s);

#endif

func.c

#include <stdio.h>
#include <stdlib.h>
#include "func.h"

/*
* function:    在堆区申请空间 
* @param [ in] n = 字节数
* @param [out]
* @return      成功返回堆区首地址，失败返回NULL
*/
char *get_space(int n){
    char *p =(char *)malloc(n);

    if(p == NULL){
        return NULL;
    }
    return p;
}

/*
* function:    字符串输入
* @param [ in] char *p = 字符串首地址
* @param [out]
* @return      
*/
void input_str(char *p){
    printf("请输入一个字符串：");
    scanf("%s",p);
}

/*
* function:    字符串长度
* @param [ in] const char *s1 = 字符串首地址
* @param [out]
* @return      
*/
sizeof_t my_strlen(const char *s1){
    int len;
    for (len = 0; s1[len] != '\0'; len++);
    return len;
}

/*
* function:    字符串连接
* @param [ in] 
                char *dest = 目标字符串首地址
                const char *src = 源字符串首地址
* @param [out]
* @return       const char * = 目标字符串首地址
*/
char *my_strcat(char *dest,const char *src){
    char *p = dest + my_strlen(dest);

    while(*p++ = *src++);

    return dest;
}

/*
* function:    冒泡排序
* @param [ in] char *s = 字符串首地址
* @param [out]
* @return      
*/
void Bubble(char *s){
    int len = my_strlen(s);
    for (int i = 0; i < len - 1; i++){
        for (int j = 0; j < len - 1 - i; j++){
            if(s[j] > s[j+1]){
                char temp = s[j];
                s[j] = s[j+1];
                s[j+1] = temp;
            }
        }
    }
}

/*
* function:    字符串逆置
* @param [ in] char *s = 字符串首地址
* @param [out]
* @return      
*/
void str_reverse(char *s){
    int len = my_strlen(s);

    for (int i = 0,j = len - 1; i < j; i++, j--){
        char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
}


/*
* function:    释放空间
* @param [ in] char *s = 字符串首地址
* @param [out]
* @return      
*/
char * free_space(char *s){
    if(s == NULL){
        return NULL;
    }
    free(s);
    s = NULL;

    return s;
}