我很难相信我是第一个遇到这个问题的人，但是搜索了很长一段时间并没有找到解决方案。
我想使用 strncpy 但让它支持 UTF8，因此它不会部分地将 utf8 字符写入目标字符串。
否则，您永远无法确定生成的字符串是有效的 UTF8，即使您知道源是（当源字符串大于最大长度时）。
验证结果字符串可以工作，但如果要经常调用它，最好有一个 strncpy 函数来检查它。
glib 有g_utf8_strncpy，但这会复制一定数量的 unicode 字符，而我正在寻找一个受字节长度限制的复制函数。
需要明确的是，“utf8 感知”是指它不应超过目标缓冲区的限制，并且绝不能仅复制 utf-8 字符的一部分。（给定有效的 utf-8 输入决不能导致无效的 utf-8 输出）。
一些回复指出，strncpy所有字节都为空，并且它不会确保零终止，回想起来我应该要求一个 utf8 感知strlcpy，但是当时我不知道这个函数的存在。
我已经在许多带有多字节字符的示例 UTF8 字符串上对此进行了测试。如果源太长，它会对其进行反向搜索（从空终止符开始）并向后工作以找到最后一个可以放入目标缓冲区的完整 UTF8 字符。它始终确保目的地为空终止。
char* utf8cpy(char* dst, const char* src, size_t sizeDest )
{
if( sizeDest ){
size_t sizeSrc = strlen(src); // number of bytes not including null
while( sizeSrc >= sizeDest ){
const char* lastByte = src + sizeSrc; // Initially, pointing to the null terminator.
while( lastByte-- > src )
if((*lastByte & 0xC0) != 0x80) // Found the initial byte of the (potentially) multi-byte character (or found null).
break;
sizeSrc = lastByte - src;
}
memcpy(dst, src, sizeSrc);
dst[sizeSrc] = '\0';
}
return dst;
}
我不确定您所说的 UTF-8 感知是什么意思；strncpy复制字节，而不是字符，缓冲区的大小也以字节为单位。如果你的意思是它只会复制完整的 UTF-8 字符，停止，例如，如果没有空间容纳下一个字符，我不知道这样的功能，但应该不会太难来写：
int
utf8Size( char ch )
{
static int const sizeTable[] =
{
// ...
};
return sizeTable( static_cast<unsigned char>( ch ) )
}
char*
stru8ncpy( char* dest, char* source, int n )
{
while ( *source != '\0' && utf8Size( *source ) < n ) {
n -= utf8Size( *source );
switch ( utf8Size( ch ) ) {
case 6:
*dest ++ = *source ++;
case 5:
*dest ++ = *source ++;
case 4:
*dest ++ = *source ++;
case 3:
*dest ++ = *source ++;
case 2:
*dest ++ = *source ++;
case 1:
*dest ++ = *source ++;
break;
default:
throw IllegalUTF8();
}
}
*dest = '\0';
return dest;
}
（utf8Size 中的表格内容生成起来有点麻烦，但如果您处理 UTF-8，这是一个您会经常使用的函数，而且您只需执行一次。）
为了回答自己的问题，这是我最终得到的 C 函数（此项目不使用 C++）：
注意： - 意识到这不是strncpyutf8 的克隆，它更像是strlcpy来自 openbsd。- 从 glib 的 gutf8.c 复制的 utf8_skip_data - 它不验证 utf8 - 这是我的意图。
希望这对其他人有用并且对反馈感兴趣，但请不要迂腐狂热关于NULL终止行为，除非它是一个实际的错误或误导/不正确的行为。
感谢 James Kanze，他为此提供了基础，但不完整且 C++（我需要 C 版本）。
static const size_t utf8_skip_data[256] = {
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
};
char *strlcpy_utf8(char *dst, const char *src, size_t maxncpy)
{
char *dst_r = dst;
size_t utf8_size;
if (maxncpy > 0) {
while (*src != '\0' && (utf8_size = utf8_skip_data[*((unsigned char *)src)]) < maxncpy) {
maxncpy -= utf8_size;
switch (utf8_size) {
case 6: *dst ++ = *src ++;
case 5: *dst ++ = *src ++;
case 4: *dst ++ = *src ++;
case 3: *dst ++ = *src ++;
case 2: *dst ++ = *src ++;
case 1: *dst ++ = *src ++;
}
}
*dst= '\0';
}
return dst_r;
}
strncpy()是一个可怕的功能：
即使字符保持在 ASCII 范围内（0x7f 及以下），生成的字符串也不会是您想要的。在 UTF-8 情况下，它可能不是以 nul 结尾的并且以无效的 UTF-8 序列结尾。
最好的建议是避免strncpy()。
编辑： 广告1）：
#include <stdio.h>
#include <string.h>
int main (void)
{
char buff [4];
strncpy (buff, "hello world!\n", sizeof buff );
printf("%s\n", buff );
return 0;
}
同意，缓冲区不会溢出。但结果仍然是不希望的。strncpy() 只解决了部分问题。这是误导和不受欢迎的。
更新（2012-10-31）：由于这是一个令人讨厌的问题，我决定破解我自己的版本，模仿丑陋的 strncpy() 行为。返回值是复制的字符数，虽然..
#include <stdio.h>
#include <string.h>
size_t utf8ncpy(char *dst, char *src, size_t todo);
static int cnt_utf8(unsigned ch, size_t len);
static int cnt_utf8(unsigned ch, size_t len)
{
if (!len) return 0;
if ((ch & 0x80) == 0x00) return 1;
else if ((ch & 0xe0) == 0xc0) return 2;
else if ((ch & 0xf0) == 0xe0) return 3;
else if ((ch & 0xf8) == 0xf0) return 4;
else if ((ch & 0xfc) == 0xf8) return 5;
else if ((ch & 0xfe) == 0xfc) return 6;
else return -1; /* Default (Not in the spec) */
}
size_t utf8ncpy(char *dst, char *src, size_t todo)
{
size_t done, idx, chunk, srclen;
srclen = strlen(src);
for(done=idx=0; idx < srclen; idx+=chunk) {
int ret;
for (chunk=0; done+chunk < todo; chunk++) {
ret = cnt_utf8( src[idx+chunk], srclen - (idx+chunk) );
if (ret ==1) continue; /* Normal character: collect it into chunk */
if (ret < 0) continue; /* Bad stuff: treat as normal char */
if (ret ==0) break; /* EOF */
if (!chunk) chunk = ret;/* an UTF8 multibyte character */
else ret = 1; /* we allready collected a number (chunk) of normal characters */
break;
}
if (ret > 1 && done+chunk > todo) break;
if (done+chunk > todo) chunk = todo - done;
if (!chunk) break;
memcpy( dst+done, src+idx, chunk);
done += chunk;
if (ret < 1) break;
}
/* This is part of the dreaded strncpy() behavior:
** pad the destination string with NULs
** upto its intended size
*/
if (done < todo) memset(dst+done, 0, todo-done);
return done;
}
int main(void)
{
char *string = "Hell\xc3\xb6 \xf1\x82\x82\x82, world\xc2\xa1!";
char buffer[30];
unsigned result, len;
for (len = sizeof buffer-1; len < sizeof buffer; len -=3) {
result = utf8ncpy(buffer, string, len);
/* remove the following line to get the REAL strncpy() behaviour */
buffer[result] = 0;
printf("Chop @%u\n", len );
printf("Org:[%s]\n", string );
printf("Res:%u\n", result );
printf("New:[%s]\n", buffer );
}
return 0;
}
这是一个 C++ 解决方案：
u8string.h：
#ifndef U8STRING_H
#define U8STRING_H 1
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* Copies the first few characters of the UTF-8-encoded string pointed to by
* \p src into \p dest_buf, as many UTF-8-encoded characters as can be written in
* <code>dest_buf_len - 1</code> bytes or until the NUL terminator of the string
* pointed to by \p str is reached.
*
* The string of bytes that are written into \p dest_buf is NUL terminated
* if \p dest_buf_len is greater than 0.
*
* \returns \p dest_buf
*/
char * u8slbcpy(char *dest_buf, const char *src, size_t dest_buf_len);
#ifdef __cplusplus
}
#endif
#endif
u8slbcpy.cpp：
#include "u8string.h"
#include <cstring>
#include <utf8.h>
char * u8slbcpy(char *dest_buf, const char *src, size_t dest_buf_len)
{
if (dest_buf_len <= 0) {
return dest_buf;
} else if (dest_buf_len == 1) {
dest_buf[0] = '\0';
return dest_buf;
}
size_t num_bytes_remaining = dest_buf_len - 1;
utf8::unchecked::iterator<const char *> it(src);
const char * prev_base = src;
while (*it++ != '\0') {
const char *base = it.base();
ptrdiff_t diff = (base - prev_base);
if (num_bytes_remaining < diff) {
break;
}
num_bytes_remaining -= diff;
prev_base = base;
}
size_t n = dest_buf_len - 1 - num_bytes_remaining;
std::memmove(dest_buf, src, n);
dest_buf[n] = '\0';
return dest_buf;
}
该函数u8slbcpy()有一个 C 接口，但它是用 C++ 实现的。我的实现使用仅标头UTF8-CPP 库。
我认为这几乎就是您要寻找的内容，但请注意，如果组合字符适用于第n个字符（本身不是组合字符）和目标缓冲区足够大，可以存储字符 1 到n的 UTF-8 编码，但不能存储字符n的组合字符。在这种情况下，表示字符 1 到n的字节被写入，但没有n的组合字符被写入。实际上，您可以说第n个字符是部分写入的。
要评论上述答案“strncpy() 是一个可怕的功能：”。我什至讨厌以创建另一个互联网编程圣战为代价来评论这种笼统的陈述，但无论如何，因为这样的陈述会误导那些可能来这里寻找答案的人。
好吧，也许 C 字符串函数是“老派”。也许 C/C++ 中的所有字符串都应该放在某种智能容器中，等等，也许应该使用 C++ 而不是 C（当你有选择的时候），这些更多是其他主题的偏好和论据。
我来这里是为了寻找我自己的 UTF-8 strncpy()。并不是说我无法制作（恕我直言，编码简单而优雅），而是想看看其他人是如何制作的，也许可以在 ASM 中找到一个优化的。
对于编程界人士的“上帝的礼物”，暂时放下你的狂妄自大，看看一些事实。
“strncpy()”或任何其他具有相同副作用和“_snprintf()”等问题的类似函数没有任何问题。
我说：“strncpy() 并不可怕”，而是“糟糕的程序员使用得非常糟糕”。
什么是“可怕的”是不知道规则。此外，由于安全性（如缓冲区溢出）和程序稳定性影响，在整个主题上，如果仅遵循规则，则不需要例如 Microsoft 将“安全字符串函数”添加到其 CRT 库中。
主要的：
这就是我个人处理此类事情的方式，以及其他需要了解和实践的规则。
一个方便的静态字符串大小宏：
// Size of a string with out terminator
#define SIZESTR(x) (sizeof(x) - 1)
声明本地/堆栈字符串缓冲区时：
A) 例如，终止符的大小限制为 1023+1，以允许长度不超过 1023 个字符的字符串。
B）我将字符串的长度初始化为零，并在最后终止以覆盖可能的“n”截断。
char szBuffer[1024]; szBuffer[0] = szBuffer[SIZESTR(szBuffer)] = 0;
或者，可以这样做：
char szBuffer[1024] = {0};
当然，但是对于编译器生成的“memset()”有一些性能影响，比如调用将整个缓冲区归零。尽管它使调试变得更干净，我更喜欢这种风格的静态（与本地/堆栈）字符串缓冲区。
现在是遵循规则的“strncpy()”：
char szBuffer[1024]; szBuffer[0] = szBuffer[SIZESTR(szBuffer)] = 0;
strncpy(szBuffer, pszSomeInput, SIZESTR(szBuffer));
当然还有其他“规则”和问题，但这些是我想到的主要问题。您刚刚了解了 lib 函数的工作原理并使用了这样的安全实践。
最后在我的项目中，无论如何我都使用ICU，所以我决定使用它并使用“utf8.h”中的宏来制作我自己的“strncpy()”。