字符串复制函数strcpy()和strncpy()详解

byte轻骑兵

发布于 2026-01-20 17:08:29

2030

在 C 语言开发中，字符串操作是核心场景之一，而strcpy()与strncpy()作为字符串复制的基础函数，贯穿于各类项目中。但这两个函数的使用细节与安全隐患常常被忽视，导致缓冲区溢出、字符串截断等问题。本文从函数本质出发，结合原理分析、代码实现与实战案例，彻底掌握这两个函数的用法与避坑指南。

一、函数简介

在 C 标准库（<string.h>）中，strcpy()与strncpy()均用于实现字符串的复制，但设计目标与安全特性存在显著差异，二者的定位可概括为：

1.1 strcpy ()：“简单直接” 的复制工具

strcpy()（string copy，字符串复制）是最基础的字符串复制函数，核心功能是将源字符串（src）的内容完整复制到目标字符串（dest）中，直到遇到源字符串的结束符'\0'为止。

它的设计理念是 “极简”—— 不需要指定复制长度，自动以'\0'作为终止信号。但这种 “自动化” 也带来了隐患：如果目标缓冲区不足以容纳源字符串，会直接导致缓冲区溢出，破坏相邻内存数据，甚至引发程序崩溃或安全漏洞。

1.2 strncpy ()：“可控长度” 的安全改进

strncpy()（string n copy，指定长度字符串复制）是为解决strcpy()的安全问题而生的函数。它在strcpy()的基础上增加了 “复制长度限制” 参数n，核心功能是最多复制n个字节的内容从源字符串到目标字符串。

它的设计理念是 “可控”—— 通过限制复制字节数，避免因源字符串过长导致的缓冲区溢出。但需要注意：strncpy()并非 “绝对安全”，其对结束符'\0'的处理逻辑与strcpy()完全不同，误用仍会引发问题。

1.3 核心区别一句话总结

strcpy()是 “复制到'\0'为止”，strncpy()是 “复制到'\0'或n个字节为止”—— 前者依赖字符串天然结束符，后者依赖人工指定长度。

二、函数原型

函数原型是使用函数的 “说明书”，明确参数类型、返回值与使用约束是避免错误的第一步。

2.1 strcpy () 原型与参数

C 标准中strcpy()的原型定义如下：

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

参数详解：

参数名	类型	含义与约束
dest	char *	目标字符串缓冲区地址，必须是可修改的内存区域（不能是字符串常量，如"abc"）
src	const char *	源字符串地址，const修饰表示 “不修改源字符串”，必须以'\0'结尾
返回值	char *	返回dest的地址，支持 “链式调用”（如printf("%s", strcpy(dest, src))）

关键约束：

dest的内存空间必须大于等于src的长度（含'\0'），否则会溢出；
src必须是 “合法 C 字符串”（即末尾有'\0'），否则函数会持续读取内存直到找到'\0'，导致越界；
dest与src的内存区域不能重叠（如strcpy(dest, dest+2)），会导致复制逻辑混乱。

2.2 strncpy () 原型与参数

C 标准中strncpy()的原型定义如下：

char *strncpy(char *dest, const char *src, size_t n);

参数详解：

在strcpy()的基础上新增参数n，其他参数含义一致：

参数名	类型	含义与约束
n	size_t	最大复制字节数，size_t是无符号整数类型（通常为unsigned int或unsigned long），不能传入负数

关键约束：

n的取值需谨慎：若n大于dest的缓冲区大小，仍会导致溢出；通常建议n = 目标缓冲区大小 - 1（预留'\0'位置）；
复制终止条件：满足以下任一条件即停止：① 已复制n个字节；② 已复制到src的'\0'；
'\0'处理逻辑特殊：若src的长度（含'\0'）小于n，会自动用'\0'填充dest剩余字节；若src长度大于等于n，则不会在dest末尾添加'\0'，此时dest不是合法 C 字符串。

三、函数实现（伪代码）

理解函数的实现过程，能更深刻地掌握其行为特性。以下基于 C 标准逻辑，用伪代码解析核心实现。

3.1 strcpy () 实现原理

strcpy()的核心逻辑是 “逐字节复制，直到'\0'”，步骤如下：

伪代码实现：

