原始指针可以指向堆栈或堆上分配的对象.
堆分配示例:
// heap allocation
int* rawPtr = new int(100);
std::cout << *rawPtr << std::endl; // 100
堆栈分配示例:
int i = 100;
int* rawPtr = &i;
std::cout << *rawPtr << std::endl; // 100
使用auto_ptr示例堆分配:
int* rawPtr = new int(100);
std::unique_ptr<int> uPtr(rawPtr);
std::cout << *uPtr << std::endl; // 100
使用auto_ptr示例堆栈分配:
int i = 100;
int* rawPtr = &i;
std::unique_ptr<int> uPtr(rawPtr); // runtime error
是否有"智能指针"用于指向堆上动态创建的对象？对于C++ 11,我们是否应该继续使用原始指针来指向堆栈分配的对象？谢谢.
我正在学习 Unicode，并有几个问题希望得到解答。
1）我读到，在 Linux 上，std::wstring是 4 字节，而在 Windows 上，它是 2 字节。这是否意味着 Linux 内部支持UTF-32而 Windows 内部支持UTF-16？
2) std::wstring 的使用与 std::string 接口非常相似吗？
3) VC++ 是否支持使用 4 字节 std::wstring？
4）如果使用std::wstring，是否必须更改编译器选项？
作为旁注，我遇到了一个用于处理 UTF-8 的字符串库，它具有与 std::string 非常相似的接口，它提供了熟悉的功能，例如长度、substr、查找、大小写转换等。该库是Glib ::ustring。
请随时添加任何评论或其他建议，因为我真的需要它。
谢谢你！
我的目标是逐个字符迭代Unicode文本字符串,但下面的代码是迭代代码单元而不是代码点,即使我使用next32PostInc(),它应该迭代代码点:
void iterate_codepoints(UCharCharacterIterator &it, std::string &str) {
UChar32 c;
while (it.hasNext()) {
c = it.next32PostInc();
str += c;
}
}
void my_test() {
const char testChars[] = "\xE6\x96\xAF"; // Chinese character ? in UTF-8
UnicodeString testString(testChars, "");
const UChar *testText = testString.getTerminatedBuffer();
UCharCharacterIterator iter(testText, u_strlen(testText));
std::string str;
iterate_codepoints(iter, str);
std::cout << str; // outputs ? in UTF-8 format
}
int main() {
my_test();
return 0;
}
上面的代码生成了正确的输出,这是中文字符,但是对于这个单个字符而不是只有1次迭代.有人可以解释我做错了什么吗？
简而言之,我只想在循环中遍历字符,并乐于使用任何ICU迭代类.
仍在努力解决这个问题......
我还观察到使用UnicodeString的一些不良行为,如下所示.我正在使用VC++ …
我将开始在一个项目中使用 MongoDB 并进行以下观察： 'Date' 必须是一个有效的时间点，并且不能为 NULL。
使用 MongoDB，我们不能存储 NULL 日期，所以我猜最好的办法是简单地从我们的文档中排除日期字段。
例如，如果我有一个“汽车”文档和一个名为“ date_sold ”的字段。如果汽车尚未售出，我只需从文档中排除此字段。汽车售出后，我可以添加 'date_sold' 字段。
通过执行上述操作，我假设我可以查询已售或未售汽车的记录。这是在 MongoDB 中处理“空”或空日期的推荐方法吗？
PS 我的困惑源于这样一个事实，因为 SQL 有一个架构，日期或日期时间字段可以存储为 NULL，但在 MongoDB 中，“日期”字段不能为 NULL，并且必须是一个有效的时间点。
我创建了一个实例化10亿次类的循环,并且非常惊讶地发现它在0ms内运行并且根据Windows任务管理器没有消耗CPU时间.
正如你从下面的代码中看到的那样,我显然没有对默认构造函数做任何事情,但我假设会有一个重要的CPU命中,然后一遍又一遍地破坏类.有人可以解释为什么没有明显的CPU命中？
class Cmytest {
public:
int lookup();
bool create_rec();
bool delete_rec();
};
void test() {
for (int i=0; i<1000000000; i++) {
Cmytest mytest;
}
}
int main()
{
test();
return 0;
}
在运行上面的测试之后,我想看看如果我在两个不同的线程中运行test()会发生什么(20亿次迭代但不包括代码以保持简洁性)并且没有明显的区别.
请指教,谢谢!
更新:
问这个的原因是因为我经常使用构图,而且我有一个Cmytest成员的类.根据某些数据条件,Cmytest的成员将被执行,而在其他情况下,它什么都不做.这是一个长期运行的Web应用程序,我一直关注效率.
最终更新:
我决定让实例做一些事情(以确保它不仅仅是优化而忽略了什么都不做的循环).我在这里看到了以下成员:
Cmytest::void count(int& i) {
i++;
}
然后我在循环中调用它:
int iter=0;
void test() {
for (int i=0; i<1000000000; i++) {
Cmytest mytest;
mytest.count(iter);
}
}
结果是10亿,如果在两个线程中运行,那么20亿是正确的.通过这种方式,我只能推断工作正在进行并且对象正在被重用,这解释了我观察到的效率.