声明一个引用并稍后初始化？

Question

我引用了某个类 MyObject，但确切的对象取决于条件。我想做这样的事情：

MyObject& ref; 
if([condition]) 
  ref = MyObject([something]);
else 
  ref = MyObject([something else]);

我现在不能这样做，因为编译器不允许我声明但不能初始化引用。我可以做些什么来实现我的目标？

Answer 1

你需要初始化它。但是如果你想有条件地初始化它，你可以这样做：

MyObject& ref = (condition) ? MyObject([something]) : MyObject([something else]);

Answer 2

AFAIK 这不能通过参考来完成。您必须使用指针：

MyClass *ptr;

if (condition)
    ptr = &object;
else
    ptr = &other_object;

指针的作用类似于引用。只是不要忘记使用-> 进行会员访问。

Answer 3

你不能这样做。引用必须绑定到某个东西，你可能不喜欢它，但它可以防止一整类错误，因为如果你有一个引用，你总是可以假设它绑定到某个东西，不像指针可能为空。

您的示例代码无论如何都不起作用，因为您尝试将非常量引用绑定到一个无效的临时对象。

为什么你仍然需要它作为参考？一种解决方案是确保您的类型具有廉价的默认构造函数并且可以有效地移动，然后就这样做：

MyObject obj; 
if([condition]) 
  obj = MyObject([something]) 
else 
  obj = MyObject([something else]);

否则，您必须将条件代码放在一个或多个函数中：

const MyObject& ref = createObject([condition]);

或

const MyObject& ref = [condition] ? doSomething() : doSomethingElse();

请注意，这两个版本都使用 const 引用，它可以绑定到临时对象，如果对象必须是非常量，则再次停止尝试使用引用：

MyObject obj = createObject([condition]);

感谢return value optimization，这可能与您尝试做的一样有效

Answer 4

我喜欢做的是立即执行的 lambda。

假设我们想要一个 const std::string& 到映射下的变量 - 如果映射不包含给定的键 - 我们想要抛出。

int main()
{
  std::map<std::string, std::string> myMap = {{"key", "value"}};

  const std::string& strRef = [&]()->const std::string& {
    try {
      return myMap.at("key"); // map::at might throw out_of_range
    }
    catch (...) {
      // handle it somehow and/or rethrow.
    }
  }(); // <- here we immediately call just created lambda.
}

---

您还可以使用 std::invoke() 使其更具可读性（C++17 起）

int main()
{
  std::map<std::string, std::string> myMap = {{"key", "value"}};

  const std::string& strRef = std::invoke([&]()->const std::string& {
    try {
      return myMap.at("key"); // map::at might throw out_of_range
    }
    catch (...) {
      // handle it somehow and/or rethrow.
    }
  });
}

Answer 5

在 C++ 中，您不能在没有初始化的情况下声明引用。你必须初始化它。

Answer 6

简短的回答：你不知道。

略长一点的答案：做这样的事情：

MyObject& getObject()
{
    if([condition]) 
        return [something] 
    else 
        return [something else];
}

MyObject& ref = getObject();

当然适用关于参考的一般免责声明。

Answer 7

MyClass *ptr;

if (condition)
    ptr = &object;
else
    ptr = &other_object;

MyClass &ref = *ptr;

Answer 8

使用静态假人作为占位符。或 std::optional 与 reference_wrapper。

static X placeHolder_;
std::reference_wrapper<X> ref = placeHolder_;
   


std::optional<std::reference_wrapper<X>> ref ;    

Answer 9

我通常这样做（C++ 11 或更高版本）：

std::shared_ptr<ObjType> pObj;
if(condition)
    pObj = std::make_shared<ObjType>(args_to_constructor_1);
else
    pObj = std::make_shared<ObjType>(args_to_constructor_2);

它是干净的并且允许使用带有（可能不同的）构造的对象定义，这是你不能直接用指针做的事情，因为编译器会抱怨使用临时对象。

Answer 10

如果（[条件]） MyObject& ref = MyObject([something]); 别的 MyObject& ref= MyObject([something else]);

Answer 11

您可以使用在实际使用之前不需要初始化的模板。

  template <uint8_t c>
  uint8_t& ref; 
void setup()
{
  uint8_t a=1;
  uint8_t b=2;
if(true) 
  ref<1> = a;
else 
  ref<1> = b;
}

一些旧的 IDE 可能会将其标记为错误，但它会很好地通过编译。

Answer 12

您可以使用“extern”关键字：第一次（假设在头文件中）您可以使用“extern”关键字在声明之前声明变量。稍后（在源文件中）您重复没有“extern”的声明并为其赋值。