قدرت تروی

کلیدواژه‌ی auto در C++

در C++، کلیدواژه‌ی auto ویژگی قدرتمندی است که در C++11 معرفی شد و برای تعریف متغیرهایی با نوع داده‌ی استنتاج‌شده به کار می‌رود. کامپایلر نوع متغیر را بر اساس مقدار اولیه‌اش استنتاج می‌کند و این کار می‌تواند کد را خواناتر کند و نگهداری از آن را آسان‌تر سازد.

نمونه‌ی استفاده

به نمونه‌ی زیر توجه کنید که در آن از auto برای تعریف متغیرها استفاده شده است:

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

در هر مورد، نوع متغیر از مقداری که با آن مقداردهی اولیه شده است استنتاج می‌شود.

استنتاج نوع

کلیدواژه‌ی auto با کم کردن پرگویی نوع‌های صریح، به نوشتن کدی موجزتر و خواناتر کمک می‌کند.

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

در این حلقه، auto نوع purple_wedding_pie را std::vector<std::string> استنتاج می‌کند و نیازی به مشخص کردن دوباره‌ی صریح نوع از بین می‌رود.

سازگاری

کلیدواژه‌ی auto با ساختارهای مختلف C++ سازگار است و آن را به ابزاری همه‌کاره در برنامه‌نویسی مدرن C++ تبدیل می‌کند.

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.

در مفاهیم بعدی، کلیدواژه‌ی auto را اغلب همراه با عبارات لامبدا، حلقه‌های For مبتنی بر بازه و تکرارگرها خواهیم دید.

اشاره‌گرهای هوشمند

«اشاره‌گرهای هوشمند» ویژگی‌ای مدرن در C++ هستند که برای مدیریت خودکار حافظه طراحی شده‌اند و به جلوگیری از «نشت حافظه» و «اشاره‌گرهای آویزان»، که معمولاً با «اشاره‌گرهای خام» همراه‌اند، کمک می‌کنند. آن‌ها به‌عنوان پوششی دور اشاره‌گرهای خام عمل می‌کنند و قابلیت‌های بیشتری مانند آزادسازی خودکار حافظه را هنگامی که دیگر به اشاره‌گر نیازی نیست اضافه می‌کنند.

نحوه‌ی نگارش کلی

اشاره‌گرهای هوشمند معمولاً به‌صورت قالب‌های کلاس در کتابخانه‌ی استاندارد C++ پیاده‌سازی می‌شوند. دو اشاره‌گر هوشمند پرکاربرد std::unique_ptr و std::shared_ptr هستند.

اشاره‌گرهای یکتا

std::unique_ptr اشاره‌گری هوشمند است که مالکیت شیء را به‌صورت انحصاری در دست دارد. تضمین می‌کند که در هر لحظه، تنها یک شیء std::unique_ptr مالک منبع باشد. هنگامی که std::unique_ptr مالک نابود یا بازنشانی شود، به‌طور خودکار اشیاء را نابود و حافظه‌شان را آزاد می‌کند.

#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

مزایای std::make_unique()

هنگام ساخت std::unique_ptr، بهتر است به‌جای استفاده‌ی مستقیم از new برای تخصیص حافظه، از std::make_unique() استفاده کنید. std::make_unique() چندین مزیت دارد:

1. ایمنی در برابر استثنا: std::make_unique() ایمنی در برابر استثنا را تضمین می‌کند. اگر هنگام ساخت شیء استثنایی پرتاب شود، حافظه به‌طور خودکار آزاد می‌شود و از نشت حافظه جلوگیری می‌کند.
2. خوانایی: استفاده از std::make_unique() کد را روشن‌تر و موجزتر می‌کند. نیازی به مشخص کردن صریح نوع تخصیص‌یافته از بین می‌رود، چون آرگومان‌های قالب به‌طور خودکار استنتاج می‌شوند.
3. فرصت‌های بهینه‌سازی: کامپایلرها می‌توانند std::make_unique() را مؤثرتر از تخصیص دستی حافظه با new بهینه کنند و این احتمالاً به بهبود کارایی می‌انجامد.
4. پرهیز از استفاده‌ی نادرست: هنگامی که std::unique_ptr به‌صورت دستی ساخته شود، حذف منبع زیرین امکان‌پذیر است. این کار هنگامی که std::unique_ptr در پایان حوزه‌ی خود تلاش می‌کند آن را حذف کند، به رفتار تعریف‌نشده می‌انجامد.

اشاره‌گرهای اشتراکی

std::shared_ptr اشاره‌گری هوشمند است که به چندین شیء std::shared_ptr اجازه می‌دهد مالکیت یک منبع یکسان را به اشتراک بگذارند. تعداد اشاره‌گرهای اشتراکی‌ای را که به منبع ارجاع می‌دهند پیگیری می‌کند و حافظه را تنها زمانی آزاد می‌کند که آخرین اشاره‌گر اشتراکی مالک منبع از حوزه خارج شود یا بازنشانی گردد.

// 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;

مزایای std::make_shared()

مشابه std::make_unique()، تابع std::make_shared() مزایایی مانند کارایی بهتر حافظه، ایمنی در برابر استثنا و خوانایی ارائه می‌دهد. تخصیص حافظه برای بلوک کنترل و شیء مدیریت‌شده را در یک عملیات واحد ترکیب می‌کند و بدین‌ترتیب کارایی را افزایش و خطر نشت حافظه را کاهش می‌دهد. علاوه بر این، استنتاج خودکار آرگومان‌های قالب کد را ساده‌تر و خواناتر می‌کند. استفاده از std::make_shared() هنگام کار با اشیاء std::shared_ptr در C++ کدی پاکیزه‌تر، ایمن‌تر و کارآمدتر به‌دست می‌دهد.

توصیه‌ی استفاده

به‌طور پیش‌فرض از اشاره‌گرهای هوشمند استفاده کنید: std::unique_ptr برای مالکیت انحصاری و std::shared_ptr برای مالکیت اشتراکی. اشاره‌گرهای خام را برای ارجاع‌های بدون مالکیت یا هنگام تعامل با کد قدیمی نگه دارید. در بیشتر موارد، std::unique_ptr برای مالکیت انحصاری کافی است، زیرا مدیریت حافظه‌ی سبکی بدون هزینه‌ی اضافی شمارش ارجاع ارائه می‌دهد. از std::shared_ptr باید کم استفاده کرد، چون مگر آنکه مالکیت اشتراکی واقعی لازم باشد، هزینه‌ی اضافی و پیچیدگی به همراه می‌آورد.