Russian Qt Forum

• Терминология: pointer -> object token.
• Все токены по умолчанию single, а не optional.
• Удалён safe::weak_single.
• Добавлен slim::unique (обёртка над std::unique_ptr).
• Добавлены raw::weak, raw::unified (обёртки над голым указателем).
• Функции для унифицированного доступа к токенам.
• Traits.
• Что-то ещё :).

C++ (Qt)
struct A {
 ...
 B * data;
 ...
};  

C++ (Qt)
void Bar::setResource( MyResource *res )
{
  m_res = res;
  connect( m_res, QObject::destroyed, [&]( QObject * ){ m_res = nullptr; } );
}
 

C++ (Qt)
if( (auto p = unique_ptr.get()) )
{
  p->do();
  p->bar();
}
 

C++ (Qt)
if( (auto p = unique_ptr.get()) )
{
  p->do();
  p->bar();
}
 
xrenEgoZnaet();
 
// Проверяем повторно
if( (auto p = unique_ptr.get()) )
{
  p->foo();
  p->bla();
}
 

C++ (Qt)
struct Owner
{
    Resource m_resource;
};
 

C++ (Qt)
struct User
{
    Resource & m_resource;
};
 

C++ (Qt)
struct User
{
    ::std::reference_wrapper< Resource > m_resource;
};
 

C++ (Qt)
struct Owner
{
    Resource * m_resource = nullptr;
 
    Owner () : m_resource( new Resource ) {}
    ~Owner () { delete m_resource; }
    Owner ( Owner && other ) { ::std::swap( m_resource, other.m_resource ); }
    Owner ( const Owner & other ) : m_resource( new Resource( *other.m_resource ) ) {}
};
 

C++ (Qt)
struct User
{
    Resource * m_resource;
    User ( Resource & resource ) : m_resource( ::std::addressof( resource ) );
};
 

C++ (Qt)
struct Owner
{
    ::std::unique_ptr< Resource > m_resource;
 
    Owner () : m_resource( ::std::make_unique< Resource >() ) {}
    Owner ( const Owner & other ) : m_resource( ::std::make_unique< Resource >( *other.m_resource ) ) {}
};
 

C++ (Qt)
struct Owner
{
    ::std::shared_ptr< Resource > m_resource;
 
    Owner () : shared_ptr( ::std::make_shared< Resource >() ) {}
    Owner ( Owner && other ) { ::std::swap( m_resource, other.m_resource ); }
    Owner ( const Owner & other ) : m_resource( ::std::make_unique< Resource >( *other.m_resource ) ) {}
};
 

C++ (Qt)
struct User
{
    ::std::weak_ptr< Resource > m_resource;
    User ( ::std::shared_ptr< Resource > resource ) : m_resource( resource );
};
 

C++ (Qt)
static void doDeleteLater(MyObject *obj)
{
    obj->deleteLater();
}
 

C++ (Qt)
#include <memory>
#include <string>
#include <iostream>
 
using namespace std;
 
template <class T>
using heap_unique = unique_ptr<T>;
 
template <class T>
using inplace_unique = T;
 
template <class T>
using weak = T *;
 
using Resource = string;
 
int main()
{
    cout << "----- heap -----" << endl;
    heap_unique<Resource> heap_owner_1 = make_unique<Resource>("heap_resource_1");
    weak<Resource>        heap_weak{heap_owner_1.get()};
    cout << "heap_owner_1: " << *heap_owner_1 << endl;
    cout << "heap_weak   : " << *heap_weak << endl;
    cout << "moving..." << endl;
    heap_unique<Resource> heap_owner_2 = std::move(heap_owner_1);
    heap_owner_1 = make_unique<Resource>("heap_resource_2");
    cout << "heap_owner_1: " << *heap_owner_1 << endl;
    cout << "heap_owner_2: " << *heap_owner_2 << endl;
    cout << "heap_weak   : " << *heap_weak << endl;
    cout << endl;
 
    cout << "----- inplace -----" << endl;
    inplace_unique<Resource> inplace_owner_1 = "inplace_resource_1";
    weak<Resource> inplace_weak{&inplace_owner_1};
    cout << "inplace_owner_1: " << inplace_owner_1 << endl;
    cout << "inplace_weak   : " << *inplace_weak << endl;
    cout << "moving..." << endl;
    inplace_unique<Resource> inplace_owner_2 = std::move(inplace_owner_1);
    inplace_owner_1 = "inplace_resource_2";
    cout << "inplace_owner_1: " << inplace_owner_1 << endl;
    cout << "inplace_owner_2: " << inplace_owner_2 << endl;
    cout << "inplace_weak   : " << *inplace_weak << endl;
    cout << endl;
}

----- heap -----
heap_owner_1: heap_resource_1
heap_weak   : heap_resource_1
moving...
heap_owner_1: heap_resource_2
heap_owner_2: heap_resource_1
heap_weak   : heap_resource_1

----- inplace -----
inplace_owner_1: inplace_resource_1
inplace_weak   : inplace_resource_1
moving...
inplace_owner_1: inplace_resource_2
inplace_owner_2: inplace_resource_1
inplace_weak   : inplace_resource_2

gsl::not_null<std::unique_ptr<int>> i(new int(10));

auto j = std::move(i);
assert(i.get()); // ooops контракт нарушен, ведь i значится как NOT null, а там ноль. Как так??

C++ (Qt)
#include <otn/all.hpp>
#include <iostream>
 
int main()
{
    otn::unique<int> i(new int(10));
 
    auto j = std::move(i);
    std::cout << *i << std::endl;
}

C++ (Qt)
#include <memory>
#include <iostream>
 
int main()
{
    auto i = std::make_shared<int>(10);
    auto j = std::move(i);
    auto k = i;
    std::cout << *j << std::endl;
}

C++ (Qt)
    heap_unique<Resource> heap_owner_1 = make_unique<Resource>("heap_resource_1");
    weak<Resource>        heap_weak{heap_owner_1.get()};
    ...
    heap_unique<Resource> heap_owner_2 = std::move(heap_owner_1);

C++ (Qt)
template<class T>
T* adoptChild(std::unique_ptr<T> child) {
    child->setParent(this);
    return child.release();
}

C++ (Qt)
template<class T>	
void adoptChild(T *child);
 
template<class T>	
T* adoptChild(std::unique_ptr<T> child);

C++ (Qt)
#include <memory>
#include <iostream>
 
class Label
{
public:
    using Caption = std::unique_ptr<std::string>;
 
    Label() = default;
    explicit Label(Caption caption) noexcept
        : m_caption{std::move(caption)}
    {}
 
    Caption releaseCaption() noexcept
    { return std::move(m_caption); }
 
    void print() const
    {
        std::cout << "Caption: " << (m_caption ? *m_caption : "[none]")
                  << std::endl;
    }
 
private:
    Caption m_caption;
};
 
int main()
{
    Label label{std::make_unique<std::string>("Hello!")};
    label.print();
    label.releaseCaption();
    label.print();
}