make_unique и идеальная пересылка

Почему std::make_uniqueв стандартной библиотеке C ++ 11 нет шаблона функции? я нахожу

std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3));

немного многословно Разве следующее не будет намного лучше?

auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3);

Это newхорошо скрывает и упоминает тип только один раз.

Во всяком случае, вот моя попытка реализации make_unique:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

Мне потребовалось много времени, чтобы собрать std::forwardматериал для компиляции, но я не уверен, что это правильно. Это? Что именно std::forward<Args>(args)...значит? Что компилятор делает из этого?

Херб Саттер, председатель комитета по стандартизации C ++, пишет в своем блоге :

То, что C ++ 11 не включает make_unique, отчасти является упущением и почти наверняка будет добавлено в будущем.

Он также дает реализацию, которая идентична реализации, данной ОП.

Изменить: std::make_unique теперь является частью C ++ 14 .

Хорошо, но у Стефана Т. Лававея (более известного как STL) есть лучшее решение для make_unique, которое работает правильно для версии массива.

#include <memory>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::false_type, Args&&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique_helper(std::true_type, Args&&... args) {
   static_assert(std::extent<T>::value == 0,
       "make_unique<T[N]>() is forbidden, please use make_unique<T[]>().");

   typedef typename std::remove_extent<T>::type U;
   return std::unique_ptr<T>(new U[sizeof...(Args)]{std::forward<Args>(args)...});
}

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
   return make_unique_helper<T>(std::is_array<T>(), std::forward<Args>(args)...);
}

Это можно увидеть на его видео Core C ++ 6 .

Обновленная версия STL make_unique теперь доступна как N3656 . Эта версия была принята в проект C ++ 14.

std::make_sharedне просто стенография для std::shared_ptr<Type> ptr(new Type(...));. Он делает то, что вы не можете сделать без него.

Чтобы выполнить свою работу, std::shared_ptrнеобходимо выделить блок отслеживания в дополнение к удержанию хранилища для фактического указателя. Однако, поскольку std::make_sharedвыделяет фактический объект, возможно, что std::make_sharedи объект, и блок отслеживания выделяются в одном и том же блоке памяти.

Таким образом, в то время как std::shared_ptr<Type> ptr = new Type(...);было бы два выделения памяти (один для new, один в std::shared_ptrблоке отслеживания), std::make_shared<Type>(...)выделил бы один блок памяти.

Это важно для многих потенциальных пользователей std::shared_ptr. Единственное, что std::make_uniqueможно сделать, это быть немного более удобным. Не более того.

Хотя ничто не мешает вам написать свой собственный помощник, я полагаю, что основная причина предоставления make_shared<T>в библиотеке заключается в том, что она на самом деле создает общий внутренний тип общего указателя, чем тот shared_ptr<T>(new T), который назначается по-другому, и нет способа достичь этого без выделенного помощник.

С make_uniqueдругой стороны, ваша обертка - это просто синтаксический сахар вокруг newвыражения, поэтому, хотя это может показаться приятным для глаз, оно ничего не приносит newна стол. Исправление: на самом деле это не так: вызов функции для переноса newвыражения обеспечивает безопасность исключений, например, в случае, когда вы вызываете функцию void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Наличие двух необработанных news, которые не упорядочены по отношению друг к другу, означает, что если одно новое выражение завершится неудачно с исключением, другое может привести к утечке ресурсов. Что касается того, почему нет make_uniqueв стандарте: это было просто забыто. (Это иногда случается. Там также нет глобальныхstd::cbegin значений, хотя они и должны быть.)

Также обратите внимание, что unique_ptrпринимает второй параметр шаблона, который вы должны как-то учесть; это отличается от того shared_ptr, что использует стирание типа для хранения пользовательских удалителей, не делая их частью типа.

В C ++ 11 ...(в коде шаблона) тоже используется для «расширения пакета».

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

Например, опираясь на ваш пример:

std::forward<Args>(args)... -> std::forward<int>(1), std::forward<int>(2),
                                                     std::forward<int>(3)

std::forward<Args...>(args...) -> std::forward<int, int, int>(1,2,3)

Последнее неверно, я думаю.

Кроме того, пакет аргументов не может быть передан функции без расширения. Я не уверен насчет пакета параметров шаблона.

Вдохновленный реализацией Stephan T. Lavavej, я подумал, что было бы неплохо иметь make_unique, который поддерживает экстенты массива, он на github, и я хотел бы получить комментарии к нему. Это позволяет вам сделать это:

// create unique_ptr to an array of 100 integers
auto a = make_unique<int[100]>();

// create a unique_ptr to an array of 100 integers and
// set the first three elements to 1,2,3
auto b = make_unique<int[100]>(1,2,3);