声明参考并稍后初始化？

我有对的引用MyOjbect，但确切的对象取决于条件。所以我想做这样的事情：

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

我现在无法执行此操作，因为编译器不允许我声明但不能初始化引用。我该怎么做才能实现自己的目标？

您需要对其进行初始化。但是，如果您想有条件地对其进行初始化，则可以执行以下操作：

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

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

MyClass *ptr;

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

指针的作用类似于参考。只是不要忘记->用于会员访问。

你做不到 引用必须绑定到某物，您可能不喜欢它，但是它可以防止整个类的错误，因为如果您有一个引用，则始终可以假定它已绑定到某物，这与指针可以为空不同。

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

无论如何，为什么需要它作为参考？一种解决方案是确保您的类型具有便宜的默认构造函数并可以有效地移动，然后执行以下操作：

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

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

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

要么

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

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

MyObject obj = createObject([condition]);

由于返回值的优化，这可能与您尝试执行的操作一样有效

在C ++中，没有初始化就不能声明引用。您必须初始化它。

简短的答案：你不知道。

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

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

MyObject& ref = getObject();

关于引用的通常免责声明当然适用。

我想做的是一个立即执行的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.
    }
  });
}

MyClass *ptr;

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

MyClass &ref = *ptr;

if（[condition]）MyObject＆ref = MyObject（[something]）; else MyObject＆ref = MyObject（[something]）;

我通常这样做（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);

这很干净，并且允许使用具有（可能不同）构造的对象定义，这是您不能直接使用指针执行的操作，因为编译器会抱怨使用临时对象。

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