Vector::shrink_to_fit

#include <iostream>
#include <vector>
 
using namespace std;
 
int main()
{
    vector<int> one, two;
    for(int i = 0; i < 30; ++i) {
        one.push_back(1);
    }
 
    for(int i = 0; i < 30; ++i) {
        cout << one[i] << ' ';
    }
    cout << endl;
 
    for(int i = 0; i < 15; ++i) {
        two.push_back(2);
    }
 
    for(int i = 0; i < 15; ++i) {
        cout << two[i] << ' ';
    }
    cout << endl;
 
    one = two;
 
    one.shrink_to_fit();
 
    cout << one.size() <<' ' <<one.capacity() << endl;
}

template<typename T, T v>
struct integral_constant
{
   typedef T type;
   static const T value = v;
};
 
template<bool P, typename T = void>
struct enable_if
{
   typedef T type;
};
 
template<typename T>
struct enable_if<false, T>
{
};
 
template <typename T, typename NameGetter>
struct has_member_impl
{
    typedef char matched_return_type;
    typedef int unmatched_return_type;
    
    template <typename C>
    static matched_return_type f(typename NameGetter::template get<C>*);
    
    template <typename C>
    static unmatched_return_type f(...);
    
public:
    static const bool value = (sizeof(f<T>(0)) == sizeof(matched_return_type));
};
 
template <typename T, typename NameGetter>
struct has_member :
        integral_constant<bool, has_member_impl<T, NameGetter>::value>
{ };
 
template<typename T>
struct check_has_shrink_to_fit
{
   template<typename U,
      void (U::*)() = &U::shrink_to_fit>
   struct get {};
};
 
template<typename T>
struct has_shrink_to_fit : has_member<T, check_has_shrink_to_fit<T> >
{
};
 
template<typename Container>
void shrink_to_fit(Container& cnt, typename enable_if<has_shrink_to_fit<Container>::value>::type* = 0)
{
   cnt.shrink_to_fit();
}
 
template<typename Container>
void shrink_to_fit(Container& cnt, typename enable_if<!has_shrink_to_fit<Container>::value>::type* = 0)
{
   Container().swap(cnt);
}

int main()
{
   std::list<int> lst;
   shrink_to_fit(lst);
   std::vector<int> v;
   shrink_to_fit(v);
}

#include <type_traits>
 
template<typename...>
using void_t = void;
 
template<typename Container, class = void>
struct has_shrink_to_fit : public std::integral_constant<bool, false>
{
};
 
template<typename Container>
struct has_shrink_to_fit<Container, void_t<decltype(&Container::shrink_to_fit)>> :
public std::integral_constant<bool, true>
{
};
 
template<typename Container, class = void>
struct is_swapable : public std::integral_constant<bool, false>
{
};
 
template<typename Container>
struct is_swapable<Container, void_t<decltype(&Container::swap)>> :
public std::integral_constant<bool, true>
{
};
 
template<typename T>
void shrink_to_fit(T& value, typename std::enable_if<has_shrink_to_fit<T>::value>::type* = 0)
{
   value.shrink_to_fit();
}
 
template<typename T>
void shrink_to_fit(T& value, typename std::enable_if<!has_shrink_to_fit<T>::value && is_swapable<T>::value>::type* = 0)
{
   T().swap(value);
}

char* my_char = new char[100];
 
vector<char>vector_char;
vector_char.resize(100);
 
 
delete[] my_char;
vector_char.shrink_to_fit();

vector_char.resize(100);
 
vector_char.clear();
vector_char.shrink_to_fit();

while(true) {
  vector<int> v(10000);//память не утекает
}
while(true) {
  int* v=new int[10000];//память утекает
}