嵌入式 C 编程必备(10)：探索strcat函数的非典型应用与内存管理策

char *strcat(char *dest, const char *src);

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

int main() {
    char dest[20] = "Hello"; // 目标字符串，初始化为"Hello"
    char src[] = " World";   // 源字符串，为" World"

    // 使用strcat函数将src拼接到dest的末尾
    strcat(dest, src);

    // 输出拼接后的字符串
    printf("拼接后的字符串: %s\n", dest);

    return 0;
}

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

#define MAX_CMD_LENGTH 50

void buildConfigCmd(char *cmd, int sampleFreq, int precisionMode) {
    char freqStr[10];
    char modeStr[10];
    
    // 将采样频率和精度模式转换为字符串
    snprintf(freqStr, sizeof(freqStr), "%d", sampleFreq);
    snprintf(modeStr, sizeof(modeStr), "%d", precisionMode);
    
    // 初始化指令字符串
    strncpy(cmd, "SET_CONFIG ", MAX_CMD_LENGTH);
    
    // 拼接采样频率、空格和精度模式
    strncat(cmd, freqStr, MAX_CMD_LENGTH - strlen(cmd) - 1);
    strncat(cmd, " ", MAX_CMD_LENGTH - strlen(cmd) - 1);
    strncat(cmd, modeStr, MAX_CMD_LENGTH - strlen(cmd) - 1);
    
    // 确保字符串以空字符结尾（理论上strncpy和strncat已经保证了这一点，但增加一层保险）
    cmd[MAX_CMD_LENGTH - 1] = '\0';
}

int main() {
    char configCmd[MAX_CMD_LENGTH];
    buildConfigCmd(configCmd, 100, 2);
    printf("生成的配置指令: %s\n", configCmd);
    return 0;
}

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

#define MAX_LOG_LENGTH 100

void logEvent(char *log, const char *eventType, int dataValue) {
    char timeStr[20];
    char dataStr[10];
    time_t currentTime = time(NULL);
    struct tm *localTime = localtime(&currentTime);
    
    // 格式化时间戳
    strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localTime);
    
    // 将数据值转换为字符串
    snprintf(dataStr, sizeof(dataStr), "%d", dataValue);
    
    // 初始化日志字符串
    strncpy(log, timeStr, MAX_LOG_LENGTH);
    
    // 拼接事件类型和数据值
    strncat(log, " - ", MAX_LOG_LENGTH - strlen(log) - 1);
    strncat(log, eventType, MAX_LOG_LENGTH - strlen(log) - 1);
    strncat(log, " - ", MAX_LOG_LENGTH - strlen(log) - 1);
    strncat(log, dataStr, MAX_LOG_LENGTH - strlen(log) - 1);
    
    // 确保字符串以空字符结尾（理论上strncpy和strncat已经保证了这一点，但增加一层保险）
    log[MAX_LOG_LENGTH - 1] = '\0';
}

int main() {
    char logEntry[MAX_LOG_LENGTH];
    logEvent(logEntry, "DATA_UPDATE", 42);
    printf("日志记录: %s\n", logEntry);
    return 0;
}

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

int main() {
    char dest[10];  // 目标字符串，空间太小，不足以容纳要拼接的字符串
    const char *src = "Hello, World!";  // 源字符串

    // 未进行边界检查，也未预分配足够的内存
    strcat(dest, src);

    // 这将导致缓冲区溢出，因为dest的空间不足以容纳src的内容
    printf("%s\n", dest);

    return 0;
}

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

int main() {
    const char *initial_dest = "Init";  // 初始目标字符串
    const char *src = "Hello, World!";  // 源字符串
    size_t initial_len = strlen(initial_dest);
    size_t src_len = strlen(src);
    size_t total_len = initial_len + src_len + 1;  // +1 是为了容纳结尾的空字符

    // 动态分配足够的内存
    char *dest = (char *)malloc(total_len * sizeof(char));
    if (dest == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        return 1;
    }

    // 复制初始目标字符串到动态分配的内存中
    strcpy(dest, initial_dest);

    // 进行边界检查后的字符串拼接
    if (total_len - strlen(dest) >= src_len + 1) {
        strcat(dest, src);
    } else {
        fprintf(stderr, "Not enough space in dest for concatenation\n");
        free(dest);
        return 1;
    }

    // 打印结果
    printf("%s\n", dest);

    // 释放动态分配的内存
    free(dest);

    return 0;
}