Как создать временную переменную в C++

Это хуже, чем плохая идея, это неопределенное поведение и в большинстве случаев приводит к сбою. Это плохо (ТМ).

Что вы можете сделать, так это изменить тип возвращаемого значения get_record, чтобы он возвращал интеллектуальный указатель. Если key действителен, он возвращает на него указатель наблюдателя. В противном случае он возвращает интеллектуальный указатель владельца на только что созданный объект:

#include <memory>
#include <iostream>

struct record { int n; } some_record{42};

std::shared_ptr<record> get_record(bool b)
{
    if (b == true) {
        return std::shared_ptr<record>{&some_record, [](record*){}}; // see explanation ^1
    }
    return std::shared_ptr<record>{new record{0}};
}

int main()
{
    std::cout << get_record(true)->n << "\n";  // this is some_record
    std::cout << get_record(false)->n << "\n"; // this is a temporary
}

¹⁾ О [](record*){}: эта лямбда-выражение без операций передается в качестве второго аргумента std::shared_ptr::shared_ptr() вызывается при уничтожении интеллектуального указателя. Он заменяет средство удаления по умолчанию std::shared_ptr, поведение которого заключается в вызове delete для принадлежащего указателя.

О том, почему ваш дизайн несовершенен. На самом деле, если get_record возвращает ссылку, это делает ее несогласованной. Что вы хотите:

• если key действителен, верните ссылку на существующий/постоянный объект и
• в противном случае вернуть временный объект.

Эти два понятия взаимоисключающие, и ваша функция не имеет смысла: что семантически возвращает get_record?

Верно ли, что возвращать ссылку на локальную переменную не очень хорошая идея?

да. Локальный объект будет уничтожен при выходе из функции, поэтому возвращаемая ссылка всегда висит.

Вы можете сделать x переменной static.

record& get_record(int key) {
    if (valid(key))
        return lookup(key);
    else {
        static record x;
        x.valid=false;
        return x;
    }
}

Обратите внимание, что возвращаемая ссылка всегда будет относиться к одному и тому же объекту, то есть x.

Если вам разрешено изменять функцию get_record, вы можете изменить тип возвращаемого значения на указатель на запись вместо ссылки на запись.

record* get_record( int key )
{
    if( valid( key ) ) return &lookup( key ); 
    else               return nullptr;
 }

Однако этот подход требует двух гарантий:

• функция lookup должна возвращать ссылку на запись
• запись, возвращаемая поиском, должна оставаться активной, когда поиск возвращает результат (например, запись является элементом какого-то контейнера, а поиск возвращает свою ссылку)

Поскольку другие уже подробно объясняют, почему возвращать ссылку на локальный объект плохо, я просто предоставлю альтернативу: исключения. Хотя вы могли бы написать пользовательское исключение, вероятно, исключение std::out_of_range могло бы оказаться уместным. (поскольку ключ находится вне диапазона допустимых ключей, что и является std::map::at делает).

Взгляните на: Как создать исключение C++

record& get_record(int key)
{
  if (valid(key))
  {
    return lookup(key);
  } else {
    throw std::out_of_range("The provided key is invalid");
  }
}

Теперь вам, очевидно, придется перехватывать исключение в коде, вызывающем get_record, иначе ваша программа все равно завершится.

Возврат ссылки сам по себе не приводит к неопределенному поведению, но если вы попытаетесь изменить его, вы это сделаете.

Доступ к объекту за пределами его времени жизни является неопределенным поведением.

int* foo(void) {
    int a = 17; // a has automatic storage duration
    return &a;
}  // lifetime of a ends
int main(void) {
    int* p = foo(); // p points to an object past lifetime ("dangling pointer")
    int n = *p; // undefined behavior
}

http://en.cppreference.com/w/c/language/lifetime

Если у вас есть доступ к C++17, вы можете реализовать его с помощью std::Optional< /а>. Обратите внимание на использование std::reference_wrapper, поскольку использование ссылки in std::optional делает вашу программу неправильной.

std::optional<std::reference_wrapper<record>> get_record(int key) {
    if (valid(key))
        return std::optional<std::reference_wrapper<record>>(lookup(key));
    else
        return std::nullopt;
}

Без С++ 17 вы могли бы просто вернуть указатель на свою запись:

record* get_record(int key) {
    if (valid(key))
        return &lookup(key);
    else
        return nullptr;
}

Или, если вы предпочитаете, вы можете сохранить возвращаемый тип ссылки и создать исключение, указывающее на отсутствующую запись. Хотя это мой наименее предпочтительный подход, так как он позволяет легко вызывать get_record без переноса в try / catch.

record& get_record(int key) {
    if (valid(key))
        return &lookup(key);
    else
        throw std::out_of_range("Invalid record key!");
}