我正在为C ++编写一个UTF-8库作为练习，因为这是我的第一个真实世界的C ++代码。到目前为止，我已经在名为“ustring”的类中实现了串联，字符索引，解析和编码UTF-8。它看起来很有效，但两种看似相同的声明新ustring的方式表现不同。第一种方式：
ustring a;
a = "test";
工作，重载的“=”运算符将字符串解析为类（将Unicode字符串存储为动态分配的int指针）。但是，以下内容不起作用：
ustring a = "test";
因为我收到以下错误：
test.cpp:4: error: conversion from ‘const char [5]’ to non-scalar type ‘ustring’ requested
有没有办法解决此错误？但是，我的代码可能存在问题。以下是我到目前为止为图书馆写的内容：
#include <cstdlib>
#include <cstring>
class ustring {
int * values;
long len;
public:
long length() {
return len;
}
ustring * operator=(ustring input) {
len = input.len;
values = (int *) malloc(sizeof(int) * len);
for (long i = 0; i < len; i++)
values[i] = input.values[i];
return this;
}
ustring * operator=(char input[]) {
len = sizeof(input);
values = (int *) malloc(0);
long s = 0; // s = number of parsed chars
int a, b, c, d, contNeed = 0, cont = 0;
for (long i = 0; i < sizeof(input); i++)
if (input[i] < 0x80) { // ASCII, direct copy (00-7f)
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = input[i];
} else if (input[i] < 0xc0) { // this is a continuation (80-bf)
if (cont == contNeed) { // no need for continuation, use U+fffd
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = 0xfffd;
}
cont = cont + 1;
values[s - 1] = values[s - 1] | ((input[i] & 0x3f) << ((contNeed - cont) * 6));
if (cont == contNeed) cont = contNeed = 0;
} else if (input[i] < 0xc2) { // invalid byte, use U+fffd (c0-c1)
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = 0xfffd;
} else if (input[i] < 0xe0) { // start of 2-byte sequence (c2-df)
contNeed = 1;
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = (input[i] & 0x1f) << 6;
} else if (input[i] < 0xf0) { // start of 3-byte sequence (e0-ef)
contNeed = 2;
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = (input[i] & 0x0f) << 12;
} else if (input[i] < 0xf5) { // start of 4-byte sequence (f0-f4)
contNeed = 3;
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = (input[i] & 0x07) << 18;
} else { // restricted or invalid (f5-ff)
values = (int *) realloc(values, sizeof(int) * ++s);
values[s - 1] = 0xfffd;
}
return this;
}
ustring operator+(ustring input) {
ustring result;
result.len = len + input.len;
result.values = (int *) malloc(sizeof(int) * result.len);
for (long i = 0; i < len; i++)
result.values[i] = values[i];
for (long i = 0; i < input.len; i++)
result.values[i + len] = input.values[i];
return result;
}
ustring operator[](long index) {
ustring result;
result.len = 1;
result.values = (int *) malloc(sizeof(int));
result.values[0] = values[index];
return result;
}
char * encode() {
char * r = (char *) malloc(0);
long s = 0;
for (long i = 0; i < len; i++) {
if (values[i] < 0x80)
r = (char *) realloc(r, s + 1),
r[s + 0] = char(values[i]),
s += 1;
else if (values[i] < 0x800)
r = (char *) realloc(r, s + 2),
r[s + 0] = char(values[i] >> 6 | 0x60),
r[s + 1] = char(values[i] & 0x3f | 0x80),
s += 2;
else if (values[i] < 0x10000)
r = (char *) realloc(r, s + 3),
r[s + 0] = char(values[i] >> 12 | 0xe0),
r[s + 1] = char(values[i] >> 6 & 0x3f | 0x80),
r[s + 2] = char(values[i] & 0x3f | 0x80),
s += 3;
else
r = (char *) realloc(r, s + 4),
r[s + 0] = char(values[i] >> 18 | 0xf0),
r[s + 1] = char(values[i] >> 12 & 0x3f | 0x80),
r[s + 2] = char(values[i] >> 6 & 0x3f | 0x80),
r[s + 3] = char(values[i] & 0x3f | 0x80),
s += 4;
}
return r;
}
};
答案 0 :(得分：16)
你的问题是ustring a = "test"实际上调用了构造函数，而不是赋值运算符。好的，欢迎来到c ++：）
您需要自己定义一个默认构造函数和一个const char*构造函数，因为一旦定义了一个构造函数，就需要定义 all 你的建设者。
其他一些事情：
const char *而非char[]（您不修改输入，而char *更常见）sizeof没有按照您的想法行事，doesn't work properly for array parameters。它会返回给您sizeof(char*)，而不是sizeof(array)。this的引用。vector<int> values;为您管理所有记忆。encode()应该返回string。使用string：
free或delete。s.append(c);代替realloc。printf("%s", s.c_str());，但在c ++中，您通常使用cout << s; 像这样：
class ustring {
public:
// Default constructor, allows you to create your class with no arguments.
ustring() { ...; }
// Allows you to create your class from string literals.
ustring(const char *input) { ...; }
// Copy constructor, allows you to create your class from other instances.
ustring(const ustring &input) { ...; }
// Assignment operators.
ustring &operator=(const ustring &input) { ...; return *this; }
ustring &operator=(const char *input) { ...; return *this; }
};
int main() {
ustring s, t; // invokes default constructor.
s = t; // invokes ustring assignment op.
s = "test"; // invokes const char* assignment op.
ustring u = "test"; // invokes const char* constructor.
ustring v("test"); // invokes const char* constructor.
ustring x(u); // invokes copy constructor.
}
如果这是c ++，你为什么要做所有这些malloc / realloc的东西？我还没有完全解析该代码，但我想有一种更简单的方法...请参阅有关使用向量的注释。
正如@Michael Aaron Safyan在评论中提到的，如果你为ustring类做任何内存分配，你将需要在析构函数中释放它。但是，我认为通过切换到内存管理容器 - 矢量＆amp; string - 你将避免任何自己的内存管理，并且可以避免编写析构函数。
答案 1 :(得分：1)
这是两个操作：
ustring a; // construct a new object using constructor
a = "test"; // assign value to object using operator=
这是一项操作：
ustring a = "test"; // construct with a value, aka value-intialization
为了提高运行时效率并允许语义自由，C ++不会将默认构造函数ustring::ustring()和赋值运算符ustring::operator=(const char*)推断为构造函数ustring::ustring(const char *)。
但是，对于大多数合理的字符串类，这将起作用：
ustring::ustring(const char *str)
: /* initialize ustring::ustring() does */ {
/* do whatever ustring::ustring() does */
*this = str; // assign value.
}
最好从构造函数中调用赋值运算符，而不是相反地尝试它。
当然，您可以通过在执行初始化时考虑给定字符串的长度来提高效率。