M

MLOG

فارسی

اشاره‌گرهای هوشمند مدرن ++C (unique_ptr, shared_ptr, weak_ptr) را برای مدیریت حافظه قوی، جلوگیری از نشت حافظه و افزایش پایداری برنامه کاوش کنید. بهترین شیوه‌ها و مثال‌های عملی را بیاموزید.

ویژگی‌های مدرن ++C: تسلط بر اشاره‌گرهای هوشمند برای مدیریت بهینه حافظه

در ++C مدرن، اشاره‌گرهای هوشمند ابزارهای ضروری برای مدیریت ایمن و کارآمد حافظه هستند. آن‌ها فرآیند آزادسازی حافظه را خودکار می‌کنند و از نشت حافظه و اشاره‌گرهای سرگردان که از مشکلات رایج در برنامه‌نویسی سنتی ++C هستند، جلوگیری می‌کنند. این راهنمای جامع به بررسی انواع مختلف اشاره‌گرهای هوشمند موجود در ++C می‌پردازد و مثال‌های عملی برای استفاده مؤثر از آن‌ها ارائه می‌دهد.

درک نیاز به اشاره‌گرهای هوشمند

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

این مشکلات می‌توانند باعث از کار افتادن برنامه، رفتار غیرقابل پیش‌بینی و آسیب‌پذیری‌های امنیتی شوند. اشاره‌گرهای هوشمند با مدیریت خودکار طول عمر اشیاء تخصیص‌داده‌شده به صورت پویا و پایبندی به اصل Resource Acquisition Is Initialization (RAII)، راه‌حلی زیبا ارائه می‌دهند.

RAII و اشاره‌گرهای هوشمند: ترکیبی قدرتمند

مفهوم اصلی پشت اشاره‌گرهای هوشمند، RAII است که حکم می‌کند منابع باید در حین ساخت شیء به دست آیند و در حین تخریب شیء آزاد شوند. اشاره‌گرهای هوشمند کلاس‌هایی هستند که یک اشاره‌گر خام را در بر می‌گیرند و به طور خودکار شیء اشاره‌شده را هنگامی که اشاره‌گر هوشمند از محدوده خارج می‌شود، حذف می‌کنند. این امر تضمین می‌کند که حافظه همیشه، حتی در حضور استثناها، آزاد می‌شود.

انواع اشاره‌گرهای هوشمند در ++C

++C سه نوع اصلی از اشاره‌گرهای هوشمند را ارائه می‌دهد که هر کدام ویژگی‌ها و موارد استفاده منحصر به فرد خود را دارند:

std::unique_ptr: مالکیت انحصاری

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

مثال: استفاده از std::unique_ptr


#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "MyClass constructed with value: " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value_ << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    std::unique_ptr<MyClass> ptr(new MyClass(10)); // یک unique_ptr ایجاد کنید

    if (ptr) { // بررسی کنید که آیا اشاره‌گر معتبر است
        std::cout << "Value: " << ptr->getValue() << std::endl;
    }

    // وقتی ptr از محدوده خارج می‌شود، شیء MyClass به طور خودکار حذف می‌شود
    return 0;
}

ویژگی‌های کلیدی std::unique_ptr:

مثال: استفاده از std::move با std::unique_ptr


#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(42));
    std::unique_ptr<int> ptr2 = std::move(ptr1); // انتقال مالکیت به ptr2

    if (ptr1) {
        std::cout << "ptr1 is still valid" << std::endl; // این اجرا نخواهد شد
    } else {
        std::cout << "ptr1 is now null" << std::endl; // این اجرا خواهد شد
    }

    if (ptr2) {
        std::cout << "Value pointed to by ptr2: " << *ptr2 << std::endl; // خروجی: Value pointed to by ptr2: 42
    }

    return 0;
}

مثال: استفاده از حذف‌کننده‌های سفارشی با std::unique_ptr


#include <iostream>
#include <memory>

// حذف‌کننده سفارشی برای دستگیره‌های فایل
struct FileDeleter {
    void operator()(FILE* file) const {
        if (file) {
            fclose(file);
            std::cout << "File closed." << std::endl;
        }
    }
};

