C复习（主要复习）

指针和数组

• 指针数组是一个数组，数组的每个元素都是指针。它适用于需要存储多个指针的场景，如字符串数组。
• 数组指针是一个指针，指向一个数组。它适用于需要传递整个数组给函数或处理多维数组的场景。

函数指针：函数指针的定义需要指定函数的返回类型、参数列表以及指针的名称。

//return_type (*pointer_name)(argument_type1, argument_type2, ...);

• return_type：函数返回值的类型。
• pointer_name：函数指针的名称。
• argument_type1, argument_type2, ...：函数参数的类型列表

 sizeof和指针与数组

Strlen和字符数组：

• strlen函数：用于计算字符串的长度，不包括终止符\0。
• 字符数组：用于存储字符串，必须以\0结尾。

库函数模拟实现手撕Memcopy：

void* my_memcpy(void* dest, const void* src, size_t n) {
    if (dest == nullptr || src == nullptr) {
        return nullptr;
    }

    char* d = static_cast<char*>(dest);
    const char* s = static_cast<const char*>(src);

    // 内存重叠检查
    if (d > s && d < s + n) {
        // 从后向前拷贝
        for (size_t i = n; i != 0; --i) {
            d[i - 1] = s[i - 1];
        }
    }
    else {
        // 正常从前向后拷贝
        for (size_t i = 0; i < n; ++i) {
            d[i] = s[i];
        }
    }

    return dest;
}

 实现Mommove:

void* my_memmove(void* destination, const void* source, size_t num) {
    // 如果源和目标指针相同，则无需移动
    if (destination == source) {
        return destination;
    }

    // 将void指针转换为char指针，以便逐字节操作
    char* dest = static_cast<char*>(destination);
    const char* src = static_cast<const char*>(source);

    // 如果源区域在目标区域之前或重叠，则从后向前复制
    if (src < dest && src + num > dest) {
        // 从后向前复制
        for (size_t i = num; i != 0; --i) {
            dest[i - 1] = src[i - 1];
        }
    }
    else {
        // 从前向后复制
        for (size_t i = 0; i < num; ++i) {
            dest[i] = src[i];
        }
    }

    return destination;
}

实现strstr 

char* my_strstr(const char* haystack, const char* needle) {
    // 如果needle是空字符串，根据标准定义，返回haystack
    if (*needle == '\0') {
        return const_cast<char*>(haystack);
    }

    // 获取主串和子串的长度
    size_t haystack_len = strlen(haystack);
    size_t needle_len = strlen(needle);

    // 如果子串长度大于主串长度，肯定找不到
    if (needle_len > haystack_len) {
        return nullptr;
    }

    // 遍历主串，寻找子串的起始位置
    for (size_t i = 0; i <= haystack_len - needle_len; ++i) {
        // 比较子串和主串的对应部分
        size_t j = 0;
        while (j < needle_len && haystack[i + j] == needle[j]) {
            ++j;
        }

        // 如果整个子串都匹配，返回匹配的起始位置
        if (j == needle_len) {
            return const_cast<char*>(haystack + i);
        }
    }

    // 如果没有找到子串，返回nullptr
    return nullptr;
}

自定义类型：内存对齐：

大小端的判断：

bool isLittleEndian() {
    union {
        uint32_t i;
        unsigned char c[4];
    } u;

    u.i = 0x01020304;

    // 检查最低地址的字节是否为最低有效字节
    return (u.c[0] == 0x04);
}

int main() {
    if (isLittleEndian()) {
        cout << "系统是小端字节序。" << endl;
    }
    else {
        cout << "系统是大端字节序。" << endl;
    }

    return 0;
}

解释：

• u.i被赋值为0x01020304。
• 如果系统是小端，u.c[0]将是0x04；如果是大端，u.c[0]将是0x01。
• 根据u.c[0]的值判断字节序。 

这次是对C中我还不清楚并且比较重要的知识进行总结，顺序可能会有点乱，还请见谅