vector<unique_ptr<T, D1>> c1;

process(c1); // ok

vector<unique_ptr<T, D2>> c2;

process(c2); // oops

vector<T*> c1;

process(c1); // ok

for(auto p:c1)
{
    deleter1(p);
}

vector<T*> c2;

process(c2); // ok

for(auto p:c2)
{
    deleter2(p);
}

KO>>Или надо было еще сказать, что иногда может понадобиться что-то более сложное чем default_deleter?

J>Если вдруг понадобилось "что-то более сложное", то, наверное, оно понадобилось бы и без умных указателей?

std::vector<ptr_type> c;

//.....

for (auto ptr:c)
{
  my_cool_custom_deleter(ptr);
}

KO>>>Или надо было еще сказать, что иногда может понадобиться что-то более сложное чем default_deleter?

J>>Если вдруг понадобилось "что-то более сложное", то, наверное, оно понадобилось бы и без умных указателей?

KO>std::vector<ptr_type> c;

KO>//.....

KO>for (auto ptr:c)
KO>{
KO>  my_cool_custom_deleter(ptr);
KO>}
KO>

auto my_cool_custom_deleter_functor = [](X* x) { my_cool_custom_deleter(x); }
std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;

NB>>template< typename Deleter >
NB>>struct foo {
NB>>   Deleter my_cool_custom_deleter;
NB>>   // как определить вектор мембером?

NB>>   void test ( ) {
NB>>      auto my_cool_custom_deleter_functor = ??;
NB>>      std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;
NB>>   }

NB>>};

new Child(new Parent(), FunctionMayThrowException());

auto c1 = new Child1(Root);
auto c2 = new Child2(c1);

auto c1 = new Child(Root.GetFirstChild(), new SomeParameter());

J>>auto my_cool_custom_deleter_functor = [](X* x) { my_cool_custom_deleter(x); }
J>>std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;
J>>

#include <iostream>
#include <memory>
#include <vector>


struct X{ int my_data; };

void my_cool_custom_deleter(X *x) { delete x; }
auto my_cool_custom_deleter_functor = [](X* x) { my_cool_custom_deleter(x); };
std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;

int main()
{
    std::cout << "size of unique_ptr with non def deleter = " << sizeof(std::unique_ptr<int, decltype(my_cool_custom_deleter_functor)>) << std::endl;

}

A lambda-expression shall not appear in an unevaluated operand (Clause 5).

int main() {
    auto lambda = [](){return 33;};
    decltype(lambda) lb;
    return lb();
}

lambda.cpp: In function ‘int main()’:
lambda.cpp:4:19: error: use of deleted function ‘main()::__lambda0::<lambda>()’
decltype(lambda) lb;
^
lambda.cpp:3:17: note: a lambda closure type has a deleted default constructor
auto lambda = [](){return 33;};
^

decltype(lambda) lb;

J>>>auto my_cool_custom_deleter_functor = [](X* x) { my_cool_custom_deleter(x); }
J>>>std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;
J>>>

J>struct X{ int my_data; };

J>void my_cool_custom_deleter(X *x) { delete x; }
J>auto my_cool_custom_deleter_functor = [](X* x) { my_cool_custom_deleter(x); };
J>std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;

template< typename Deleter >
struct foo {
   Deleter my_cool_custom_deleter;
   // как определить вектор мембером?

   void test ( ) {
      auto my_cool_custom_deleter_functor = ??;
      std::vector<std::unique_ptr<X, decltype(my_cool_custom_deleter_functor)>> c;
   }

};

NB>>>template< typename Deleter >
NB>>>struct foo {
NB>>>   Deleter my_cool_custom_deleter;
NB>>>   // как определить вектор мембером?
NB>

std::vector<std::unique_ptr<X, Deleter>> c;

auto x = make_unique<Foo>(1);
// vs
Foo x{1};