stpcpy和stpncpy用法 strcpy和strncpy用法

文章目录

strncpy, strncpy_s参考文档用法
strcpy, strncpy实例
- strcpy, strncpy用法举例
- 运行结果
stpcpy()和stpncpy()用法上的区别(C语言版)
stpcpy()和stpncpy()用法
- stpcpy()和stpncpy()用法**区别：**
补充：C/C++编程笔记：C语言字符数组初始化，有些赋值方式千万注意！
- 一、字符数组的定义和初始化
- 二、字符数组与字符串
- 三、赋值方式

strncpy, strncpy_s参考文档用法

C++ API参考文档 cppreference

C++字符串库链接字符串库

定义于头文件 `<string.h>`
char strncpy( char dest, const char *src, size_t count );	(C99前)
char strncpy( char restrict dest, const char *restrict src, size_t count );	(C99起)
errno_t strncpy_s(char restrict dest, rsize_t destsz, const char restrict src, rsize_t count);	(C11 起)

(1)、复制 src 所指向的字符数组的至多 count 个字符（包含空终止字符，但不包含后随空字符的任何字符）到 dest 所指向的字符数组。

若在完全复制整个 src 数组前抵达 count ，则结果的字符数组不是空终止的。
若在复制来自 src 的空终止字符后未抵达 count ，则写入额外的空字符到 dest ，直至写入总共 count 个字符。
若字符数组重叠，若 dest 或 src 不是指向字符数组的指针（包含若 dest 或 src 为空指针），若 dest 所指向的数组大小小于 count ，或若 src 所指向的数组大小小于 count 且它不含空字符，则行为未定义。

(2)、同 (1) ，除了函数不持续写入零到目标数组以填满 count ，它在写入空终止字符后停止（若源中无空字符，则它于 dest[count] 写入一个然后停止）。并且在运行时检测下列错误并调用当前安装的制约处理函数：

若 dest 所指的字符数组大小 < strnlen_s(src, destsz) <= destsz 则行为未定义；换言之，错误的 destsz 值不暴露行将发生的缓冲区溢出。若 src 所指的字符数组大小 < strnlen_s(src, count) < destsz 则行为未定义；换言之，错误的 count 值不暴露行将发生的缓冲区溢出。

参数

dest	指向要复制到的字符数组的指针
src	指向复制来源的字符数组的指针
count	要复制的最大字符数
destsz	目标缓冲区的大小

返回值

返回 dest 的副本
成功时返回零，错误时返回非零。而且，在错误时写入零到 dest[0] （除非 dest 为空指针，或 destsz 为零或大于 RSIZE_MAX ），而且可能以未指定值破坏目标数组的剩余部分。

注解

按 C11 后的 DR 468 更正， strncpy_s 不同于strcpy_s，仅若错误发生才被允许破坏目标数组的剩余部分。

不同于 strncpy ， strncpy_s 不以零填充目标数组。这是转换既存代码到边界检查版本的常见错误源。

尽管适合目标缓冲区的截断是安全风险，从而是 strncpy_s 的运行时制约违规，还是可通过指定 count 等于目标数组大小减一以获取截断行为：它会复制首 count 个字节，并照常添加空终止符： strncpy_s(dst, sizeof dst, src, (sizeof dst)-1);

strcpystrcpy_s(C11)	复制一个字符串给另一个 (函数)
memcpymemcpy_s(C11)	将一个缓冲区复制到另一个 (函数)
strndup(动态内存 TR)	分配字符串副本，至多到指定的大小 (函数)

strcpy, strncpy实例

strcpy, strncpy用法举例

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
int main()
{//char src[] = "hi";//char dest[7] = "abcdef"; // 有一个'\0'结束字符//cout << strncpy(dest, src, 5) << endl;string _str = "aaabbbccc";char _d1[10] = "00000";char _d2[100] = "\0";//char _d2[100] = "00000";//char _d2[100] = { '\0' } ;//char _d2[100] = '\0';//马上报错,error C2440: “初始化”: 无法从“char”转换为“char [100]”//cout << strcpy(_d1, _str) << endl;//马上报错cout << strcpy(_d1, _str.c_str()) << endl;//转化cout << strncpy(_d2, _str.c_str(), 3) << endl;//"aaa"return 0;
}

