Tự cài lại thư viện chuỗi

#ifndef MYSTRING_H
#define MYSTRING_H

#include <stddef.h>

size_t my_strlen(const char *s);
char  *my_strcpy(char *dich, const char *nguon);
char  *my_strcat(char *dich, const char *nguon);
int    my_strcmp(const char *a, const char *b);
int    my_strncmp(const char *a, const char *b, size_t n);
char  *my_strchr(const char *s, int c);
char  *my_strrchr(const char *s, int c);
char  *my_strstr(const char *lon, const char *nho);

#endif

#include "mystring.h"

size_t my_strlen(const char *s)
{
    const char *p = s;

    while (*p != '\0')
        ++p;

    return (size_t)(p - s);
}

char *my_strcpy(char *dich, const char *nguon)
{
    size_t i = 0;

    while (nguon[i] != '\0') {
        dich[i] = nguon[i];
        ++i;
    }

    dich[i] = '\0';

    return dich;
}

char *my_strcat(char *dich, const char *nguon)
{
    size_t d = my_strlen(dich);
    size_t i = 0;

    while (nguon[i] != '\0') {
        dich[d + i] = nguon[i];
        ++i;
    }

    dich[d + i] = '\0';

    return dich;
}

int my_strcmp(const char *a, const char *b)
{
    while (*a != '\0' && *a == *b) {
        ++a;
        ++b;
    }

    return (int)(unsigned char)*a - (int)(unsigned char)*b;
}

int my_strncmp(const char *a, const char *b, size_t n)
{
    for (size_t i = 0; i < n; ++i) {
        unsigned char x = (unsigned char)a[i];
        unsigned char y = (unsigned char)b[i];

        if (x != y)   return (int)x - (int)y;
        if (x == '\0') return 0;      /* cả hai cùng kết thúc */
    }

    return 0;
}

char *my_strchr(const char *s, int c)
{
    char ch = (char)c;

    for (;;) {
        if (*s == ch)   return (char *)s;
        if (*s == '\0') return NULL;

        ++s;
    }
}

char *my_strrchr(const char *s, int c)
{
    char        ch = (char)c;
    const char *kq = NULL;

    for (;;) {
        if (*s == ch)   kq = s;
        if (*s == '\0') break;

        ++s;
    }

    return (char *)kq;
}

char *my_strstr(const char *lon, const char *nho)
{
    if (nho[0] == '\0')
        return (char *)lon;

    for (; *lon != '\0'; ++lon) {
        const char *a = lon;
        const char *b = nho;

        while (*a == *b && *b != '\0') {
            ++a;
            ++b;
        }

        if (*b == '\0')
            return (char *)lon;
    }

    return NULL;
}

#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "mystring.h"

static int so_luot = 0;

