这两个函数之间创建的临时对象的数量是否有差异？
string foo1() {
return "";
}
string foo2() {
string s = "";
return s;
}
这是一个功课问题所以请假设没有编译器优化.
我有一个std::wstring decode(const char *s)功能.
我这样使用它:
const char *src = "some string";
const wchar_t *result = decode(src).c_str();
我总是得到垃圾result[0],有时result[1]也是垃圾.
当我以另一种方式使用它时,我不会得到垃圾:
std::wstring res = decode(src);
const wchar_t *result = res.c_str();
我的decode功能定义如下,它确实起作用了.唯一的问题是调用代码(上图).
std::wstring decode(const char *s, UINT cp=CP_ACP)
{
if(s == NULL)
return std::wstring();
int length = ::MultiByteToWideChar(cp, 0, s, -1, NULL, 0 );
wchar_t *buf = new wchar_t[length];
::MultiByteToWideChar(cp, 0, s, -1, buf, length);
std::wstring r(buf);
delete[] buf;
return r;
}
我使用Visual C++ 2008 SP1进行编译.
我正在学习本教程 - http://www.learncpp.com/cpp-tutorial/132-function-template-instances/
// passing all parameters by references
template <typename T1, typename T2>
const T2& add_two_objects(const T1& x,const T2& y) {
return x+y;
};
int main() {
using std::cout;
int x(0),y(0);
std::cout << "Please enter number 1" << std::endl;
std::cin >> x;
std::cout << "Please enter number 2" << std::endl;
std::cin >> y;
cout<< "sum of two integers is " << add_two_objects(x,y+1.2) << '\n';
cout<< "sum of two double is " << add_two_objects(x,y+2.52424324) << '\n';
return 0;
}
程序编译得很好,但在运行时,我总是遇到分段错误.但是,如果我将模板更改为按值传递,则一切正常. …
我有这个初始化：
const char* str = std::string("a").c_str();
在此初始化中创建了多少个临时对象？
可以"a"算是临时的。宾语？
我知道std::string("a")是临时的。宾语。
的结果c_str()是一个对象，str将其存储。所以这不是临时的。对象，对不对？
根据文档（），其中说：
当实现引入具有重要构造函数（[class.default.ctor]、[class.copy.ctor]）的类的临时对象时，它应确保为临时对象调用构造函数。类似地，应使用非平凡的析构函数（[class.dtor]）来调用临时析构函数。临时对象在评估完整表达式 ([intro.execution]) 的最后一步被销毁，该完整表达式（在词法上）包含创建它们的点。即使该评估最终引发异常也是如此。销毁临时对象的值计算和副作用仅与完整表达式相关联，而不与任何特定的子表达式相关联。
如何理解“临时对象被销毁作为评估完整表达式（[intro.execution]）的最后一步，该完整表达式（从词法上）包含它们被创建的点。”？任何人都可以通过一些简单的例子说清楚吗？
#include <vector>
std::vector<int> f()
{
return std::vector<int>(1024);
}
void use_1(std::vector<int> const&)
{}
void use_2(std::vector<int> const&)
{}
int main()
{
{
auto const& v = f(); // style 1
use_1(v);
use_2(v);
}
{
auto&& v = f(); // style 2
use_1(v);
use_2(v);
}
{
auto v = f(); // style 3
use_1(v);
use_2(v);
}
}
哪个更好？样式 1、样式 2或样式 3？
在我看来，如果返回类型没有实现移动语义，那么样式 1和样式 2比样式 3更有效。
我有一个关于在使用时返回对本地对象的引用的编译警告visit()，但我无法理解为什么......
我使用以下代码（有点做作，但这是出于演示目的）：
#include <iostream>
template <class... Ts> struct overloaded : Ts... {
using Ts::operator()...;
};
template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
using namespace std;
class B {
public:
B(int i) :
i_(i) {}
int get_i() const {
return i_;
}
private:
int i_;
};
class D: public B {
public:
D(int i) :
B(i) {}
};
const B& as_base(const variant<B, D>& op) {
return visit(overloaded {
[](const B& b) { return static_cast<const B&>(b); },
[](const D& d) { …目前,我正在从文本文件中删除一大块数据(段落/字符串)并将其写入新文件.但是,我计划稍后添加一些条件,因此希望能够取出这一块数据并仅将其存储在临时数组中,然后在满足条件时写出文件.但是,我不知道如何在不知道数组大小的情况下将其写入数组.
有没有人有任何想法？
我知道 const 引用会延长本地临时文件的寿命。现在我问自己是否可以在临时对象链上扩展此属性，也就是说，我是否可以安全地定义：
std::string const& foo = aBar.getTemporaryObject1().getTemporaryObject2();
我的感觉是，由于第一个方法aBar.getTemporaryObject1()已经返回了一个临时对象，因此不适用于aBar.getTemporaryObject2().
在这样的代码中
#include <iostream>
#include <memory>
struct A {
int i;
A() {
std::cout << "A()" << std::endl;
}
~A() {
std::cout << "~A()" << std::endl;
}
};
void f(const A& a) {
std::cout << "f(A)" << std::endl;
}
std::unique_ptr<A> make_a() {
return std::make_unique<A>();
}
int main() {
f(*make_a());
}
是否可以保证A仅在f()执行对象后删除该对象？