标签: temporary-objects

我想知道哪个更高效,在PHP中使用$ _SESSION变量存储临时数据(与该会话相关)或从SQL数据库存储和检索？

感谢您的时间.

IMO临时对象存储在动态(堆)内存中,但我不确定.你能否确认或否认我的想法？

我认为引用只会将临时工具的生命周期延长到引用本身的生命周期,但下面代码片段的输出似乎是矛盾的:

#include <iostream>

struct X{ ~X(){ std::cout << "Goodbye, cruel world!\n"; } };

X const& f(X const& x = X()){
  std::cout << "Inside f()\n";
  return x;
}

void g(X const& x){
  std::cout << "Inside g()\n";
}

int main(){
  g(f());
}

实例.输出:

Inside f()
Inside g()
Goodbye, cruel world!

因此看起来临时g()被称为......被赋予了什么？

常规字符串字符串文字具有以下定义:

普通字符串文字和UTF-8字符串文字也称为窄字符串文字.窄字符串文字的类型为"n const char数组",其中n是下面定义的字符串大小,并且具有静态存储持续时间(3.7).

我假设因为它具有静态存储持续时间并且它们通常被放置在ROM中,如果有一个悬挂引用它真的没什么大不了的.以下代码发出警告

const char* const & foo()
{
    return "Hello";
}
// warning: returning reference to temporary [-Wreturn-local-addr]

但即使没有static关键字,这也没关系

const char* const & foo()
{
    const char* const & s = "Hello";
    return s;
}

那两者有什么区别？

在C++中(如果错误请纠正我),通过常量引用的临时绑定应该比它绑定的表达式更长.我认为在Rust中也是如此,但在两种不同情况下我得到了两种不同的行为.

考虑:

struct A;
impl Drop for A { fn drop(&mut self) { println!("Drop A.") } }

struct B(*const A);
impl Drop for B { fn drop(&mut self) { println!("Drop B.") } }

fn main() {
    let _ = B(&A as *const A); // B is destroyed after this expression itself.
}

输出是:

Drop B.
Drop A.

这是你所期望的.但现在如果你这样做:

fn main() {
    let _b = B(&A as *const A); // _b will be dropped when scope exits main()
}

输出是:

Drop …

这个代码是UB吗？

struct A
{
 void nonconst() {}
};

const A& a = A{};
const_cast<A&>(a).nonconst();

换句话说,(临时)对象原来是const？我已经查看了标准,但找不到答案,所以会对相关部分的引用表示赞赏.

编辑:对于那些说A{}不是的人const,你能做到A{}.nonconst()吗？

我喜欢在c ++中使用哨兵类,但我似乎有一种精神上的痛苦,导致反复编写如下错误:

{
  MySentryClass(arg);
  // ... other code
}

毋庸置疑,这是失败的,因为哨兵在创作后立即死亡,而不是在预期的范围结束时死亡.有没有办法防止MySentryClass被实例化为临时代码,以便上面的代码无法编译,或者至少在运行时中止错误消息？

考虑C++中的以下代码:

struct A {A(int);};
A foo() {return static_cast<A>(0);}
A x = foo();

这里static_cast<A>(0)通过标准[5.2.9-4]创建一个临时对象,它是一个prvalue.标准[12.2-1]说

类型的临时数在各种上下文中创建:绑定对prvalue的引用(8.5.3),返回prvalue(6.6.3),创建prvalue的转换(4.1,5.2.9,5.2.11,5.4) ,抛出异常(15.1),进入处理程序(15.3),以及一些初始化(8.5).

那么return语句会再次创建一个临时对象吗？

顺便说一下,任何人都可以告诉我标准是否保证隐式类型转换会创建一个临时对象？

[class.temporary]/7中当前的 C++ 标准草案包含短语

除函数参数对象之外的临时对象

我的印象是函数参数对象不是临时对象。然而，这个短语是最近才添加的。那么我是否错误或误解了上下文？

请考虑以下代码:

#include <iostream>

using namespace std;

class A
{
    public:
        int a;
        A(): a(5)
        {
           cout << "Constructor\n";
        }
        A(const A &b)
        {
            a = b.a;
            cout << "Copy Constructor\n";
        }
        A fun(A a)
        {
            return a;
        }
};

int main()
{
    A a, c;
    A b = a.fun(c);
    return 0;
}

上面代码的输出g++ file.cpp是:

Constructor
Constructor
Copy Constructor
Copy Constructor

上面代码的输出g++ -fno-elide-constructors file.cpp是:

Constructor
Constructor
Copy Constructor
Copy Constructor
Copy Constructor

我知道返回值优化.我的问题是哪个复制构造函数的调用被删除(返回期间的临时对象或被复制到b的返回对象)？

如果省略的复制构造函数是用于创建b的构造函数,那么如何创建b(因为在这种情况下也没有构造函数调用)？

如果我替换行A b …