// strcpy()伪代码（简化版，实际需考虑参数检查）
char *strcpy(char *dest, const char *src) {
    // 1. 保存dest初始地址（用于返回）
    char *dest_start = dest;
    
    // 2. 检查参数合法性（实际标准库可能省略，但开发中必须加）
    if (dest == NULL || src == NULL) {
        return NULL; // 或触发断言，避免空指针访问
    }
    
    // 3. 逐字节复制，直到遇到src的'\0'
    while (*src != '\0') {
        *dest = *src; // 复制当前字符
        dest++;       // 目标指针后移
        src++;        // 源指针后移
    }
    
    // 4. 复制src的'\0'到dest，确保dest是合法字符串
    *dest = '\0';
    
    // 5. 返回dest初始地址
    return dest_start;
}

执行流程图：

必须复制'\0'：这是strcpy()保证dest为合法字符串的核心；
无长度检查：正是因为没有 “目标缓冲区大小” 或 “复制长度” 的检查，才导致溢出风险。

3.2 strncpy () 实现原理

strncpy()的核心逻辑是 “按长度复制，处理'\0'填充”，步骤比strcpy()更复杂：

伪代码实现：

// strncpy()伪代码（简化版）
char *strncpy(char *dest, const char *src, size_t n) {
    // 1. 保存dest初始地址
    char *dest_start = dest;
    
    // 2. 参数合法性检查
    if (dest == NULL || src == NULL || n == 0) {
        return dest_start; // n=0时不复制，直接返回
    }
    
    // 3. 阶段1：复制src字符，直到'\0'或n耗尽
    while (n > 0 && *src != '\0') {
        *dest = *src;
        dest++;
        src++;
        n--; // 剩余可复制字节数减1
    }
    
    // 4. 阶段2：若n仍有剩余，用'\0'填充dest
    while (n > 0) {
        *dest = '\0';
        dest++;
        n--;
    }
    
    // 5. 返回dest初始地址
    return dest_start;
}

执行流程图：

两阶段处理：先复制有效字符，再填充'\0'（若 n 有剩余）；
'\0'不保证：若src长度≥n，阶段 1 结束后 n 已耗尽，阶段 2 不执行，dest无'\0'。

四、使用场景

选择strcpy()还是strncpy()，核心取决于 “是否明确源字符串长度” 与 “是否需要安全控制”。

4.1 strcpy () 的适用场景

strcpy()仅适用于源字符串长度已知且目标缓冲区足够大的场景，常见情况：

1. 静态字符串复制：源字符串是编译期确定的常量，长度可预知。

示例：复制固定提示信息到缓冲区

char msg[50];
// 源字符串"File opened successfully!"长度为26（含'\0'），msg大小50足够
strcpy(msg, "File opened successfully!");

2. 内部函数参数传递：在自定义函数中，已通过前置逻辑确保源字符串长度合法。

示例：内部模块间字符串传递（需提前校验长度）

// 前提：调用前已确认src_len（src长度）≤ dest_size（dest大小）
void internal_copy(char *dest, size_t dest_size, const char *src, size_t src_len) {
    strcpy(dest, src); // 此时使用strcpy安全
}

禁忌场景：

处理用户输入（如scanf("%s", src)获取的字符串，长度未知）；
处理动态内存字符串（如malloc分配的内存，长度可能变化）；
处理网络 / 文件读取的数据（长度不确定，可能无'\0'）。

4.2 strncpy () 的适用场景

strncpy()适用于源字符串长度未知，需限制复制长度以避免溢出的场景，常见情况：

1. 用户输入处理：限制复制长度，防止恶意输入导致溢出。

示例：读取用户输入的用户名（最多 19 个字符，加'\0'共 20 字节）

#define USERNAME_MAX 20 // 缓冲区大小
char username[USERNAME_MAX];
char input[1024]; // 临时接收用户输入（假设足够大）

fgets(input, sizeof(input), stdin); // 读取用户输入
// 复制最多19个字符（留1字节给'\0'），再手动添加'\0'
strncpy(username, input, USERNAME_MAX - 1);
username[USERNAME_MAX - 1] = '\0'; // 强制添加结束符，避免无'\0'问题

2. 动态内存字符串复制：已知目标缓冲区大小，限制复制长度。

示例：malloc分配缓冲区后复制字符串

size_t dest_size = 30;
char *dest = (char *)malloc(dest_size);
if (dest == NULL) { exit(1); }

