База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

`= default` — явни дефиниции на функции по подразбиране в C++

`= default` указва на компилатора да предостави стандартната дефиниция на допустима функция. Собствеността върху ресурси, PImpl и виртуалните деструктори показват кога това е полезно.

Версия: ISO C++23; implementation support may vary

Синтаксис

struct T {
    T() = default;
    T(const T&) = default;
    T(T&&) = default;
    T& operator=(const T&) = default;
    T& operator=(T&&) = default;
    ~T();
    bool operator==(const T&) const = default;
};
T::~T() = default;

В C++23 = default; е явна дефиниция по подразбиране, а не присвояване или етикет default: в switch. Използва се за специални член-функции (от C++11) и за допустими оператори за сравнение (от C++20), например bool operator==(const T&) const = default;. Записът не е приложим към произволна функция и не допуска аргументи по подразбиране. Поддръжката може да се различава според реализацията.

Функция с = default още в първата декларация е декларирана, но не е предоставена от потребителя (user-provided). По-късна дефиниция като T::~T() = default; е user-provided, което може да повлияе на тривиалността. Ако член или базов клас възпрепятства нужната операция, функцията по подразбиране може да бъде дефинирана като изтрита. Ако това стане при = default след първата декларация, програмата е некоректно формирана.

В const T& знакът & декларира референция към lvalue, а в T&& знакът && декларира референция към rvalue. Това са типични типове на параметри за копиране и преместване. = delete изрично забранява използването на функцията: ако изборът между претоварванията я посочи, извикването е некоректно. Това не е изразът delete, който служи за унищожаване на обект и освобождаване на паметта му. Тип, съдържащ std::future, може да премести дескриптора към споделеното състояние, но не може да го копира член по член.

При PImpl декларирай Impl в заглавния файл без дефиниция и съхранявай std::unique_ptr<Impl>. Средството за изтриване по подразбиране изисква пълен тип Impl, затова дефинирай деструктора извън класа след дефиницията на Impl. Декларираният от потребителя деструктор потиска неявното деклариране и на двете операции за преместване. Ако са нужни, декларирай ги и ги дефинирай на същото място с = default. Присвояването чрез преместване може да изтрие предишния Impl на целевия обект. std::unique_ptr не може да се копира, а списъкът за инициализация на конструктора инициализира члена, който притежава ресурса.

В полиморфен интерфейс за стратегия = 0 означава чисто виртуална функция. За разлика от него, virtual ~Strategy() = default; дефинира публичен виртуален деструктор, така че производен обект да бъде унищожен правилно чрез std::unique_ptr<Strategy>. Извикващият код подава стратегията чрез конструктора. Регистър на фабрики може да свързва имена с фабрики за стратегии, които вече са компилирани и свързани с програмата, без да зарежда динамични библиотеки.

Примери

#include <iostream>
#include <memory>
#include <stdexcept>
#include <utility>

struct Strategy {
    virtual ~Strategy() = default;
    virtual int apply(int value) const = 0;
};

struct Double final : Strategy {
    int apply(int value) const override { return 2 * value; }
};

class Task {
public:
    explicit Task(std::unique_ptr<Strategy> strategy);
    ~Task();
    Task(Task&&) noexcept;
    Task& operator=(Task&&) noexcept;
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    int run() const;

private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

struct Task::Impl {
    explicit Impl(std::unique_ptr<Strategy> s) : strategy(std::move(s)) {}
    std::unique_ptr<Strategy> strategy;
};

Task::Task(std::unique_ptr<Strategy> s)
    : impl_(std::make_unique<Impl>(std::move(s))) {}
Task::~Task() = default;
Task::Task(Task&&) noexcept = default;
Task& Task::operator=(Task&&) noexcept = default;

int Task::run() const {
    if (!impl_ || !impl_->strategy) {
        throw std::logic_error("no strategy");
    }
    return impl_->strategy->apply(21);
}

int main() {
    Task original(std::make_unique<Double>());
    Task owner(std::move(original));
    std::cout << owner.run() << '\n';
}

Резултат

42

`main` подава `Double`, а конструкторът за преместване по подразбиране прехвърля собствеността върху `Impl` от `original` към `owner`. Виртуалното извикване на `Double::apply(21)` дава `42`. Примерът не копира обекта и не извиква `run()` върху изходния обект след преместването.

Свързани уроци

  • C++ · Урок 45 · Напреднало · Версия: 3
  • C++ · Урок 57 · Напреднало · Версия: 3
  • C++ · Урок 59 · Напреднало · Версия: 3

Източници