int main() {
    // باز کردن یک فایل
    FILE* file = fopen("example.txt", "w");
    if (!file) {
        std::cerr << "Error opening file." << std::endl;
        return 1;
    }

    // ایجاد یک unique_ptr با حذف‌کننده سفارشی
    std::unique_ptr<FILE, FileDeleter> filePtr(file);

    // نوشتن در فایل (اختیاری)
    fprintf(filePtr.get(), "Hello, world!\n");

    // وقتی filePtr از محدوده خارج می‌شود، فایل به طور خودکار بسته می‌شود
    return 0;
}

std::shared_ptr: مالکیت اشتراکی

std::shared_ptr مالکیت اشتراکی یک شیء تخصیص‌داده‌شده به صورت پویا را امکان‌پذیر می‌سازد. چندین نمونه shared_ptr می‌توانند به یک شیء واحد اشاره کنند و شیء تنها زمانی حذف می‌شود که آخرین shared_ptr اشاره‌کننده به آن از محدوده خارج شود. این کار از طریق شمارش مرجع (reference counting) انجام می‌شود، که در آن هر shared_ptr هنگام ایجاد یا کپی شدن، شمارنده را افزایش می‌دهد و هنگام تخریب، آن را کاهش می‌دهد.

مثال: استفاده از std::shared_ptr


#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1(new int(100));
    std::cout << "Reference count: " << ptr1.use_count() << std::endl; // خروجی: Reference count: 1

    std::shared_ptr<int> ptr2 = ptr1; // کپی کردن shared_ptr
    std::cout << "Reference count: " << ptr1.use_count() << std::endl; // خروجی: Reference count: 2
    std::cout << "Reference count: " << ptr2.use_count() << std::endl; // خروجی: Reference count: 2

    {
        std::shared_ptr<int> ptr3 = ptr1; // کپی کردن shared_ptr در یک محدوده
        std::cout << "Reference count: " << ptr1.use_count() << std::endl; // خروجی: Reference count: 3
    } // ptr3 از محدوده خارج می‌شود، شمارنده مرجع کاهش می‌یابد

    std::cout << "Reference count: " << ptr1.use_count() << std::endl; // خروجی: Reference count: 2

    ptr1.reset(); // آزادسازی مالکیت
    std::cout << "Reference count: " << ptr2.use_count() << std::endl; // خروجی: Reference count: 1

    ptr2.reset(); // آزادسازی مالکیت، شیء اکنون حذف می‌شود

    return 0;
}

ویژگی‌های کلیدی std::shared_ptr:

ملاحظات مهم برای std::shared_ptr:

std::weak_ptr: ناظر بدون مالکیت

std::weak_ptr یک مرجع بدون مالکیت به شیئی که توسط یک shared_ptr مدیریت می‌شود، فراهم می‌کند. این اشاره‌گر در مکانیسم شمارش مرجع شرکت نمی‌کند، به این معنی که از حذف شدن شیء زمانی که تمام نمونه‌های shared_ptr از محدوده خارج شده‌اند، جلوگیری نمی‌کند. weak_ptr برای مشاهده یک شیء بدون گرفتن مالکیت، به ویژه برای شکستن وابستگی‌های دایره‌ای، مفید است.

مثال: استفاده از std::weak_ptr برای شکستن وابستگی‌های دایره‌ای


#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> b;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> a; // استفاده از weak_ptr برای جلوگیری از وابستگی دایره‌ای
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b = b;
    b->a = a;

    // بدون weak_ptr، A و B به دلیل وابستگی دایره‌ای هرگز تخریب نمی‌شدند
    return 0;
} // A و B به درستی تخریب می‌شوند

مثال: استفاده از std::weak_ptr برای بررسی اعتبار شیء


#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(123);
    std::weak_ptr<int> weakPtr = sharedPtr;

    // بررسی کنید که آیا شیء هنوز وجود دارد
    if (auto observedPtr = weakPtr.lock()) { // lock() یک shared_ptr برمی‌گرداند اگر شیء وجود داشته باشد
        std::cout << "Object exists: " << *observedPtr << std::endl; // خروجی: Object exists: 123
    }

    sharedPtr.reset(); // آزادسازی مالکیت

    // دوباره پس از ریست شدن sharedPtr بررسی کنید
    if (auto observedPtr = weakPtr.lock()) {
        std::cout << "Object exists: " << *observedPtr << std::endl; // این اجرا نخواهد شد
    } else {
        std::cout << "Object has been destroyed." << std::endl; // خروجی: Object has been destroyed.
    }

    return 0;
}