const char *src = "This is a long string that may exceed dest size";
// 复制最多29个字符，手动加'\0'
strncpy(dest, src, dest_size - 1);
dest[dest_size - 1] = '\0';

3. 固定长度数据处理：如处理协议字段、数据库固定长度字段（无需'\0'）。

示例：处理长度为 10 的协议字段（不需要'\0'）

#define PROTOCOL_FIELD_LEN 10
char field[PROTOCOL_FIELD_LEN];
const char *data = "abcdefghijklmn"; // 源数据超过10字节

// 复制10字节，无需加'\0'（字段本身是固定长度二进制数据）
strncpy(field, data, PROTOCOL_FIELD_LEN);

禁忌场景：

直接将strncpy()的结果作为 “C 字符串” 使用而不手动加'\0'；
传入n大于目标缓冲区大小（如dest大小 20，n=30）；
认为strncpy()“绝对安全”，忽略参数校验（如dest为 NULL）。

五、注意事项与常见错误

strcpy()与strncpy()的 “坑” 多源于对细节的忽视，以下是高频问题与解决方案。

5.1 strcpy () 的 3 大核心风险

风险 1：缓冲区溢出（最严重）

问题表现：源字符串长度超过目标缓冲区，导致相邻内存数据被覆盖，程序崩溃或触发安全漏洞。

错误示例：

char dest[5]; // 缓冲区大小5（最多存4个字符+1个'\0'）
const char *src = "Hello World"; // 长度12（含'\0'）
strcpy(dest, src); // 溢出！dest会覆盖后续内存

解决方案：

严格校验源字符串长度：复制前用strlen(src) + 1（含'\0'）与sizeof(dest)比较；
优先使用strncpy()替代，避免直接使用strcpy()。

风险 2：源字符串无'\0'

问题表现：src不是合法 C 字符串（无'\0'），函数会持续读取内存直到找到'\0'，导致内存越界。

错误示例：

char src[5] = {'H', 'e', 'l', 'l', 'o'}; // 无'\0'，不是合法字符串
char dest[10];
strcpy(dest, src); // 会读取src后的内存，直到找到'\0'，越界风险

解决方案：

确保src始终以'\0'结尾（如char src[] = "Hello"，自动加'\0'）；
若处理二进制数据（无'\0'），改用memcpy()（按字节复制，需指定长度）。

风险 3：内存区域重叠

问题表现：dest是src的子内存区域（如dest = src + 2），复制时会覆盖未读取的src数据，导致结果错误。

错误示例：

char str[] = "abcdef";
// dest是src的子区域（str+2 = "cdef"）
strcpy(str + 2, str); // 复制过程：先把'a'写到'c'位置，后续读取混乱
// 最终str可能变成"abaaaa"，结果不可控

解决方案：避免内存重叠场景，若无法避免，改用memmove()（支持重叠内存复制）。

5.2 strncpy () 的 4 大常见误区

误区 1：认为 “复制后 dest 一定有 '\0'”

问题表现：当src长度≥n时，strncpy()不添加'\0'，dest不是合法字符串，后续用strlen()、printf("%s")等函数会读取乱码或越界。

错误示例：

char dest[5];
const char *src = "Hello World";
strncpy(dest, src, 5); // src长度≥5，dest无'\0'
printf("%s", dest); // 错误：dest无'\0'，会打印乱码直到找到'\0'

解决方案：强制在dest的 “预期结束位置” 添加'\0'，无论src长度如何：

strncpy(dest, src, sizeof(dest) - 1); // 复制最多4个字符
dest[sizeof(dest) - 1] = '\0'; // 强制加'\0'，确保合法

误区 2：n取值等于目标缓冲区大小

问题表现：若n = sizeof(dest)，且src长度≥n，dest无'\0'；若src长度<n，dest会填充'\0'到n字节，但后续若用strlen()会得到正确长度（因src的'\0'已复制），但仍有溢出风险（若n计算错误）。

错误示例：

char dest[5];
strncpy(dest, "Hello World", 5); // n=5等于dest大小，无'\0'

解决方案：统一n = sizeof(dest) - 1，预留 1 字节给'\0'，再手动加'\0'。

误区 3：忽视n的无符号类型

问题表现：n是size_t（无符号），若传入负数，会自动转换为极大的正数（如n=-1→4294967295），导致复制字节数远超预期，触发溢出。

错误示例：

