make_unique e encaminhamento perfeito

Por que não há std::make_uniquemodelo de função na biblioteca C ++ 11 padrão? eu acho

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

um pouco detalhado. O seguinte não seria muito melhor?

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

Isso oculta newbem e apenas menciona o tipo uma vez.

De qualquer forma, aqui está minha tentativa de implementação de 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)...));
}

Levei um bom tempo para std::forwardcompilar o material, mas não tenho certeza se está correto. É isso? O que exatamente std::forward<Args>(args)...significa? O que o compilador faz disso?

Herb Sutter, presidente do comitê de padronização C ++, escreve em seu blog :

O fato de o C ++ 11 não incluir make_uniqueé parcialmente um descuido, e certamente será adicionado no futuro.

Ele também fornece uma implementação idêntica à fornecida pelo OP.

Edit: std::make_unique agora faz parte do C ++ 14 .

Bom, mas Stephan T. Lavavej (mais conhecido como STL) tem uma solução melhor para make_unique, que funciona corretamente para a versão do array.

#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)...);
}

Isso pode ser visto em seu vídeo Core C ++ 6 .

Uma versão atualizada da versão do make_unique da STL está agora disponível como N3656 . Esta versão foi adotada no rascunho C ++ 14.

std::make_sharednão é apenas uma abreviação para std::shared_ptr<Type> ptr(new Type(...));. Faz algo que você não pode fazer sem ele.

Para fazer seu trabalho, é std::shared_ptrnecessário alocar um bloco de rastreamento, além de reter o armazenamento para o ponteiro real. No entanto, como std::make_sharedaloca o objeto real, é possível que std::make_sharedaloque o objeto e o bloco de rastreamento no mesmo bloco de memória.

Portanto, embora std::shared_ptr<Type> ptr = new Type(...);houvesse duas alocações de memória (uma para a new, uma no std::shared_ptrbloco de rastreamento), std::make_shared<Type>(...)alocaria um bloco de memória.

Isso é importante para muitos usuários em potencial de std::shared_ptr. A única coisa que um std::make_uniquefaria seria ser um pouco mais conveniente. Nada além disso.

Embora nada impeça você de escrever seu próprio ajudante, acredito que o principal motivo para fornecer make_shared<T>na biblioteca é que ele realmente cria um tipo interno de ponteiro compartilhado diferente do shared_ptr<T>(new T)que é alocado de maneira diferente, e não há como conseguir isso sem o dedicado ajudante.

Seu make_uniqueinvólucro, por outro lado, é mero açúcar sintático em torno de uma newexpressão; portanto, embora pareça agradável aos olhos, não traz nada newpara a mesa. Correção: isso não é verdade: ter uma chamada de função para quebrar a newexpressão fornece segurança de exceção, por exemplo, no caso em que você chama uma função void f(std::unique_ptr<A> &&, std::unique_ptr<B> &&). Ter dois news brutos que não são sequenciais um em relação ao outro significa que, se uma nova expressão falhar com uma exceção, a outra poderá vazar recursos. Quanto ao porquê não existe make_uniqueno padrão: foi apenas esquecido. (Isso acontece ocasionalmente. Também não há global std::cbeginno padrão, mesmo que deva haver um.)

Observe também que unique_ptrutiliza um segundo parâmetro de modelo que você deve permitir de alguma forma; é diferente de shared_ptr, que usa apagamento de tipo para armazenar deleters personalizados sem torná-los parte do tipo.

No C ++ 11 ...é usado (no código do modelo) também para "expansão de pacote".

O requisito é que você o utilize como sufixo de uma expressão que contenha um pacote de parâmetros não expandido, e ele simplesmente aplicará a expressão a cada um dos elementos do pacote.

Por exemplo, desenvolvendo seu exemplo:

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)

O último está incorreto, eu acho.

Além disso, o pacote de argumentos não pode ser passado para uma função não expandida. Não tenho certeza sobre um pacote de parâmetros de modelo.

Inspirado na implementação de Stephan T. Lavavej, achei que seria bom ter um make_unique que suporta extensões de matriz, está no github e eu gostaria de receber comentários sobre ele. Ele permite que você faça isso:

// 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);