Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

`= default` — jawna definicja domyślna funkcji w C++

`= default` zleca kompilatorowi wygenerowanie standardowej definicji dozwolonej funkcji. Własność zasobu, PImpl i destruktor wirtualny pokazują, kiedy warto użyć tego zapisu.

Wersja: ISO C++23; implementation support may vary

Składnia

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;

W C++23 zapis = default; oznacza jawną definicję domyślną, a nie przypisanie ani etykietę default: w switch. Można go użyć dla specjalnych funkcji składowych (od C++11) i dozwolonych operatorów porównania (od C++20), np. bool operator==(const T&) const = default;. Zwykłej funkcji nie można tak zdefiniować, a funkcja z = default nie może mieć argumentów domyślnych. Obsługa zależy od implementacji.

Funkcja z = default w pierwszej deklaracji jest zadeklarowana przez użytkownika, ale nie jest przez niego dostarczona (user-provided). Późniejsza definicja, np. T::~T() = default;, jest user-provided, co może wpłynąć na trywialność. Jeśli składowa lub klasa bazowa nie pozwala wykonać wymaganej operacji, funkcja domyślna może zostać zdefiniowana jako usunięta. Jeśli stanie się to przy późniejszym = default, program jest niepoprawny.

W const T& znak & oznacza referencję l-wartości, a w T&& znak && oznacza referencję r-wartości. To typowe parametry kopiowania i przenoszenia. = delete jawnie zabrania użycia funkcji: jeśli rozstrzyganie przeciążenia ją wybierze, wywołanie jest błędem. To nie wyrażenie delete, które służy do niszczenia obiektu i zwalniania pamięci. Typ zawierający std::future może przenosić uchwyt do stanu współdzielonego, ale nie może kopiować go składowa po składowej.

W PImpl zadeklaruj Impl bez definicji w nagłówku i przechowuj std::unique_ptr<Impl>. Domyślna funkcja usuwająca wymaga kompletnego Impl, więc zdefiniuj destruktor poza klasą, po definicji Impl. Destruktor zadeklarowany przez użytkownika wstrzymuje niejawne deklarowanie obu operacji przenoszenia; jeśli są potrzebne, zadeklaruj je i zdefiniuj przez = default również tam. Przypisanie przenoszące może usunąć poprzedni Impl obiektu docelowego. std::unique_ptr nie jest kopiowalny, a lista inicjalizacyjna konstruktora inicjalizuje składową będącą właścicielem.

W polimorficznym interfejsie strategii = 0 oznacza funkcję czysto wirtualną. Z kolei virtual ~Strategy() = default; definiuje publiczny destruktor wirtualny, który umożliwia poprawne niszczenie obiektu pochodnego przez std::unique_ptr<Strategy>. Kod wywołujący wstrzykuje strategię przez konstruktor. Rejestr fabryk może przypisywać nazwy fabrykom strategii już skompilowanych i połączonych z programem, bez dynamicznego ładowania bibliotek.

Przykłady

#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';
}

Wynik

42

`main` wstrzykuje `Double`, a domyślny konstruktor przenoszący przekazuje własność `Impl` z `original` do `owner`. Wywołanie wirtualne `Double::apply(21)` daje `42`. Przykład nie kopiuje obiektu ani nie wywołuje `run()` na obiekcie po przeniesieniu.

Powiązane lekcje

  • C++ · Lekcja 45 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 57 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 59 · Zaawansowany · Wersja: 3

Źródła