int len = -5; // 错误：用int存长度，可能为负
char dest[10];
strncpy(dest, "abc", len); // len=-1→转换为4294967295，溢出！

解决方案：

用size_t类型存储长度（如size_t n = 5）；
复制前校验n的合法性（如if (n >= sizeof(dest)) { 报错 }）。

误区 4：填充'\0'的性能损耗

问题表现：若n远大于src长度，strncpy()会填充大量'\0'，浪费 CPU 资源。

示例场景：

char dest[1000];
const char *src = "short"; // 长度6（含'\0'）
strncpy(dest, src, 1000); // 需填充994个'\0'，性能损耗

解决方案：若无需填充'\0'，可手动复制后加'\0'，替代strncpy()：

size_t copy_len = strlen(src) < 999 ? strlen(src) : 999;
memcpy(dest, src, copy_len); // 用memcpy复制指定长度
dest[copy_len] = '\0';

六、实战示例代码：从 “理论” 到 “实践”

以下通过完整可运行代码，展示strcpy()与strncpy()的正确用法与错误对比。

6.1 strcpy () 实战：正确与错误对比

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

int main() {
    // 1. 正确用法：源字符串长度≤目标缓冲区
    char dest1[20];
    const char *src1 = "Correct strcpy usage";
    // 复制前校验长度（推荐做法）
    if (strlen(src1) + 1 <= sizeof(dest1)) {
        strcpy(dest1, src1);
        printf("Case 1 (Correct): dest1 = %s\n", dest1); // 输出完整字符串
    } else {
        printf("Case 1: src1 too long\n");
    }

    // 2. 错误用法：源字符串长度>目标缓冲区（溢出风险）
    char dest2[10];
    const char *src2 = "Too long string"; // 长度14（含'\0'）
    printf("Case 2 (Wrong): Before strcpy, dest2 = %s\n", dest2); // 垃圾值
    // 无长度校验，直接复制（危险！实际运行可能崩溃）
    strcpy(dest2, src2);
    printf("Case 2 (Wrong): After strcpy, dest2 = %s\n", dest2); // 乱码或崩溃

    // 3. 错误用法：源字符串无'\0'（越界风险）
    char src3[5] = {'H', 'e', 'l', 'l', 'o'}; // 无'\0'
    char dest3[10];
    // strcpy会读取src3后内存，直到找到'\0'（结果不可控）
    strcpy(dest3, src3);
    printf("Case 3 (Wrong): dest3 = %s\n", dest3); // 乱码

    return 0;
}

Case 1 正常输出；
Case 2 和 Case 3 因溢出 / 越界，可能打印乱码或导致程序崩溃（取决于编译器与系统）。

6.2 strncpy () 实战：安全用法与避坑

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

#define USER_MAX 15  // 用户名最大长度（含'\0'）
#define BUF_SIZE 20  // 缓冲区大小

int main() {
    // 1. 正确用法：处理用户输入，手动加'\0'
    char username[USER_MAX];
    char input[1024];
    printf("Enter username (max 14 characters): ");
    fgets(input, sizeof(input), stdin);
    // 移除fgets读取的换行符（可选，根据需求）
    input[strcspn(input, "\n")] = '\0';
    
    // 复制最多14个字符，手动加'\0'
    strncpy(username, input, USER_MAX - 1);
    username[USER_MAX - 1] = '\0'; // 关键：强制加结束符
    printf("Case 1 (Correct): Username = %s\n", username);

    // 2. 正确用法：动态内存复制
    char *dest = (char *)malloc(BUF_SIZE);
    if (dest == NULL) {
        perror("malloc failed");
        exit(EXIT_FAILURE);
    }
    const char *src = "Dynamic memory copy test: long string";
    // 复制最多19个字符，手动加'\0'
    strncpy(dest, src, BUF_SIZE - 1);
    dest[BUF_SIZE - 1] = '\0';
    printf("Case 2 (Correct): Dynamic dest = %s\n", dest);
    free(dest);

    // 3. 错误用法：不手动加'\0'，导致乱码
    char dest3[5];
    const char *src3 = "Hello World";
    strncpy(dest3, src3, 5); // src3长度≥5，dest3无'\0'
    printf("Case 3 (Wrong): dest3 = %s\n", dest3); // 乱码（无'\0'）

    // 4. 正确用法：固定长度字段（无需'\0'）
    #define FIELD_LEN 8
    char field[FIELD_LEN];
    const char *data = "1234567890"; // 源数据超过8字节
    strncpy(field, data, FIELD_LEN);
    printf("Case 4 (Correct): Fixed field = ");
    // 按字节打印，验证复制结果（无'\0'）
    for (int i = 0; i < FIELD_LEN; i++) {
        printf("%c", field[i]); // 输出"12345678"
    }
    printf("\n");

    return 0;
}

