Troy ereje

Az auto kulcsszó C++-ban

A C++-ban az auto egy hatékony eszköz, amelyet a C++11 vezetett be: kikövetkeztetett adattípusú változók deklarálására szolgál. A fordító a változó típusát a kezdőértékéből következteti ki, amitől a kód olvashatóbbá és könnyebben karbantarthatóvá válik.

Példa a használatra

Nézzük a következő példát, amelyben az auto-val változókat deklarálunk:

auto dragon_population{3};          // dragon_population is deduced as an integer
auto westeros{7.7777};              // westeros is deduced as a double
auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string

Mindegyik esetben a változó típusát abból az értékből következteti ki a fordító, amellyel inicializáltuk.

Típuskövetkeztetés

Az auto kulcsszó segít tömörebb és olvashatóbb kódot írni, mert csökkenti a kifejezett típusok bőbeszédűségét.

const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
auto purple_wedding_pie{pigeon_pie};
purple_wedding_pie.emplace_back("the strangler");

Ebben a ciklusban az auto a purple_wedding_pie típusát std::vector<std::string>-ként következteti ki, így nem kell újra kifejezetten megadni a típust.

Kompatibilitás

Az auto kulcsszó számos C++ szerkezettel működik együtt, ami sokoldalú eszközzé teszi a modern C++ programozásban.

auto& element{array[0]};           // reference to an element
const auto object{otherObject};    // const type version of otherObject's type
auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.

A későbbi fogalmakban gyakran találkozunk majd az auto kulcsszóval lambda-kifejezésekkel, tartományalapú for-ciklusokkal és iterátorokkal.

Okos mutatók

Az okos mutatók modern C++-funkció, amely automatikus memóriakezelést nyújt, segítve a nyers mutatókhoz gyakran társított memóriaszivárgások és lógó mutatók megelőzését. Burkot képeznek a nyers mutatók körül, további funkciókat adva hozzájuk, például automatikusan felszabadítják a memóriát, amikor a mutatóra már nincs szükség.

Általános szintaxis

Az okos mutatókat általában osztálysablonként valósítják meg a C++ szabványos könyvtárában. A két leggyakrabban használt okos mutató a std::unique_ptr és a std::shared_ptr.

Egyedi mutatók

A std::unique_ptr olyan okos mutató, amely kizárólagosan birtokolja az objektumot. Biztosítja, hogy egy adott pillanatban csak egy std::unique_ptr objektum birtokolja az erőforrást. Amikor a birtokló std::unique_ptr megsemmisül vagy visszaáll, automatikusan megsemmisíti az objektumokat és felszabadítja a memóriájukat.

#include <memory>
// Declaring and defining a unique pointer
auto rightful_king_of_england = std::make_unique<std::string>("Excalibur");

// Unique pointers cannot be copied or assigned
auto mordred = rightful_king_of_england; // Error: Cannot copy a unique_ptr

A std::make_unique() előnyei

Amikor std::unique_ptr-t hozunk létre, érdemesebb a std::make_unique()-ot használni, ahelyett hogy közvetlenül a new-val foglalnánk memóriát. A std::make_unique() számos előnnyel jár:

1. Kivételbiztonság: A std::make_unique() garantálja a kivételbiztonságot. Ha kivétel keletkezik az objektum létrehozása közben, a memória automatikusan felszabadul, megelőzve a memóriaszivárgást.
2. Átláthatóság: A std::make_unique() használata világosabbá és tömörebbé teszi a kódot. Nem kell kifejezetten megadni a lefoglalandó típust, mert a sablonargumentumok automatikusan kikövetkeztethetők.
3. Optimalizálási lehetőségek: A fordítóknak lehetőségük van hatékonyabban optimalizálni a std::make_unique()-ot, mint a new-val kézzel foglalt memóriát, ami jobb teljesítményt eredményezhet.
4. A helytelen használat elkerülése: Lehetőség van az alapul szolgáló erőforrás törlésére, ha a std::unique_ptr-t kézzel hozzuk létre. Ez nem definiált viselkedéshez vezet, amikor a std::unique_ptr a scope végén megpróbálja törölni.

Megosztott mutatók

A std::shared_ptr olyan okos mutató, amely lehetővé teszi, hogy több std::shared_ptr objektum megossza ugyanazon erőforrás tulajdonjogát. Számon tartja, hogy hány megosztott mutató hivatkozik az erőforrásra, és csak akkor szabadítja fel a memóriát, amikor az erőforrást birtokló utolsó megosztott mutató kikerül a scope-ból vagy visszaáll.

// Declaring and defining a shared pointer to a dynamically allocated string
auto martian_congressional_republic = std::make_shared<std::string>("protomolecule");

// Creating more shared pointer that shares ownership
auto outer_planets_alliance = martian_congressional_republic;
auto united_nations = martian_congressional_republic;

A std::make_shared() előnyei

A std::make_unique()-hoz hasonlóan a std::make_shared() is olyan előnyöket kínál, mint a jobb memóriahatékonyság, a kivételbiztonság és az olvashatóság. A vezérlőblokk és a kezelt objektum memóriafoglalását egyetlen műveletbe vonja össze, ami növeli a hatékonyságot és csökkenti a memóriaszivárgás kockázatát. Ráadásul a sablonargumentumok automatikus kikövetkeztetése egyszerűbbé teszi a kódot és javítja az olvashatóságát. A std::make_shared() használata tisztább, biztonságosabb és hatékonyabb kódot eredményez, amikor C++-ban std::shared_ptr objektumokkal dolgozunk.

Használati tanácsok

Alapértelmezés szerint használj okos mutatókat: std::unique_ptr-t a kizárólagos tulajdonjoghoz és std::shared_ptr-t a megosztott tulajdonjoghoz. A nyers mutatókat a nem birtokló hivatkozásokhoz, illetve a régi kóddal való kapcsolódáshoz tartsd fenn. A legtöbb esetben a std::unique_ptr elegendő a kizárólagos tulajdonjoghoz, mert könnyűsúlyú memóriakezelést kínál a referenciaszámlálás többletterhe nélkül. A std::shared_ptr-t takarékosan érdemes használni, mert többletterhet és bonyolultságot hoz, hacsak nem valódi megosztott tulajdonjogra van szükség.