Zarządzanie pamięcią i zasobami w C++

Korzystaj z właściwych wskaźników i unikaj wycieków pamięci

Jedyny tak kompleksowy kurs zarządzania pamięcią i zasobami w nowoczesnym C++ po polsku

Będziemy pisać taki kod:

  /*
 * RAII wrapper for raw pointers to FILE
 * Remember to implement Rule of 5
 */
class FileHandler {
    FILE* fp_;
public:
    FileHandler(std::string filename)
        : fp_ { std::fopen(filename.c_str(), "r") }
    {
        if (!fp_) {
            throw FileOpeningError{filename};
        }
    }

    FileHandler(const char* filename)
        : fp_ { std::fopen(filename, "r") }
    {
        if (!fp_) {
            throw FileOpeningError{filename};
        }
    }

    ~FileHandler() {
        std::fclose(fp_);
    }

    friend std::ostream& operator<<(std::ostream& os, const FileHandler& fh);
};

   #include <iostream>
 #include <memory>
 #include <string>
 
 class Parent {
 public:
     Parent() { std::cout << "PARENT C'tor called\n"; }
     virtual ~Parent() { std::cout << "PARENT D'tor called\n"; }
 };
 
 class Child : public Parent {
 public:
     Child() { std::cout << "CHILD C'tor called\n"; }
     ~Child() override { std::cout << "CHILD D'tor called\n"; }
 };
 
 int main() {
     Child child;    // ok, object on stack, not a pointer
     std::cout << '\n';
     std::unique_ptr<Parent> child2 = std::make_unique<Child>();
     std::cout << '\n';
     std::shared_ptr<Parent> child3 = std::make_shared<Child>();
     std::cout << '\n';
     Parent* ptr = new Child{};
     delete ptr;
     std::cout << '\n';
 }

  #include <memory>
#include <iostream>

class Gadget {};

void f(const Gadget&) { std::cout << "const Gadget&\n"; }
void f(Gadget&)       { std::cout << "Gadget&\n"; }
void f(Gadget&&)      { std::cout << "Gadget&&\n"; }

template <typename T>
void use(T&& t) {
    f(std::forward<T>(t));
}

int main() {
    const Gadget cg;
    Gadget g;
    use(cg);       // calls use(const Gadget&) then calls f(const Gadget&)
    use(g);        // calls use(Gadget&) then calls f(Gadget&)
    use(Gadget{}); // calls use(Gadget&&) then calls f(Gadget&&)
}

Co znajdziesz
wewnątrz
kursu?

Wyjątki

Na czym polegają sytuacje wyjątkowe w C++ i jak sobie z nimi radzić?

Problemy z pamięcią

Jakich problemów z pamięcią możemy się spodziewać i jak je wykrywać?

Dobre praktyki

Klucz do dobrego programowania w C++

Pamięć procesu

Jak działają programy, skąd bierze się w nich pamięć i jak jest podzielona?

Wskaźniki inteligentne

Dlaczego są takie inteligentne i jak z nich korzystać?

Semantyka przenoszenia

Trochę więdzy eksperckiej, aby zwalić rekruterów z nóg

Poprzedni

Następny

75 lekcji wideo

Krótkie kilkuminutowe lekcje pozwolą Ci skubnąć trochę wiedzy w każdej wolnej chwili 🚽

Zadania i mini projekty

Dzięki nim w praktyce przećwiczysz poznaną teorię

Narzędzia

Poznasz najważniejsze narzędzia, które ułatwią Ci pracę

Automatyczne sprawdzanie zadań

Błyskawicznie dowiesz się, czy Twoje rozwiązania przechodzą nasze testy. Zawsze też możesz porozmawiać o nich na czacie

Społeczność

Na Discordzie porozmawiasz z innymi kursantami. Możesz wymieniać się doświadczeniem oraz rozwiązaniami zadań. Pytaj o wszystko co związane z C++

Aktualizacje

Na bieżąco czuwamy nad materiałami. Jeśli coś się zmieni lub nagramy nowe wideo to dostaniesz je gratis

Dożywotni dostęp

Możesz powrócić do szkolenia nawet za kilka lat

Gwarancja satysfakcji

W ciągu 14 dni możesz zwrócić kurs z dowolnego powodu, np. aberracji stratosferycznych nad biegunem południowym 😉 Możesz też nie podawać powodu w ogóle

Lekcje demo

Zarządzanie pamięcią i zasobami w C++

7 Videos

Wskaźniki - tworzenie shared_ptr

3:01

Semantyka przenoszenia — std::move

4:39

Semantyka przenoszenia — copy elision

7:47

Ile materiału wideo znajdziesz w kursie Zarządzanie pamięcią i zasobami w C++?

Moduł

Ilość lekcji wideo

Czas trwania materiałów
[H:MM:SS]

Wyjątki