Case 1 和 Case 2 正常输出，无乱码；
Case 3 因无'\0'，printf会打印乱码（直到找到内存中的'\0'）；
Case 4 按字节打印固定长度字段，符合需求。

七、strcpy () 与 strncpy () 核心差异对比

为方便快速查阅，以下从 6 个维度对比两者差异：

对比维度	strcpy()	strncpy()
参数个数	2 个（dest, src）	3 个（dest, src, n）
复制终止条件	仅当复制到 src 的'\0'	① 复制 n 个字节；② 复制到 src 的'\0'（满足任一即停止）
'\0'处理	自动复制 src 的'\0'到 dest，确保合法字符串	仅当 src 长度 < n 时，用'\0'填充剩余字节；否则无'\0'
安全性	不安全（无长度限制，易溢出）	相对安全（需手动加'\0'，否则仍有风险）
适用场景	源长度已知且目标缓冲区足够大	源长度未知，需限制复制长度
性能	无额外开销（仅复制到'\0'）	可能有'\0'填充开销（n 远大于 src 长度时）

八、替代方案与扩展思考

在实际开发中，除了strcpy()与strncpy()，还有更安全的替代函数，可根据场景选择：

8.1 更安全的替代函数

1. strlcpy()（BSD 扩展，非 C 标准）：

原型：

size_t strlcpy(char *dest, const char *src, size_t size);

优势：自动添加'\0'（即使 src 过长），返回 src 的总长度（方便判断是否截断）；
缺点：仅在 BSD 系统（如 macOS）、Linux（GCC 扩展）支持，移植性差。

2. snprintf()（C99 标准）：

功能：格式化输出到字符串，可替代字符串复制；
优势：snprintf(dest, size, "%s", src)等价于 “安全复制”，自动加'\0'，兼容性好；
示例：

char dest[10];
const char *src = "Hello World";
snprintf(dest, sizeof(dest), "%s", src); // 安全复制，自动加'\0'

3. memcpy()（按字节复制，非字符串专用）：

原型：

void *memcpy(void *dest, const void *src, size_t n);

适用场景：复制二进制数据（无'\0'），或已知长度的字符串；
注意：不处理'\0'，需手动添加（若用于字符串）。

8.2 扩展思考：为什么 C 标准不废弃 strcpy ()？

strcpy()存在明显安全隐患，但 C 标准仍保留它，原因有二：

历史兼容性：大量 legacy 代码依赖strcpy()，废弃会导致兼容性问题；
性能需求：在明确安全的场景（如静态字符串复制），strcpy()无额外开销，性能优于strncpy()。

本文核心要点可概括为：

strcpy()：简单但不安全，仅适用于 “源长度已知且目标足够大” 的场景，使用前必须校验长度；
strncpy()：可控但需注意'\0'，核心是 “限制复制长度 + 手动加'\0'”，避免无结束符问题；
安全第一：实际开发中，优先选择strncpy()、snprintf()等更安全的函数，避免直接使用strcpy()；
细节决定成败：无论是参数校验、'\0'处理还是内存重叠，忽视细节都会导致隐藏 bug。

掌握这两个函数的本质与差异，不仅能避免常见错误，更能深刻理解 C 语言 “手动管理内存” 的设计哲学，为后续更复杂的字符串操作打下基础。

博主简介 byte轻骑兵，现就职于国内知名科技企业，专注于嵌入式系统研发，深耕 Android、Linux、RTOS、通信协议、AIoT、物联网及 C/C++ 等领域。乐于技术分享与交流，欢迎关注互动！ 📌 主页与联系方式

CSDN：https://blog.csdn.net/weixin_37800531
知乎：https://www.zhihu.com/people/38-72-36-20-51
微信公众号：嵌入式硬核研究所
邮箱：byteqqb@163.com（技术咨询或合作请备注需求）

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-09-21，如有侵权请联系 cloudcommunity@tencent.com 删除

字符串

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度