可以传递匿名变量的地址吗？

Question

当我不需要一个命名对象在整个当前范围内徘徊时，我一直使用匿名变量。

我需要使用一个函数 - 在我的控制范围之外 - 它以指针作为参数并且不进行 NULL 检查。我希望能够传递匿名变量的地址（因为我不关心在取消引用的地址处写入的值），但遇到了编译错误。下面的简化示例...

#include <iostream>

void ptrFunc( const int* p )
{
  if ( p )
  {
    std::cout << "*p == " << *p << std::endl;
  }
}

void refFunc( const int& i )
{
  std::cout << "(ref)i == " << i << std::endl;
}

void valueFunc( int i )
{
  std::cout << "i == " << i << std::endl;
}

int main( int argc, char* argv[] )
{
  valueFunc( int() );   // This is fine.
  refFunc( int() );     // This is also fine.
  ptrFunc( &(int()) );  // This doesn't compile.
}

...生成此编译错误：

>g++ -g main.cpp 
main.cpp: In function 'int main(int, char**)':
main.cpp:25:19: error: lvalue required as unary '&' operand
   ptrFunc( &(int()) );  // This doesn't compile.
                   ^
>g++ --version
g++ (GCC) 4.8.3 20140911 (Red Hat 4.8.3-7)
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

编译器错误非常可读：需要左值才能使用地址运算符。但我想知道社区是否可以帮助我理解此限制背后的基本原理。在我看来我的尝试使用可能合理合法，因为匿名变量的生命周期取决于分号，即在 ptrFunc() 的生命周期中它是 "alive" .

我考虑是否考虑 "dangerous" 允许指向匿名变量的指针，因为它们的生命周期缩短。但实际上任何使用 if 指针——即使是左值或堆分配的对象都会遇到同样的问题：如果有人挂在任何指针上，它总是有可能指向无效内存的危险。指针的使用本质上取决于仔细的编码，我不认为这个尝试用例在这方面有什么特别不同。

我很想知道这背后的原理。谢谢。

我还尝试了什么？

尝试用gcc-4.9.2在线编译示例代码达到同样的效果；所以这个问题不是来自过时编译器的 limitation/bug。

Answer 1

最终，您在这里要求的内容并不存在，这是有充分理由的：具有地址的值必须位于某处，因此有一些 scope/lifetime。您将传递给函数的指针是一个地址。它可以被多次读取，并且，当非常量时，被写入。

编译器不知道调用函数将如何使用您的参数，并希望自由地放置右值，包括将它们折叠成代码中的常量，或将它们放入寄存器中。您不能获取该地址并将其传递给函数。

您所要求的似乎简化为编译器糖，它在堆栈上创建一个局部变量，引用它，并将它传递给一个函数，但在代码中隐藏它的地址，以便没有其他代码可以使用该值。 C++ 建立在显式内存管理之上，因此与此相反。

好的，但我真的很想这样做

不过为了好玩，我想你可以这样做：

#include <memory>
#include <iostream>

void ptrFunc( const int* p )
{
  if ( p )
  {
    std::cout << "*p == " << *p << std::endl;
  }
}

int main()
{
  ptrFunc(std::unique_ptr<int>(new int()).get());
  return 0;
}

这是如何工作的？

糟糕，因为它非常低效。从句法上讲，它可以做你想做的事，不过：

ptrFunc(                 // 1. call ptrFunc
  std::unique_ptr<int>(  // 2. instantiate a unique_ptr as a temporary
                         //    this takes a pointer to a heap-allocated value
                         //    and assumes ownership of it. it deletes that
                         //    value when it goes out of scope. for a
                         //    temporary, this happens after the expression.
    new int()            // 3. heap-allocate an integer
  ).get()                // 4. returns a raw-pointer to the heap-allocated
                         //    value owned by the unique_ptr. That value
                         //    becomes invalid memory if accessed after the
                         //    unique_ptr destroys it.
);

Answer 2

C++11引入了std::addressof()来获取变量的地址，即使它是覆盖operator&的class类型。您可以应用类似的技术来获取临时变量的地址，例如：

template <class T>
const T* addrtemp(const T& arg)     
{    
    return reinterpret_cast<T*>(    
        &const_cast<char&>(    
            reinterpret_cast<const volatile char&>(arg)
        )
    );    
}

ptrFunc( addrtemp(int()) );

Demo

Answer 3

But I'm wondering if the community can help me understand the rationale behind this restriction. It seems to me that my attempted use could reasonably be legal because the anonymous variable's lifetime is up to the semicolon, i.e. it is "alive" during ptrFunc()'s lifetime.

在这种情况下，是的，它会起作用。一般来说，没有。

引用导致临时文件的生命周期延长。指针没有。即，给定：

int main() {
    const int & a = 1;
    int && b = 2;
    const int * c = &static_cast<const int &>(3); // don't do this
    return a + b - *c;
}

引用 a 和 b 继续引用有效对象。指针 c 没有，并且没有合理的方法可以在指针是的内容没有发生重大根本变化的情况下对指针起作用。它对于引用是可行的，因为引用是一种新的（与 C 相比）语言特性，并且作为一种新的语言特性，使它们不可变是没有问题的。指针有很多使用它们的现有代码，这些代码会因规则的更改而失效。

可以传递匿名变量的地址吗？

Possible to pass address of anonymous variable?

c++

pointers

anonymous

lvalue

好的，但我真的很想这样做

这是如何工作的？