0Pricing
C++ Academy · Lekcja

unique_ptr — wyłączna własność

Wyrażaj semantykę jednego właściciela za pomocą unique_ptr i typów dostępnych wyłącznie przez przenoszenie

unique_ptr — wyłączna własność to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Inteligentny wskaźnik z jednym właścicielem

std::unique_ptr<T> jest właścicielem jednego obiektu na stercie. Po zniszczeniu unique_ptr usuwa ten obiekt. Nie można go kopiować — można go tylko przenosić.

Tworzenie unique_ptr

Należy używać std::make_unique (C++14) — jest bezpieczne w obecności wyjątków i zwięzłe.

#include <memory>
auto w = std::make_unique<Widget>();         // default-constructed
auto p = std::make_unique<Point>(3, 4);       // forwarded args

Używanie jak wskaźnika

unique_ptr obsługuje typowe operacje na wskaźnikach.

auto p = std::make_unique<Point>(3, 4);
std::cout << p->x;        // arrow access
std::cout << (*p).y;      // dereference
if (p) std::cout << "non-null";

Nie można kopiować — można przenosić

Kopiowanie oznaczałoby istnienie dwóch właścicieli — byłoby to sprzeczne z określeniem „unique”. Przeniesienie przekazuje własność.

std::unique_ptr<int> a = std::make_unique<int>(1);
std::unique_ptr<int> b = std::move(a);
// a is now empty, b owns the int

Przekazywanie do funkcji

Przez wartość (z użyciem std::move): przekazanie własności. Przez referencję: pożyczenie bez przejmowania własności.

void consume(std::unique_ptr<Widget> w);   // takes ownership
void inspect(const Widget& w);              // borrows

auto w = std::make_unique<Widget>();
consume(std::move(w));
// w is now empty
inspect(*w);                                // (after re-creating)

Zwracanie z funkcji

Funkcja, która alokuje obiekt i zwraca do niego własność, powinna zwracać std::unique_ptr.

std::unique_ptr<Widget> create() {
    return std::make_unique<Widget>();
}

Resetowanie i zwalnianie

reset() usuwa bieżący obiekt i opcjonalnie przejmuje własność nowego. release() zrzeka się własności i zwraca surowy wskaźnik.

auto p = std::make_unique<int>(10);
p.reset(new int(20));    // delete the old, own the new
int* raw = p.release();   // p is now empty
delete raw;               // caller must delete

get(): pożyczanie surowego wskaźnika

get() zwraca surowy wskaźnik bez przekazywania własności. Należy używać go do integracji niewymagającej przejmowania własności.

auto p = std::make_unique<int>(42);
legacy_api(p.get());      // p still owns it

unique_ptr dla tablic

W przypadku tablic należy używać unique_ptr<T[]>. Dostęp indeksowany odbywa się za pomocą []; przy niszczeniu wywoływane jest delete[].

auto arr = std::make_unique<int[]>(10);
arr[0] = 99;
std::cout << arr[0];

Niestandardowe funkcje usuwające

Należy dostarczyć niestandardową funkcję usuwającą jako parametr szablonu, gdy zasób nie jest pamięcią surową (na przykład uchwytem pliku lub zasobem systemu operacyjnego).

auto closer = [](FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<FILE, decltype(closer)> file(std::fopen("a.txt","r"), closer);

Wydajność

Przy domyślnej funkcji usuwającej unique_ptr ma taki sam rozmiar i szybkość działania jak surowy wskaźnik — nie powoduje dodatkowego narzutu.

Szybkie sprawdzenie

Dlaczego std::unique_ptr nie pozwala na kopiowanie?

Podsumowanie

std::unique_ptr to domyślny inteligentny wskaźnik: nie powoduje dodatkowego narzutu, zapewnia wyłączną własność i można go przenosić, ale nie kopiować. Do tworzenia należy preferować std::make_unique.

Często zadawane pytania

Czy lekcja „unique_ptr — wyłączna własność” jest bezpłatna?

Tak — pełny tekst „unique_ptr — wyłączna własność” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „unique_ptr — wyłączna własność”?

Wyrażaj semantykę jednego właściciela za pomocą unique_ptr i typów dostępnych wyłącznie przez przenoszenie Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „unique_ptr — wyłączna własność”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Dlaczego inteligentne wskaźniki zastępują surowe new i delete
  2. unique_ptr — wyłączna własność
  3. shared_ptr i weak_ptr — współdzielenie własności
  4. Własne deletery i funkcje make
← Powrót do C++ Academy