Как сделать функцию, которая может возвращать статические или автоматические объекты хранения без копирования в C++?

Ответ 1

Я не очень понимаю назначение статического/автоматического материала. Если все, что вы пытаетесь сделать, это избегать повторных конструкций, когда аргумент использовался ранее, почему бы просто не иметь кеш вместо этого?

C& func_reg(const int i)
{
    static std::unordered_map<int, C> cache;
    auto it = cache.find(i);
    if (it == cache.end())
      it = cache.emplace(i, C(i));

    return it->second;
}

Не всегда нужен кеш? Отлично! Добавь это:

C func_reg_nocache(const int i)
{
    return C(i);
}

Если я неправильно понял, и вам действительно нужна эта вещь, когда передача is_static == true дает вам совершенно другой объект (is_static == true с 0 а не с i), тогда просто создайте новую функцию для этого; это делает что-то особенное.

C& func_reg()
{
    static C obj(0);
    return obj;
}

C func_reg(const int i)
{
    return C(i);
}

Ответ 2

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

C& func_reg_maybe_static(int i, void* buf)
{
    static C c(0);
    if(i == 0)
        return c;
    else
        return *new (buf) C(i);
}

using uninit_C = std::aligned_storage<sizeof(C), alignof(C)>;
uninit_C buf;
auto& c = func_reg_maybe_static(i, &buf);

Это требует ручного вызова деструктора далее по линии, если и только если деструктор имеет побочные эффекты. Еще один дубль будет

C& func_reg_maybe_static(int i, C& buf)
{
    static C c(0);
    if(i == 0)
        return c;
    else
    {
        buf.~C();
        return *new (&buf) C(i); // note below
    }
}

C buf;
auto& c = func_reg_maybe_static(i, buf);

Эта версия, очевидно, требует, чтобы C был конструируемым по умолчанию. Размещение new совершенно законно, но использование buf после вызова функции может или не может быть законным в зависимости от содержимого C Деструктор будет вызван при выходе из области видимости.

Ответ 3

То, что вы хотите, по сути, вариант:

std::variant<C, C*> func_reg_maybe_static(int i)
{
  static C static_obj{ 0 };
  if (i == 0) {
    return &static_obj;
  } else {
    return std::variant<C, C*>{ std::inplace_type_t<C>{}, i };
  }
}

Это имеет то преимущество, что не требует каких-либо дополнительных выделений памяти (по сравнению с подходом shared_ptr). Но это несколько неудобно использовать на стороне вызывающего абонента. Мы могли бы обойти это, написав класс-оболочку:

template <class C> class value_or_ptr
{
  std::variant<C, C*> object_;
public:
  explicit template <class... Params> value_or_ptr(Params&&... parameters)
    : object_(std::inplace_type_t<C>{}, std::forward<Params>(parameters)...)
  {}
  explicit value_or_ptr(C* object)
    : object_(object)
  {}
  // other constructors...

  C& operator*()
  {
    return object_.index() == 0 ? std::get<0>(object_) : *std::get<1>(object_);
  }

  // other accessors...
}

Если у вас нет компилятора С++ 17, то же самое можно сделать с объединениями, но реализация, конечно, будет более сложной. Исходная функция тогда становится:

value_or_ptr<C> func_reg_maybe_static(int i)
{
  static C static_obj{ 0 };
  if (i == 0) {
    return value_or_ptr{ &static_obj };
  } else {
    return value_or_ptr{ i };
  }
}

Контраст с перегрузками

Мы могли бы достичь аналогичных результатов с перегрузками функций:

C& func_reg()
{
  static C obj{ 0 };
  return obj;
}

C func_reg(const int i)
{
  return C{ i };
}

Преимущество этого в том, что он проще, но может потребовать, чтобы вызывающий сделал копию. Также требуется, чтобы вызывающая сторона знала, будет ли возвращен предварительно вычисленный объект (что нежелательно). При использовании варианта подхода вызывающая сторона может обрабатывать результаты единообразно. Вызывающий всегда возвращает объект с семантикой значения и ему не нужно знать, получит ли он предварительно вычисленный объект.