Собеседования по С++ для джуна

template<
    class T,
    class Deleter = std::default_delete<T>
> class unique_ptr;

unique_ptr( pointer p, Deleter d1 );

#include <iostream>
#include <memory>
 
struct Foo { int x; };
 
// пишем специализацию, потому что make_unique работает только с дефолтным делитером
// можно было написать свой класс и передавать в конструктор, указанный выше
namespace std
{
template<>
struct default_delete<Foo> {
    void operator()(Foo * ptr)
    {
        std::cout << "D is deleting a Foo\n";
        delete ptr;
    }
};
}
 
int main()
{
    auto p = std::make_unique<Foo>();
    std::cout << sizeof(p) << '\n';
    std::cout << sizeof(void*) << '\n';
}

typedef std::tuple<typename _Pointer::type, _Dp>  __tuple_type;
 __tuple_type                                      _M_t;

template<std::size_t _Idx, typename _Head, bool _IsEmpty>
  struct _Head_base;
 
template<std::size_t _Idx, typename _Head>
  struct _Head_base<_Idx, _Head, true>
  : public _Head
  {
    constexpr _Head_base()
    : _Head() { }
 
    constexpr _Head_base(const _Head& __h)
    : _Head(__h) { }
 
    template<typename _UHead>
      _Head_base(_UHead&& __h)
  : _Head(std::forward<_UHead>(__h)) { }
 
    _Head&       _M_head()       { return *this; }
    const _Head& _M_head() const { return *this; }
  
    void 
    _M_swap_impl(_Head& __h)
    {
  using std::swap;
  swap(__h, _M_head());
    }
  };
 
template<std::size_t _Idx, typename _Head>
  struct _Head_base<_Idx, _Head, false>
  {
    constexpr _Head_base()
    : _M_head_impl() { }
 
    constexpr _Head_base(const _Head& __h)
    : _M_head_impl(__h) { }
 
    template<typename _UHead>
      _Head_base(_UHead&& __h)
  : _M_head_impl(std::forward<_UHead>(__h)) { }
 
    _Head&       _M_head()       { return _M_head_impl; }
    const _Head& _M_head() const { return _M_head_impl; }        
 
    void
    _M_swap_impl(_Head& __h)
    { 
  using std::swap;
  swap(__h, _M_head());
    }
 
    _Head _M_head_impl; 
  };

#include <iostream>
 
 
struct base
{
    size_t getSize()const { return sizeof(*this); }
};
 
struct der: base
{
    size_t getSize()const { return sizeof(*this); }
    size_t getBaseSize()const { return base::getSize(); }
    
    int a;
    
};
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    std::cout << "size of base: " << base().getSize() <<std::endl;
    std::cout << "size of der: " << der().getSize() <<std::endl;
    
    std::cout << "size of der::base " << der().getBaseSize() <<std::endl;
    
}

struct base{};
struct der: base{ int a; };