Russian Qt Forum

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

C++ (Qt)
ItemObserverPointer item = ...;  //  как-то получили айтем
...
// теперь его надо удалить (напр юзер нажал Del)
// delete item;  // так нельзя
// а тогда как ???

C++ (Qt)
void DeleteItem( ItemObserverPointer & item )
{
 auto parent = item->parent();
 assert(parent);
 parent->remove(item);
 item.reset();
}
 

C++ (Qt)
    ItemUniquePointer take(ItemObserverPointer item)
    {
        ItemUniquePointer result;
        const auto pred = [item](const ItemUniquePointer &p) { return item.get() == p.get(); };
        const auto it = std::find_if(m_children.begin(), m_children.end(), pred);
        if (it != m_children.end()) {
            std::swap(result, *it);
            result->m_parent = nullptr;
            m_children.erase(it);
        }
        return result;
    }
 
void DeleteItem( ItemObserverPointer & item )
{
    (void)item->parent()->take(item);
}
 

C++ (Qt)
const auto pred = [item](const ItemUniquePointer &p) { return item.get() == p.get(); };
const auto it = std::find_if(m_children.begin(), m_children.end(), pred);
 

C++ (Qt)
void DeleteItem( ItemObserverPointer & item )
{
    (void)item->parent()->take(item);
}
 

C++ (Qt)
qDeleteAll(treeWidget->selectedItems());

C++ (Qt)
qDeleteAll(treeWidget->selectedItems());

C++ (Qt)
Engine * Car::ReplaceEngine( Engine * engine )
{
    QMutexLocker lock(&mMutex);
    Q_ASSERT(engine && engine->GetOwner() == 0);
    Engine * old = mEngine.take();
    old->SetOwner(0);
 
    mEngine.reset(engine);
    engine->SetOwner(this);
 
    return old;
}
...
void Monitor::SetEngine( Engine * engine )
{
    QMutexLocker lock(&Car::mMutex);
    if (engine == mEngine) return;
 
    if (mEngine)
        mEngine->RemMonitor(this);
 
    mEngine = engine;
 
    if (mEngine)
        mEngine->AddMonitor(this);
}

C++ (Qt)
SingleEngine Car::replaceEngine(SingleEngine engine)
{
    using std::swap;
    swap(m_engine, engine);
    return engine;
}
...
void Monitor::setEngine(const WeakEngine& engine)
{ m_engine = engine; }

C++ (Qt)
ItemObserverPointer item1 = ...;
ItemObserverPointer item2 = ...;
DeleteItem(item1);  // это удалит item1 и item2
DeleteItem(item2);  // а это вылет

C++ (Qt)
using Items = ::std::list< Item >;
using ItemForIndex = ::std:vector< Items::iterator >
 
Items m_items;
ItemForIndex m_item_for_index;
 

C++ (Qt)
    ItemPointer createChild(qsizetype row = -1)
    {
        insert(row == - 1 ? childCount() : row, std::make_unique<Derived>());
        return ItemPointer(m_children.back().get());
    }
 

C++ (Qt)
    ItemPointer createChild(qsizetype row = -1)
    {
        insert(row == - 1 ? childCount() : row, std::make_unique<Derived>());
        return child(row);
    }
 

C++ (Qt)
ItemPointer p = ...;  // получили валидный айтем
...
// тут может происходить что угодно, возможно айтем грохнут
---
if (!p.isNull()) {
 

C++ (Qt)
struct CIem {
 typedef std::weak_ptr<CItem>  TItemPtr;
 ...
 
private:
 TItemPtr m_parent;
 std::vector<std::shared_ptr<CItem>> m_children;
};
 

C++ (Qt)
struct CIem {
 typedef std::weak_ptr<CItem>  TItemPtr;
 ...
 
private:
 TItemPtr m_parent;
 std::vector<TItemPtr> m_children;
 
 typedef std::list<std::shared_ptr<CItem>> TList;
 TList m_list;
 TList::iterator m_iterator;
};
 

C++ (Qt)
// static
bool CItem::DeleteItem( TItemPtr itemPtr )
{
  auto item = itemPtr.lock();
  if (!item) return false;
  auto parent = item->parent().lock();
  if (parent) 
    parent->removeChild(item.get());
  else
   item->m_list.erase(m_iterator);
  return true;
}
 
CItem::~CItem( void )
{
  while (m_children.size())
    DeleteItem(m_children.front());
}

C++ (Qt)
struct CIem {
 typedef std::weak_ptr<CItem>  TItemPtr;
 ...
 
private:
 TItemPtr m_parent;
 std::vector<std::shared_ptr<CItem>> m_children;
 std::shared_ptr<CItem> m_self;    // not null for root
};
 

C++ (Qt)
#include <experimental/memory>
 
int main()
{
    using namespace std;
    using namespace std::experimental;
 
    auto u = make_unique<int>(42);
 
    int* p = u.get();
    unique_ptr<int> a{p}; // Compiled.
    delete p;             // Compiled.
 
    observer_ptr<int> o{u.get()};
    unique_ptr<int>   b{o}; // Not compiled.
    delete o;               // Not compiled.
}

C++ (Qt)
TreeItemRef item = treeView->Root().childAt(0);
 
item.SetName("test");     // синтаксис или "семантика" (?) ссылки 
if (CheckSomething(item))
 DeleteItem(item);
 
if (!item.IsNull())
 item.SetName("done");
 
if (item.Lock()) {
...
}
 

C++ (Qt)
if (item.Lock()) {
...
}
 

C++ (Qt)
// int index
treeView->RemoveChildAt(index);

C++ (Qt)
template<class T>
struct CItemRef {
...
// data
  std::shared_ptr<T> m_shared;
  std::weak_ptr<T> m_weak;
  T * m_raw; 
};
typedef CItemRef<TreeItem> TreeItemRef;
 

C++ (Qt)
template<class T>
struct CItemRef {
  CItemRef( std::shared_ptr<T> sh )  :
    m_weak(sh),
    m_raw(sh.get())
  {
  }
 
  T * data( void ) const
  {
    auto p = m_shared.get();  // locked?
    if (p) return p;
 
    if (m_raw)
      assert(!m_weak.expired());
 
    return m_raw;
  }
 
...
// data
  std::shared_ptr<T> m_shared;
  std::weak_ptr<T> m_weak;
  T * m_raw; 
};

C++ (Qt)
bool Lock( void )
{
  if (!m_shared.get()) 
   m_shared = m_weak.lock();
 
  return m_shared.get();
}

C++ (Qt)
struct CIem {
 ...
 
private:
 TreeItemRef m_parent;
 std::vector<std::shared_ptr<CItem>> m_children;
 std::shared_ptr<CItem> m_self;    // not null for root
};

C++ (Qt)
TreeItemRef item = treeView->Root().childAt(0);
 
item.SetName("test");
if (CheckSomething(item))
 DeleteItem(item);
 
if (!item.IsNull())
 item.SetName("done");
 
if (item.Lock()) {
...
}

C++ (Qt)
if (auto item_data = item.lock())
{
    item_data->doSomething();
    ...
}