#define KT(bieu_thuc)                                          \
    do {                                                       \
        ++so_luot;                                             \
        if (!(bieu_thuc)) {                                    \
            printf("HONG tai dong %d: %s\n", __LINE__, #bieu_thuc); \
            return 1;                                          \
        }                                                      \
    } while (0)

/* So sánh dấu chứ không so giá trị, vì chuẩn chỉ bảo đảm dấu. */
static int cung_dau(int a, int b)
{
    return (a < 0 && b < 0) || (a == 0 && b == 0) || (a > 0 && b > 0);
}

static int kiem_thu_len(void)
{
    const char *mau[] = { "", "a", "hello", "a b c", "\t\n", "xyz123" };

    for (size_t i = 0; i < sizeof mau / sizeof mau[0]; ++i)
        KT(my_strlen(mau[i]) == strlen(mau[i]));

    return 0;
}

static int kiem_thu_cmp(void)
{
    const char *mau[] = { "", "a", "ab", "abc", "abd", "B", "b", "\x80" };
    size_t n = sizeof mau / sizeof mau[0];

    for (size_t i = 0; i < n; ++i)
        for (size_t j = 0; j < n; ++j)
            KT(cung_dau(my_strcmp(mau[i], mau[j]),
                        strcmp(mau[i], mau[j])));

    for (size_t i = 0; i < n; ++i)
        for (size_t j = 0; j < n; ++j)
            for (size_t k = 0; k <= 4; ++k)
                KT(cung_dau(my_strncmp(mau[i], mau[j], k),
                            strncmp(mau[i], mau[j], k)));

    return 0;
}

static int kiem_thu_cpy_cat(void)
{
    char a[64], b[64];

    const char *mau[] = { "", "a", "hello", "xin chao the gioi" };
    size_t n = sizeof mau / sizeof mau[0];

    for (size_t i = 0; i < n; ++i) {
        my_strcpy(a, mau[i]);
        strcpy(b, mau[i]);
        KT(strcmp(a, b) == 0);

        for (size_t j = 0; j < n; ++j) {
            my_strcpy(a, mau[i]);
            strcpy(b, mau[i]);

            my_strcat(a, mau[j]);
            strcat(b, mau[j]);

            KT(strcmp(a, b) == 0);
        }
    }

    return 0;
}

static int kiem_thu_tim(void)
{
    const char *mau[] = { "", "a", "hello", "aaaa", "abcabcabd", "a/b/c.txt" };
    const char  ky_tu[] = { 'a', 'l', 'z', '/', '\0' };

    for (size_t i = 0; i < sizeof mau / sizeof mau[0]; ++i) {
        for (size_t j = 0; j < sizeof ky_tu / sizeof ky_tu[0]; ++j) {
            KT(my_strchr(mau[i], ky_tu[j])  == strchr(mau[i], ky_tu[j]));
            KT(my_strrchr(mau[i], ky_tu[j]) == strrchr(mau[i], ky_tu[j]));
        }

        for (size_t j = 0; j < sizeof mau / sizeof mau[0]; ++j)
            KT(my_strstr(mau[i], mau[j]) == strstr(mau[i], mau[j]));
    }

    return 0;
}

int main(void)
{
    if (kiem_thu_len())     return 1;
    if (kiem_thu_cmp())     return 1;
    if (kiem_thu_cpy_cat()) return 1;
    if (kiem_thu_tim())     return 1;

    printf("Tat ca %d luot kiem thu deu qua\n", so_luot);

    return 0;
}

#include <ctype.h>
#include <string.h>

/* 1. Xóa khoảng trắng ở hai đầu, sửa tại chỗ. Trả về con trỏ tới đầu mới. */
char *cat_trang(char *s)
{
    while (isspace((unsigned char)*s))
        ++s;

    if (*s == '\0') return s;      /* toàn khoảng trắng */

    char *cuoi = s + strlen(s) - 1;

    while (cuoi > s && isspace((unsigned char)*cuoi))
        --cuoi;

    cuoi[1] = '\0';

    return s;
}

/* 2. Chuyển thành chữ thường tại chỗ. */
char *ha_thap(char *s)
{
    for (char *p = s; *p != '\0'; ++p)
        *p = (char)tolower((unsigned char)*p);

    return s;
}

/* 3. Đảo ngược chuỗi tại chỗ. */
char *dao_nguoc(char *s)
{
    size_t n = strlen(s);

    for (size_t i = 0; i + 1 < n - i; ++i) {
        char t = s[i];

        s[i] = s[n - 1 - i];
        s[n - 1 - i] = t;
    }

    return s;
}

/* 4. Kiểm tra chuỗi có bắt đầu bằng tiền tố cho trước. */
int bat_dau_bang(const char *s, const char *tien_to)
{
    return strncmp(s, tien_to, strlen(tien_to)) == 0;
}

/* Kiểm tra chuỗi có kết thúc bằng hậu tố cho trước. */
int ket_thuc_bang(const char *s, const char *hau_to)
{
    size_t ls = strlen(s);
    size_t lh = strlen(hau_to);

    return lh <= ls && strcmp(s + ls - lh, hau_to) == 0;
}