Современный C++ 5 крутых фишек

vector, string
Время: O(N)
Память: O(N) – для хранения копии
Может выбросить

исключение
Перемещение vector, string
Время: O(1)
Память: O(1)
Как правило, не бросает исключений
Некоторые типы могут только перемещаться
std::fstream, std::unique_ptr, std::future, std::thread

name;
vector employees;
};

Department ReadDepartment(istream& input) {
Department department;
Person p;

if (getline(input, department.name)) {
string line;
while (getline(input, line)) {
istringstream strm(line);
if (strm >> p.name && strm >> p.surname)
department.employees.push_back(p);
}
}
return department;
}

C++’03

Может приводить к копированию всего Department

Копирование сотрудников при изменерии размеров контейнера

name;
vector employees;
};

Department ReadDepartment(istream& input) {
Department department;
Person p;

if (getline(input, department.name)) {
string line;
while (getline(input, line)) {
istringstream strm(line);
if (strm >> p.name && strm >> p.surname)
department.employees.emplace_back(move(p));
}
}
return department;
}

C++’14

Элемент конструируется путем перемещения значения из p

перемещения значения от одного объекта
Возврат результата из функции
Передача аргумента в

функцию
Пример:
Объекты типа Handle, управляющие некоторыми ресурсами ОС

INVALID;
public:
Handle() = default;

explicit Handle(HANDLE handle = INVALID) :

m_handle(handle) {}

Handle(Handle&& x) : m_handle(x.m_handle) { x.m_handle = INVALID; }

Handle(const Handle&) = delete; // no copy construction

Handle& operator=(Handle&& x) {// move assignment
std::swap(m_handle, x.m_handle);
return *this;
}

Handle &operator=(const Handle&) = delete; // no copy assignment

CloseHandle(m_handle);
}
}

explicit operator bool() const {

return m_handle != INVALID; }
operator HANDLE() const { return m_handle; }

void Close() {
if (!CloseHandle(m_handle)) {
m_handle = INVALID;
throw std::runtime_error("Failed to close handle");
}
m_handle = INVALID;
}
};
} // namespace detail

using FileHandle = detail::Handle;

nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));

if (!fh)
throw runtime_error("Failed to open file");
return fh;
}

int main() {
auto f = SafeOpenFile(L"main.cpp");
DWORD fileSize = GetFileSize(f, nullptr);
if (fileSize != INVALID_FILE_SIZE)
cout << "File size: " << fileSize << "\n";
}

Пример использования

stl-контейнерами
Позволяет управлять массивом объектов в куче
Поддержка пользовательского deleter-а

R.I.P. auto_ptr

на структуру или класс с деталями реализации
Скрывает лишние зависимости из

заголовочного файла
Позволяет сократить время компиляции

m_data(data) {}
void Foo() { /* do something */ }

int m_data = 42;
};

OpaqueObj::OpaqueObj(int data)
: m_impl(new Impl(data)) {}

OpaqueObj::~OpaqueObj() { delete m_impl;}

void OpaqueObj::Foo() {
m_impl->Foo();
}

OpaqueObj.cpp

class OpaqueObj {
public:
OpaqueObj(int data);
~OpaqueObj();
 
void Foo();
private:
struct Impl;
Impl* m_impl;
};

OpaqueObj.h

Проблема – требуется реализовать или запретить конструктор копирования и оператор присваивания

m_data(data) {} 
void Foo() { /* do something */ }

int m_data = 42;
};
 
OpaqueObj::OpaqueObj(int data)
: m_impl(make_unique(data)){}

OpaqueObj::~OpaqueObj() = default;

void OpaqueObj::Foo() {
m_impl->Foo();
}

OpaqueObj.cpp

class OpaqueObj {
public:
OpaqueObj(int data);
~OpaqueObj();
 
void Foo();
private:
struct Impl;
unique_ptr m_impl;
};

OpaqueObj.h

Приятный бонус: OpaqueObj из коробки стал Move-only типом

value;
} Data;
 
Data* AllocateData();
void DoSomethingWithData(Data *data, int x);
void DeallocateData(Data* data);

(!p) {
cout

return false;
}
if (p->value == 42) {
DeallocateData(p);
return true;
}

DoSomethingWithData(p, CalculateX(p->value));
DeallocateData(p);
return false;
}

Код по-прежнему содержит проблему

argument");
return value + 1;
}

bool Foo() {
Data *p =

AllocateData();
if (!p) {
cout << "Failed to allocated data\n";
return false;
}
if (p->value == 42) {
DeallocateData(p);
return true;
}

DoSomethingWithData(p, CalculateX(p->value));
DeallocateData(p);
return false;
}

Если CalculateX выбросит исключение, DeallocateData вызван не будет

DeallocateData(data);
}
};
using DataPtr = std::unique_ptr;

