子表达式中临时对象的生存期
是指在一个表达式中创建的临时对象的存在时间。临时对象是指在表达式求值过程中临时创建的对象，它们在表达式求值完成后会被销毁。
临时对象的生存期取决于编程语言的规范和具体实现。一般情况下，临时对象的生存期会尽可能短，以便节省内存和资源。在子表达式中，临时对象的生存期通常是在该子表达式求值完成后立即结束。
临时对象的生存期在编程中有一些重要的应用场景。例如，在函数调用中，临时对象可以用于传递参数或者作为函数返回值。在算术运算中，临时对象可以用于保存中间结果。在对象的构造和析构过程中，临时对象可以用于辅助完成对象的创建和销毁。
腾讯云提供了一系列与云计算相关的产品，其中包括云服务器、云数据库、云存储、人工智能服务等。这些产品可以帮助用户快速搭建和管理云计算环境，提供稳定可靠的计算和存储能力，支持各种应用场景的需求。
以下是腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：提供弹性计算能力，支持多种操作系统和应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库（CDB）：提供高性能、可扩展的数据库服务，包括关系型数据库和NoSQL数据库。详情请参考：https://cloud.tencent.com/product/cdb
- 云存储（COS）：提供安全可靠的对象存储服务，适用于各种数据存储和备份需求。详情请参考：https://cloud.tencent.com/product/cos
- 人工智能（AI）：提供丰富的人工智能服务，包括图像识别、语音识别、自然语言处理等。详情请参考：https://cloud.tencent.com/product/ai
以上是腾讯云在云计算领域的一些产品和服务，可以根据具体需求选择适合的产品来支持和扩展云计算应用。
相关·内容
3回答
我有以下代码(简化版本)：
const int& function( const int& param )
{
return param;
}
const int& reference = function( 10 );
//use reference
我不太清楚C++03标准$12.2/5的措辞有多大
：绑定引用的临时对象或临时对象，该对象是对临时绑定的子对象的完整对象，在引用的生存期内.
在这里适用。
以上代码中的reference变量是有效的还是悬空的？调用代码中的引用会延长作为参数传递的临时参数的生存期吗？
浏览 0提问于2012-04-17得票数 10
回答已采纳
2回答
我读到了函数调用之间的return值，
并对以下代码片段进行了实验：
/* file structaddr.c */
#include <stdio.h>
#define MSIZE 10
struct simple
{
char c_str[MSIZE];
};
struct simple xprint(void)
{
struct simple ret = { "Morning !" };
return ret;
}
int main(void)
{
printf("Good %s\n", x
浏览 4提问于2013-07-27得票数 7
回答已采纳
在下面的代码片段中..。在Quote::toXML成员变量中存储对ToXML::s_返回的临时字符串的引用安全吗，至少只要它只与<<操作符一起使用即可？也就是说，子表达式q.toXML的结果是否存活到下一个;。
w.r.t.的完整表达式是什么？q.toXML的返回值。整个std::cout还是对ToXML构造函数的调用？
#include <iostream>
#include <string>
struct ToXML
{
ToXML(char const * const tag, std::string const & s) : tag
浏览 2提问于2015-09-27得票数 2
回答已采纳
1回答
人们经常听说，在C++中，临时对象在完整表达式的末尾被解构。完整表达式被定义为不是其他表达式的子表达式的表达式。在我看来，这听起来非常类似于声明的概念。
所以我的问题是:如果我在一个完整表达式后面加一个分号，它会永远是一种陈述吗？一个人能通过在结尾取一些带有分号的语句，并去掉那个分号来达到每个完整的表达式吗？我是否可以假设每一个临时的人都会活到它的声明结束。
浏览 2提问于2017-02-28得票数 4
回答已采纳
我有以下代码：
#include <iostream>
using namespace std;
void func1(int &&val) {
// statements
}
int main() {
const int &i = 5; //line1
func1(4);// line 2
return 0;
}
第1行中I的生存期是否与main()的生存期或作用域相同？第2行中整数字面值4的生存期如何，它的生存期是否也与main()相同？
浏览 7提问于2022-01-10得票数 0
1回答
按照这个问题的公认答案，，当将x值分配给问题中的rvalue引用lvalue时，lvalue的生存期似乎没有延长。但是当我这么做的时候
#include <iostream>
using namespace std;
class Something {
public:
Something() {
cout << "Something()" << endl;
}
Something(const Something&) {
cout << "Something
浏览 3提问于2017-02-24得票数 7
2回答
假设您有以下代码(在c++14中)：
auto && a = a_function_returning_a_temp_rvalue();
在哪里存储返回的值，何时调用其析构函数，a const (考虑到函数不返回const )，它是如何在标准中指定的？(甚至是合法的)
另外，您确认了吗，临时数据实际上是绑定到a上的，并且没有operator= --这两个构造函数都不会被调用？
它在g++上编译，避免输入长模板类，但在使用它之前，我想检查它是否在c++14中清楚说明
浏览 2提问于2017-04-11得票数 0
回答已采纳
2回答
C++标准草案N4296说
第二个上下文是将引用绑定到临时上下文时。引用绑定到的临时对象或临时对象，该对象是引用绑定的子对象的完整对象，除非.
所以我想知道如果两个或两个以上的引用被绑定到一个临时的话会发生什么。它是标准中的特定吗？下面的代码可以是一个例子：
#include <iostream> //std::cout
#include <string> //std::string
const std::string &f() {
const std::string &s = "hello";
static
浏览 1提问于2015-11-21得票数 5
回答已采纳
1回答
我的印象是，std::initializer_list在C++中的行为可能类似于文字字符串，而且它们还可能延长const引用的生存期。这是正确的评估吗？
initializer_list 中的对象可以在本地范围内被稍后引用(而不是复制它们)吗？在全球范围？
例如，这个测试通过GCC和clang。这只是偶然吗？
#include<cassert>
#include<initializer_list>
struct A{
double const* p;
A(std::initializer_list<double> il){ p = &
浏览 0提问于2018-12-15得票数 2
回答已采纳
1回答
我所知道的
我知道返回临时对象的const引用是可以的！(如下面的示例：)
class A {
public:
virtual const A& clone () { return (A()); }
virtual std::string name() const { return ("A"); }
};
但!
如果我想这样做，这仍然是正确的：
class B : public A {
public:
virtual const A& clone () { return (B()); }
virtual std::string name() c
浏览 3提问于2014-10-09得票数 5
回答已采纳
1回答
总参考成员和临时寿命
、、、、
给定此代码示例，传递给S的临时字符串的生存期规则是什么。
struct S
{
// [1] S(const std::string& str) : str_{str} {}
// [2] S(S&& other) : str_{std::move(other).str} {}
const std::string& str_;
};
S a{"foo"}; // direct-initialization
auto b = S{"bar"}; // copy-initialization with r
浏览 1提问于2016-02-10得票数 13
回答已采纳
4回答
请有人解释一下为什么在下面的代码示例中bar的行为与foo不同？
#include <iostream>
using namespace std;
struct A {
A() { cout << "A"; }
~A() { cout << "B"; }
};
void foo() {
A a{};
cout << "X";
}
void bar() {
A {};
cout << "X
浏览 7提问于2013-12-04得票数 0
回答已采纳
作为函数调用参数的一部分创建的临时函数是否保证在被调用的函数结束之前一直存在，即使临时函数不是直接传递给函数的呢？
这几乎不可能是连贯的，所以这里有一个例子：
class A {
public:
A(int x) : x(x) {printf("Constructed A(%d)\n", x);}
~A() {printf("Destroyed A\n");}
int x;
int* y() {return &x;}
};
void foo(int* bar) {
printf("foo(): %d\n
浏览 6提问于2010-06-14得票数 25
回答已采纳
我正在试验受启发的通用参考资料。
因此，我尝试了以下几点：
#include <iostream>
#include <cassert>
template<typename T>
T& f(T&& var){
std::cout<< &var << std::endl;
return var;
}
int main() {
int& j = f(10);
std::cout<< &j << ", " <&l
浏览 3提问于2014-08-12得票数 1
回答已采纳
2回答
函数返回的对象的延长生存期
、、、、
对于函数返回并绑定到rvalue/const lvalue引用的对象的生存期的延长，我有些不清楚的信息。来自的信息。
对返回语句中函数的返回值的临时绑定不会扩展:它将在返回表达式的末尾立即销毁。这样的函数总是返回一个悬空引用。
如果我正确理解它，则引号声明返回语句返回的对象的生存期不可扩展。但最后一句表明，这只适用于返回引用的函数。
在GCC上，此代码生成以下输出：
struct Test
{
Test() { std::cout << "creation\n"; }
~Test() { std::cout << "des
浏览 6提问于2017-04-11得票数 9
回答已采纳
3回答
更新问题
源代码：
int a = 0;
auto && b = a++;
++a;
cout << a << b << endl;
打印20
在b调用之后使用a++是未定义的行为(UB)吗？也许我们不能使用b，因为它指的是临时的？
浏览 9提问于2016-02-10得票数 12
回答已采纳
可能重复：
我了解到，如果我在const中使用&在赋值(以及在被调用的方法签名中)中，引用对象的生存期将被延长到方法的结束。
Employee const& getEmp(int a) {
return Employee(a);
}
Employee const& tmpEmp = m.getEmp(10); //
... stuff
//end of scope - tmpEmp valid until here
我写了很少的程序，看到它像预期的那样工作。我的问题不是怎么做的？我的问题是编译器是如何做到这一点的？正如您从示例中看到的，析构函数在返
浏览 0提问于2012-08-01得票数 2
回答已采纳
1回答
这也许是关于C++11的一个愚蠢的问题，但它真的困扰着我。
据我理解，rvalue引用也是一个引用，这意味着它将点指向某个变量，就像引用一样。
例如,
const int &ref = 1;
引用ref指向不能修改的纯rvalue 1，这就是编译器强制我们使用const的原因。
另一个例子，
Bar&& GetBar()
{
Bar b;
return std::move(b);
}
此函数将返回一个悬空引用，因为b在returning之后被销毁。
总之，rvalue引用也就是引用。
现在我糊涂了。请检查以下代码：
int &&rref
浏览 1提问于2020-09-27得票数 2
回答已采纳
是下列(人为的示例)可以还是未定义的行为：
// undefined behavior?
const auto& c = SomeClass{};
// use c in code later
const auto& v = c.GetSomeVariable();
浏览 2提问于2019-10-31得票数 11
回答已采纳
如果我编写以下代码：
#include <iostream>
using namespace std;
int main()
{
cout << &(int &&)123 << endl;
return 0;
}
然后g++抱怨道：
foo.cc: In function ‘int main()’:
foo.cc:7:20: error: taking address of xvalue (rvalue reference)
好吧，多亏了，我才知道xvalue意味着它即将“过期”，这是有道理的。但现在如果我这么做
#inc
浏览 0提问于2012-02-27得票数 8
回答已采纳
给予：
struct hurg { ... };
hurg get_hurg() { return hurg(); }
hurg&& get_mhurg() { return hurg(); }
我对的理解表明，以下不是未定义的行为(编辑:感谢答案，结果发现我错了，get_mhurg()示例是未定义的行为)：
{
const hurg& a = get_hurg();
hurg&& b = get_hurg();
const hurg& c = get_mhurg();
hurg&& d =
浏览 0提问于2015-08-03得票数 3
回答已采纳
2回答
考虑以下代码：
struct foo
{
foo(foo const&) = default; // To make sure it exists
};
foo& get_local_foo_reference()
{
foo my_local_foo;
return my_local_foo; // Return a reference to a local variable
}
int main()
{
foo my_foo = get_local_foo_reference();
}
现在，每个人都会同意，返回对局部变量的引用是不好
浏览 0提问于2018-06-07得票数 5
回答已采纳
假设我有一个按值返回std::vector的函数：
std::vector<int> buildVector();
使用基于范围的for迭代结果似乎很自然。
for (int i : buildVector()) {
// ...
}
问:这样做安全吗？
我对标准(实际上是草案)的解读表明，它可能不是，尽管我很难相信委员会没有考虑到这种用法。我希望我的阅读是错误的。
第6.5.4节定义了基于范围的for
for ( for-range-declaration : expression ) statement
有以下几点：
{
auto && __range
浏览 4提问于2015-05-26得票数 36
回答已采纳
1回答
因为c++提供了对rvalue的引用，即rvalue引用，这些引用主要用于执行移动、语义和其他内存高效的任务。但是在下面的情况下，引用改变了文字的值，但是正如我们所知道的，文字是只读的，所以引用如何能够改变一些只读变量的值。rvalue引用是分配自己的内存，还是简单地更改文字的值？
#include <iostream>
using namespace std;
int main()
{
int a = 5;
int&& b = 3;
int& c = a;
b++;
c++;
cout << &
浏览 2提问于2016-05-30得票数 10
回答已采纳
考虑到以下代码：
template <typename U> U func1(std::function<U()> func2) {
return func2();
}
const int x = 1;
const int& result1 = func1<const int&>([&x]() { return x; });
// result1 = ??????? (random garbage)
const int& result2 = [&x]() { return x; }();
// result2 =
浏览 2提问于2018-01-04得票数 2
回答已采纳
有类似的代码
#include <stdio.h>
struct P2d {
double x, y;
P2d(double x, double y) : x(x), y(y) {}
~P2d() { printf("Destructor called\n"); }
};
P2d center() {
return P2d(10, 10);
}
int main(int argc, const char *argv[]) {
const double& x = center().x;
printf(
浏览 5提问于2016-03-11得票数 31
回答已采纳
3回答
从函数返回临时对象的引用
、、、
考虑以下代码-
#include <iostream>
#include <stdio.h>
const int & retRef() {
return 6;
}
int main()
{
const int& k = retRef();
printf("Value: %d\n", k);
printf("Address: %p\n", &k);
printf("Value: %d\n", k);
return 0;
}
输出是-
Value: 6
浏览 1提问于2018-12-03得票数 4
回答已采纳
我看到一旦返回一个本地对象，编译器将接受返回值优化。(RVO，NRVO)。
标准祝福RVO的部分接着说，如果满足RVO的条件，但是编译器选择不执行复制省略，返回的对象必须被视为rvalue。
所以我们只需要写这样的代码：
Widget makeWidget()
{
Widget w;
…
return w;//never use std::move(w);
}
我从来没见过有人写这样的代码：
Widget&& makeWidget()
{
Widget w;
…
return std::move(w);
}
我知道返回本地对象的lvalue引用总是错误的
浏览 5提问于2015-03-09得票数 16
回答已采纳
这是问题的后续。答案-呃没有回复我的评论，我也不可能从他的回答中理解，也不知道如何解决这个问题。所以我提出了这个问题，我对此表示诚挚的歉意。
考虑以下代码：
#include <iostream>
using namespace std;
struct foo{const char* bar ; foo(): bar("This is foo"){} };
foo returnByValue(){ return foo(); }
const foo& returnByConstRef() { return returnByValue(); } // *
浏览 2提问于2015-09-23得票数 2
回答已采纳
2回答
我注意到，在c++的visual studio中，每当我运行如下代码时
#include "stdafx.h"
#include <iostream>
int &test() {
int num = 19;
return num;
}
int main() {
auto &num = test();
std::cout << num << std::endl;
}
这显然是行不通的，因为num在测试中是一个本地对象，但它在visual studio上是如何编译的。此外，此代码还会编译
#i
浏览 0提问于2016-03-12得票数 0
2回答
在下面的片段中，球面的生存期是否扩展到r的值不是未定义的？
struct Sphere {
auto& radius() const { return _radius;}
float _radius{};
};
struct Capsule {
auto sphere() const { return Sphere{12.0}; }
};
auto func() {
auto capsule = Capsule{};
const auto& r = capsule.sphere().radius();
std::cout <&
浏览 1提问于2018-03-13得票数 8
回答已采纳
1回答
汽车及外部范围
、、、
我认为写作是对的吗？
auto && x = ...;
在范围的for (...)部分之外几乎没有任何意义，因为如果右手边确实是一个r值，它通常会在分号处停止存在，然后x指的是已经被破坏的东西。
换言之：
Widget f () { ... }
...
auto && x = f();
// do something with x
错了吗？
浏览 2提问于2015-02-12得票数 1
回答已采纳
下面的代码使用g++ 6.3.0和-Wall一起干净地编译。
#include <iostream>
class Base
{
public:
Base(char const* base) : base_(base) {}
void print( char const* msg ) { print( base_, msg ); }
protected:
~Base() = default;
private:
char const* base_;
virtual void print( char const*, char const* )
浏览 0提问于2019-02-08得票数 3
回答已采纳
可能重复：
嗨，当我写这段代码时：
//Returns the transpose matrix of this one
SparseMatrix& SparseMatrix::transpose()const{
vector<Element> result;
size_t i;
for(i=0;i<_matrix.size();++i){
result.push_back(Element(_matrix.at(i)._col, _matrix.at(i)._row, _matrix.at(i)._val));
}
浏览 2提问于2010-10-06得票数 17
我理解为什么int& x=1是非法的(您不能引用常量值)，但是我不明白为什么const int& x=1是合法的？你怎么能引用"1“这个数字？它甚至不是一个定义的变量。
编辑:我阅读了在这篇文章中给出的答案：，但是有人能解释一下他的意思是“表达式f(1)返回的临时值的生存期将被延长。这个规则对于const引用是唯一的。”所以文字是以int形式存储在堆栈上的吗？谢谢!
浏览 8提问于2014-07-21得票数 4
回答已采纳
最近，我被告知在C++中找到一个临时变量，将其提升到具有完整的词法范围：
class Foo {
public:
Foo() {
std::cout << "A";
}
~Foo() {
std::cout << "B";
}
};
int main(void)
{
// Prints "ACB", showing the temporary being promoted to having lexical scope.
const Foo&
浏览 3提问于2013-02-05得票数 2
1回答
#include <iostream>
struct A{
A(int){
}
~A(){
std::cout<<"A destroy\n";
}
};
struct B{
B(int){
std::cout<<"B construct\n";
}
~B(){
std::cout<<"B destroy\n";
}
};
struct Content{
A cons
浏览 5提问于2020-12-25得票数 11
我遇到了这样的代码：
std::vector<foo> someFunction(Args args)
{
std::vector<foo> value;
/*...*/
return value;
}
std::vector<foo> someOtherFunction(OtherArgs args)
{
std::vector<foo> value;
/*...*/
return value;
}
const auto bar = someFunction(args);
const auto&
浏览 0提问于2019-09-12得票数 1
回答已采纳
考虑一下
struct A {
~A() {std::cout << "A's dtor called\n";}
};
A f1(const A& a)
{
return a;
}
int main()
{
{
const A& r = f1(A());
std::cout << "XXX\n";
}
std::cout << "YYY\n";
}
输出：
A's dtor called
XXX
A's dtor
浏览 5提问于2017-12-03得票数 2
回答已采纳
3回答
const引用默认值
、、、
可能重复：
#include <string>
void foo1(const std::string& s = std::string());
void foo2(std::string& s = std::string());
void foo3(const std::string s = std::string());
void foo4(std::string s = std::string());
error at foo2(): default argument for ‘std::string& s’ has type ‘st
浏览 3提问于2013-01-30得票数 22
回答已采纳
在最新的C++标准中，它意味着：
for (foo : bar)
baz;
等同于：
{
auto && r = bar;
for ( auto it = r.begin(), end = r.end(); it != end; ++it )
{
foo = *it;
baz;
}
}
当上面的bar是一个返回集合的函数调用时，例如：
vector<string> boo();
即
for (auto bo : boo())
...
这行代码不是变成了：
auto&& r
浏览 5提问于2012-03-12得票数 23
回答已采纳
1回答
返回Rvalue引用和临时物化
、、、、
考虑以下功能。我想要C++17的答案。
MyClass&& func() {
return MyClass{};
}
int main() {
MyClass&& myRef = func();
}
问题：
表达式func()是xvalue吗？为什么？
为什么myRef是一个悬空的引用？或者，更确切地说，为什么func()返回一个悬空引用？返回rvalue引用不会导致临时物化，并延长临时对象的生存期吗？
浏览 7提问于2020-06-10得票数 3
回答已采纳
3回答
关于暂时性奇性的比较
、、、
我们都知道这样的事情在c++中是有效的：
const T &x = T();
同时：
T &x = T();
不是。
在中，对话导致了这条规则。OP发布了一些代码，这些代码清楚地让人联想到UB。但我希望修改后的版本能够工作(这是修改后的版本)：
#include <iostream>
using namespace std;
class A {
public:
A(int k) { _k = k; };
int get() const { return _k; };
int _k;
};
class B {
public:
B(c
浏览 8提问于2010-06-22得票数 8
回答已采纳
2回答
询问是否所有的临时值都是右值。
答案是否定的，因为如果我们考虑这个表达式：
const int &ri = 2 + 3;
然后，完全相同的临时(2 + 3) (这里是一个右值)可以用作后续表达式中的左值：
const int *pi = &ri;
所以这个临时值不是(唯一的)一个右值。
那么逻辑语句temporary ==> rvalue就是false。
但是，我们不能写
const int &ri = &(2 + 3); // illegal, 2 + 3 -> temporary -> rvalue
或
int *i = &4; /
浏览 2提问于2012-11-03得票数 1
回答已采纳
1回答
我经常编写通过非const引用获取参数的函数，但缺点是不能传递r值。
我的一位同事给我看了一段据说能解决问题的代码：
#include <iostream>
// example function
int f(int& x) {
x += 5;
return x;
}
// is this undefined behaviour?
auto& to_l_value(auto&& x) {
return x;
}
int main () {
auto y = f(to_l_value(5)); // usage e
浏览 2提问于2021-09-13得票数 6
回答已采纳
今天，我看到了我老板的代码，它使用const引用作为map的值类型。
下面是代码：
class ConfigManager{
public:
map<PB::Point, const PB::WorldPoint&, compare_point> world_point;
//the rest are omitted
};
(PB是Google，我们正在使用Protobuf库。我对此不太了解，也不知道是否与这个问题有关。)
这个类所做的是读取一些配置文件，并将其放入一些map中进行搜索。
一开始我很惊讶，因为我还没有看到一个以引用作为其值的
浏览 0提问于2020-10-22得票数 2
1回答
考虑以下代码示例：
SomeClass Callee() {
// Option 1:
return SomeClass(/* initializer here */);
// Option 2:
SomeClass tmp(/* initializer here */);
// Do something to tmp here
return tmp;
}
void Caller() {
SomeClass a(/* initializer here */);
SomeClass b = Callee();
SomeClass c(/* initializer
浏览 3提问于2017-09-12得票数 0
回答已采纳
2回答
SomeStruct getSomeStruct();
const SomeStruct a = getSomeStruct();
const SomeStruct &b = getSomeStruct();
我理解按值传递与参照传递与参照传递之间的区别。我的问题是，上述示例是否与向函数传递参数时相同？所以b的赋值更快，因为它不需要复制数据，不像a的赋值
浏览 3提问于2020-04-16得票数 3
回答已采纳
2回答
struct Base {
Base() {
std::cout << "Inside: " << __PRETTY_FUNCTION__ << std::endl;
}
~Base() {
std::cout << "Inside: " << __PRETTY_FUNCTION__ << std::endl;
}
};
struct BaseWrapper {
const Base &b;
};
int
浏览 0提问于2019-03-06得票数 3
回答已采纳
我正在处理模板和c++语法，我注意到，当函数定义如下时，您可以通过调用add(2,3)传递引用：
#include <iostream>
using namespace std;
auto add(const int& lhs, const int& rhs)
{
return lhs + rhs;
}
int main()
{
cout << add(2, 3) << '\n';
getchar();
return 0;
}
为什么这样做是违法的：
int& r = 3;
但是我
浏览 2提问于2019-04-07得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