ویژگی‌های کلیدی std::weak_ptr:

انتخاب اشاره‌گر هوشمند مناسب

انتخاب اشاره‌گر هوشمند مناسب به معناشناسی مالکیتی که باید اعمال کنید بستگی دارد:

بهترین شیوه‌ها برای استفاده از اشاره‌گرهای هوشمند

برای به حداکثر رساندن مزایای اشاره‌گرهای هوشمند و جلوگیری از مشکلات رایج، این بهترین شیوه‌ها را دنبال کنید:

مثال: استفاده از std::make_unique و std::make_shared


#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "MyClass constructed with value: " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value_ << std::endl;
    }

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    // استفاده از std::make_unique
    std::unique_ptr<MyClass> uniquePtr = std::make_unique<MyClass>(50);
    std::cout << "Unique pointer value: " << uniquePtr->getValue() << std::endl;

    // استفاده از std::make_shared
    std::shared_ptr<MyClass> sharedPtr = std::make_shared<MyClass>(100);
    std::cout << "Shared pointer value: " << sharedPtr->getValue() << std::endl;

    return 0;
}

اشاره‌گرهای هوشمند و ایمنی در برابر استثناها

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

مثال زیر را در نظر بگیرید که در آن هنگام استفاده از اشاره‌گرهای خام، احتمال نشت حافظه وجود دارد:


#include <iostream>

void processData() {
    int* data = new int[100]; // تخصیص حافظه

    // انجام عملیاتی که ممکن است استثنا پرتاب کنند
    try {
        // ... کد بالقوه پرتاب کننده استثنا ...
        throw std::runtime_error("Something went wrong!"); // استثنای نمونه
    } catch (...) {
        delete[] data; // آزادسازی حافظه در بلوک catch
        throw; // پرتاب مجدد استثنا
    }

    delete[] data; // آزادسازی حافظه (فقط در صورتی که استثنا پرتاب نشود، به این بخش می‌رسد)
}

اگر یک استثنا در بلوک try *قبل* از دستور delete[] data; اول پرتاب شود، حافظه تخصیص‌داده‌شده برای data نشت خواهد کرد. با استفاده از اشاره‌گرهای هوشمند، می‌توان از این امر جلوگیری کرد:


#include <iostream>
#include <memory>

void processData() {
    std::unique_ptr<int[]> data(new int[100]); // تخصیص حافظه با استفاده از اشاره‌گر هوشمند

    // انجام عملیاتی که ممکن است استثنا پرتاب کنند
    try {
        // ... کد بالقوه پرتاب کننده استثنا ...
        throw std::runtime_error("Something went wrong!"); // استثنای نمونه
    } catch (...) {
        throw; // پرتاب مجدد استثنا
    }

    // نیازی به حذف صریح data نیست؛ unique_ptr به طور خودکار آن را مدیریت می‌کند
}

در این مثال بهبودیافته، unique_ptr به طور خودکار حافظه تخصیص‌داده‌شده برای data را مدیریت می‌کند. اگر یک استثنا پرتاب شود، تخریب‌گر unique_ptr هنگام باز شدن پشته (stack unwinding) فراخوانی می‌شود و تضمین می‌کند که حافظه بدون توجه به اینکه استثنا گرفته شده یا دوباره پرتاب شده باشد، آزاد می‌شود.

نتیجه‌گیری

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

از استارتاپ‌ها در سیلیکون ولی که از ++C مدرن برای محاسبات با کارایی بالا استفاده می‌کنند تا شرکت‌های جهانی که سیستم‌های حیاتی را توسعه می‌دهند، اشاره‌گرهای هوشمند به طور جهانی قابل استفاده هستند. چه در حال ساخت سیستم‌های تعبیه‌شده برای اینترنت اشیاء باشید و چه در حال توسعه برنامه‌های مالی پیشرفته، تسلط بر اشاره‌گرهای هوشمند یک مهارت کلیدی برای هر توسعه‌دهنده ++C است که به دنبال برتری است.

برای مطالعه بیشتر