DataPtr SafeAllocateData() {
if (DataPtr

p{AllocateData()})
return p;
throw std::runtime_error("Failed to allocate data");
}

Пользовательский deleter

cout

}
if (p->value == 42) {
DeallocateData(p);
return true;
}

DoSomethingWithData(p, CalculateX(p->value));
DeallocateData(p);
return false;
}

Было

if (p->value == 42)
return true;

DoSomethingWithData(p.get(), CalculateX(p->value));
} catch (std::exception const &e) {
cout << e.what() << "\n";
}
return false;
}

Стало

не только памятью
Накладные расходы
Память для хранения счетчиков
Thread-safe подсчет ссылок

удаления объекта
Пока объект жив, позволяет получить shared_ptr на него
Решает проблему

циклических ссылок и висячих указателей

Master

Slave

себя
shared_from_this()
weak_from_this () (C++ 17)
Нельзя вызывать shared_from_this() из конструктора и деструктора,

а также у объекта, не обернутого в shared_ptr
До C++ 17 грозило UB
В C++17 – исключение bad_weak_ptr
Применимость
Передача shared-ссылки на самого себя
Реализация идиомы weak this
Защита от преждевременного удаления при вызове внешнего кода

AddChild(const NodePtr& node) {
auto self = shared_from_this();

if (node == self || IsDescendantOf(node))
throw invalid_argument("Can't add self or ancestor");
 
if (m_children.emplace(node).second) {
if (auto oldParent = node->GetParent()) oldParent->m_children.erase(node);
node->m_parent = self;
}
}
NodePtr GetParent()const { return m_parent.lock(); }
bool IsDescendantOf(const NodePtr& node)const {
auto self = shared_from_this();
for (auto x = node->GetParent(); x; x = x->GetParent())
if (x == self) return true;
return false;
}
private:
weak_ptr m_parent;
unordered_set m_children;
};

= function;
void LoadImageAsync(string_view url, Callback callback);

struct ImageView
{

void ShowImageAtURL(string_view url) {
/* Загрузить изображение асинхронно и вызвать OnImageLoaded */
}
private:
void OnImageLoaded(string_view url, unique_ptr image);
};

???

Задача: асинхронная загрузка изображения в GUI-приложении

image)>;
void LoadImageAsync(string_view url, Callback callback);

struct ImageView
{
void ShowImageAtURL (string_view url)

{
LoadImageAsync(url, [this](auto url, auto img) {
OnImageLoaded(url, move(img));
});
}
private:
void OnImageLoaded(string_view url, unique_ptr image);
};

UB На момент вызова колбека ImageView может быть разрушен. Нельзя вызывать OnImageLoaded

return shared_ptr(new ImageView);
}
void ShowImageAtURL (string_view url) {

weak_ptr weakSelf = shared_from_this();
LoadImageAsync(url, [=](auto url, auto data) {
if (auto strongSelf = weakSelf.lock())
strongSelf->OnImageLoaded(url, move(data));
});
}
private:
ImageView() = default;
void OnImageLoaded(string_view url, unique_ptr image);
};

А если нельзя владеть ImageView через shared_ptr?

Pimpl

{
return shared_ptr(new ImageView);
}
void ShowImageAtURL (string_view url)

{
auto weakSelf = weak_from_this();
LoadImageAsync(url, [=](auto url, auto data) {
if (auto strongSelf = weakSelf.lock())
strongSelf->OnImageLoaded(url, move(data));
});
}
private:
ImageView() = default;
void OnImageLoaded(string_view url, unique_ptr image);
};

Create() {
return shared_ptr(new ImageView);
}
void ShowImageAtURL (string_view

url) {
using namespace std::placeholders;
LoadImageAsync(url, BindWeakPtr(&ImageView::OnImageLoaded,
shared_from_this(), _1, _2));
}
private:
ImageView() = default;
void OnImageLoaded(string_view url, unique_ptr image);
};

Или weak_from_this()

Bind weak ptr: https://goo.gl/5NquDA

альтернатива передаче по ссылке или указателю
Объекту нужен доступ к ресурсу,

но не нужны права владения
Lifetime объекта не превышает lifetime ресурса
Клиент может передать объекту ресурс вместе с правами владения
Накладные расходы
Обертка над shared_ptr с соответствующими затратами на копирование

UniversalPtr(nullptr_t) noexcept {}
 
template UniversalPtr(U& r);
 template

U> UniversalPtr(U* p);
  template UniversalPtr(std::unique_ptr&& p);
  template UniversalPtr(const std::shared_ptr& p) noexcept;
 
explicit operator bool()const noexcept;
T& operator*()const noexcept;
T* operator->()const noexcept;
T* get()const noexcept;
private:
static constexpr void NoDelete(T*) noexcept {} 
std::shared_ptr m_ptr;
};

Полный фрагмент кода тут: https://goo.gl/yFlql5