C语言 为什么strncpy()产生垃圾时，dest小于src，但大到足以适应src的子字符串?

Question

我尝试限制复制到dest的n字节数(这里str1)strncpy()．桌子足够大的n个字节,但是输出产生的垃圾当桌子小于源(这里argv [1](.当我使dest足够大以容纳源文件时，这看起来就不同了。

代码如下:

#include <stdio.h>                                                              
#include <string.h>                                                             
          
int main(int argc, char *argv[])                                                
{                                                                               
/* // Works when str1[?] is 20:                                                                    
char str1[20];                                                                
char str2[20]; */                                                             
          
// produces garbage, str1 is smaller than argv[1] but big enough for the 4 bytes copied                                                            
char str1[10];                                                                
char str2[10];                                                                
          
printf("argc = %in", argc);                                                  
if (argc <= 1 || argc > 2){                                                   
printf("Input Example:n"                                                   
"  %s SEGMENT:OFFSETn"                                              
"  %s 0100:F00An", argv[0], argv[0]);                               
return 0;                                                                   
}                                                                             
printf("strlen(argv[1]) = %li, argv[1] = %sn"                                
, strlen(argv[1]), argv[1]);                                          
          
// str1                                                                       
strncpy(str1, argv[1], 4); // copying 4 bytes to str1                                                   
printf("Copy only 4 Bytes -> sizeof(str1) = %li, "                            
"strlen(str1) = %li, str1 = %sn", sizeof(str1), strlen(str1), str1);  
          
// str2                                                                       
strncpy(str2, argv[1], 3); // copying 3 bytes to str2                                                   
printf("Copy only 3 Bytes -> sizeof(str2) = %li, "                            
"strlen(str2) = %li, str2 = %sn", sizeof(str2), strlen(str2), str2);  
          
return 0;                                                                     
}                      

输入0100:F00A产生:

./test.bin 0100:F00A
argc = 2
strlen(argv[1]) = 9, argv[1] = 0100:F00A
Copy only 4 Bytes -> sizeof(str1) = 10, strlen(str1) = 8, str1 = 0100�U
Copy only 3 Bytes -> sizeof(str2) = 10, strlen(str2) = 3, str2 = 010

预期值str1 = 0100.

我也想知道为什么str2是正确的，它的初始数组大小为str1.

当我改变

char str1[10] 

char str1[20]

并使其大于argv[1]的输入，那么输出是正确的:

./test.bin 0100:F00A
argc = 2
strlen(argv[1]) = 9, argv[1] = 0100:F00A
Copy only 4 Bytes -> sizeof(str1) = 20, strlen(str1) = 4, str1 = 0100
Copy only 3 Bytes -> sizeof(str2) = 20, strlen(str2) = 3, str2 = 010

似乎strncpy首先将所有内容复制到dest，然后将其后面的部分剪掉。但这就是strong的工作方式吗?我假设它只是复制了需要的4个字节。

Answer 1

from手册https://linux.die.net/man/3/strncpy

strncpy()函数与之相似，除了最多复制n个字节的src。警告:如果src的前n个字节中没有空字节，放在dest中的字符串将不会以空结束。

即在您的情况下，dest

中没有null。

Answer 2

来自strncpy()的GLIBC手册页:

警告

:如果src的第一个n字节中没有空字节，则放置在dest中的字符串将不以空结束

你正在观察效果。

Answer 3

不管它是值得的，我试着在我的PC (Windows/GCC 10.3.0)上编译和运行你的程序…从表面上看，它"看起来不错"。我没有看到你描述的神器。

这个例子说明了发生了什么:

#include <stdio.h>                                                              
#include <string.h>                                                             
          
int main(int argc, char *argv[])                                                
{ 
char *s;
char test1[] = "AAAAAAAA";                                                                             
char test2[] = "AAAAAAAA";                                                                             
printf("BEFORE: strlen(test1)=%lli, sizeof(test1)=%lli, test1=%s...n",
strlen(test1), sizeof(test1), test1);
strncpy(test1, "BBBB", 4);
printf("AFTER: strlen(test1)=%lli, sizeof(test1)=%lli, test1=%s...n",
strlen(test1), sizeof(test1), test1);
strncpy(test2, "BBBB", 6);
printf("AFTER: strlen(test2)=%lli, sizeof(test2)=%lli, test2=%s...n",
strlen(test2), sizeof(test2), test2);
return 0;
}
- gcc -o x -g -Wall -pedantic x.c
x.c:37:3: warning: 'strncpy' output truncated before terminating nul copying 4 bytes from a string of the same length [-Wstringop-truncation]
37 |   strncpy(test1, "BBBB", 4);
|   ^~~~~~~~~~~~~~~~~~~~~~~~~
- x 0100:F00A
segment=0100, strlen(segment)=4; offset=F00A, strlen(offset)=4
BEFORE: strlen(test1)=8, sizeof(test1)=9, test1=AAAAAAAA...
AFTER: strlen(test1)=8, sizeof(test1)=9, test1=BBBBAAAA...
AFTER: strlen(test2)=4, sizeof(test2)=9, test2=BBBB...

其他说明:

• 一些系统(bsd, Solaris等)提供strlcpy()。

  它最多复制大小为1的字节到dest，总是添加一个结束空字节，并且不向目标填充(进一步)空字节。

• 另一种将命令行解析为"段"的方法和offset"可能是使用strtok():

  ...
  if (argc != 2) {                                                   
  printf("USAGE: enter SEGMENT:OFFSET, e.g. "0100:F00A"n");                               
  return 1;                                                                   
  } 
  if ((strlen(argv[1]) != 9) || (strchr(argv[1], ':') == NULL)) {
  printf ("This doesn't look like a segment::offset!n");
  return 1;
  }
  s = strtok(argv[1], ":");
  if (s == NULL){                                                   
  printf("Illegal entry: unable to parse %sn", argv[1]);                               
  } 
  else {
  strcpy(segment, s);
  strcpy (offset, strtok(NULL, ":"));
  printf("segment=%s, strlen(segment)=%lli; offset=%s, strlen(offset)=%llin",
  segment, strlen(segment), offset, strlen(offset));
  }