运行结果

调试错误：目标字符串内存空间太小，内存溢出

stpcpy()和stpncpy()用法上的区别(C语言版)

**参考代码链接地址：**https://www.apiref.com/c-zh/stpcpy.htm

函数名: stpcpy
功  能: 拷贝一个字符串到另一个
用  法: #include <string.h>char *stpcpy(char *destin, char *source);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{char string[10];char *str1 = "abcdefghi";stpcpy(string, str1);printf("%s\n", string);return 0;
}

stpcpy()和stpncpy()用法

用途：用法和作用和strcpy()和strncpy()一样，都是复制字符串

stpcpy()和stpncpy()用法区别：

strcpy()和strncpy()返回：复制之后的起始地址
stpcpy()和stpncpy()返回：复制之后的末尾地址

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;
int main()
{const char _str[20] = { "abcdefg " };char _d1[1024] = "0";char _d2[1024] = "0";cout << strcpy(_d1, _str) << endl;cout << stpcpy(_d2, _str) << endl;  //extern char *stpcpy(char *dest,char *src)cout << strncpy_s(_d2, _str, 4) << endl;}

//总代码

// stpcpy()和stpncpy()用法上的区别 //   用途：复制字符串//   区别：
//  strcpy()和strncpy()返回：复制之后的起始地址
//  stpcpy()和stpncpy()返回：复制之后的末尾地址//  举例//   stpcpy()和stpncpy()返回：复制之后的末尾地址
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstring>
using namespace std;
int main()
{//const char _str[20] = { "abcdefg " };//char _d1[1024] = "0";//char _d2[1024] = "0";//cout << strcpy(_d1, _str) << endl;//cout << stpcpy(_d2, _str) << endl;  //extern char *stpcpy(char *dest,char *src)//cout << strncpy_s(_d2, _str, 4) << endl;char source[1024] = { "abcdef" };char _dst1[1024];char _dst2[1024];std::cout << strcpy(_dst1, source) + 1 << std::endl;///"bcdef"//std::cout << stpcpy(_dst2, source) - 1 << std::endl;}/*
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
int main()
{//char src[] = "hi";//char dest[7] = "abcdef"; // 有一个'\0'结束字符//cout << strncpy(dest, src, 5) << endl;string _str = "aaabbbccc";char _d1[10] = "00000";char _d2[10] = "\0";//char _d2[100] = "00000";//char _d2[100] = { '\0' } ;//char _d2[100] = '\0';//马上报错,error C2440: “初始化”: 无法从“char”转换为“char [100]”//cout << strcpy(_d1, _str) << endl;//马上报错cout << strcpy(_d1, _str.c_str()) << endl;//转化cout << strncpy(_d2, _str.c_str(), 3) << endl;//"aaa"return 0;
}*/

补充：C/C++编程笔记：C语言字符数组初始化，有些赋值方式千万注意！

一、字符数组的定义和初始化

字符数组的初始化，最容易理解的方式就是逐个字符赋给数组中各元素。

charstr[10]={‘I’,‘’,‘a’,‘m’,‘’,‘h’,‘a’,‘p’,‘p’,‘y’};

即把10个字符分别赋给str[0]到str[9]10个元素

如果花括号中提供的字符个数大于数组长度，则按语法错误处理；若小于数组长度**，则只将这些字符数组中前面那些元素，其余的元素自动定为空字符（即’\0’)**。

如char str[10] = {‘\0’}; //结果里面元素全都为\0.其实这样赋值只是把第1个元素赋值为\0，后面的都默认用\0填充，如果是char str[10]={‘1’};

只有第一个为‘1’，后面都是\0。但千万不要以为写成char str[10];不赋值也可以。这样写里面的内容是乱的。

这是细节，值得注意。

所以我们最好每次想写char str[5]都写成

char str[5]=‘\0’;

这样做最好。

int a[10]={4，5};

第一个赋值为4，第二个为5，后面的为0.如果直接int a[10]; 内容很乱。

规律：用某个值给数组赋值，没有被赋值的元素会自动调用默认的构造函数，如char默认为\0,int默认为0.等等.

二、字符数组与字符串

在 c语言中，将字符串作为字符数组来处理。（c++中不是）

在实际应用中人**们关心的是有效字符串的长度而不是字符数组的长度，**例如，

定义一个字符数组长度为100，而实际有效字符只有40个，为了测定字符串的实际长度，C语言规定了一个“字符串结束标志”，以字符’\0’代表。如果有一个字符串，其中第10个字符为’\0’，则此字符串的有效字符为9个。也就是说，在遇到第一个字符’\0’时，表示字符串结束，由它前面的字符组成字符串。

系统对字符串常量也自动加一个’\0’作为结束符。例如"C Program”共有9个字符，但在内存中占10个字节，最后一个字节’\0’是系统自动加上的。（通过 sizeof()函数可验证）

有了结束标志’\0’后，字符数组的长度就显得不那么重要了，在程序中往往依靠检测’\0’的位置来判定字符串是否结束，而不是根据数组的长度来决定字符串长度。当然，在定义字符数组时应估计实际字符串长度，保证数组长度始终大于字符串实际长度。（在实际字符串定义中，常常并不指定数组长度，如 char str[ ]）

说明：'\n’代表 ASCII 码为0的字符，从 ASCII码表中可以查到 ASCII 码为0的字符不是一个可以显示的字符，而是一个“空操作符”，即它什么也不干。用它来作为字符串结束标志不会产生附加的操作或增加有效字符，只起一个供辨别的标志。

对C 语言处理字符串的方法由以上的了解后，再对字符数组初始化的方法补充一种方法——即可以用字符串常量来初始化字符数组：

注意sizeof与strlen的不同：

char a[40]={‘0’};

printf(“%d”,sizeof(a));//开辟的数组的总大小40*1

printf(“%d”,strlen(a));

输出 40，1.

char str[ ]={“I am happy”}; 可以省略花括号，如下所示

char str[ ]=“I am happy”;

注意：上述这种字符数组的整体赋值只能在字符数组初始化时使用，不能用于字符数组的赋值，字符数组的赋值只能对其元素一一赋值，如：

char d[5];

d=“hell”;

错误。vs2010提示表达式d必须是可修改的左值。

这跟

int a[5]={1,2,3};

而不能

int a[5];

a={1,2,3}

数组只能在初始化的时候一次性赋值，其他时候必须要一个一个赋值。

看来数组名和指针是有区别的。

下面的赋值方法是错误的

char str[ ];

str=“I am happy”;

不是用单个字符作为初值，而是用一个字符串（注意：字符串的两端是用双引号“”而不是单引号‘’括起来的）作为初值。显然，这种方法更直观方便。（注意：数组str的长度不是10，而是11，这点请务必记住，因为字符串常量"I am happy"的最后由系统自动加上一个’\0’）

因此，上面的初始化与下面的初始化等价

char str[ ]={‘I’,’ ‘,‘a’,‘m’,’ ‘,‘h’,‘a’,‘p’,‘p’,‘y’,’\0’};必须要人为加上一个\0，否则strlen不正确。

而不与下面的等价

char str[ ]={‘I’,’ ‘,‘a’,‘m’,’ ',‘h’,‘a’,‘p’,‘p’,‘y’};//strlen错误，后面没有\0

前者的长度是11，后者的长度是10.

说明：字符数组并不要求它的最后一个字符为’\0’，甚至可以不包含’\0’，向下面这样写是完全合法的。

char str[5]={‘C’,‘h’,‘i’,‘n’,‘a’};

可见，用两种不同方法初始化字符数组后得到的数组长度是不同的。

三、赋值方式

对字符数组只能对各个元素赋值，不能用以下方法对字符数组赋值

char str[14];

str=“I love China”; （但在字符数组初始化时可以，即 charstr[14]=“I love China”;）

而对字符指针变量，采用下面方法赋值：

char* a;

a=“I love China”;

或者是 char* a=“I love China”; 都可以

对字符指针变量赋初值（初始化）：

char* a=“I love China”;

等价于：

char* a

a=“I love China”;

而对于字符数组的初始化

char str[14]=“I love China”;

不能等价于：