آموزش ساختارهای داده و کتابخانه استاندارد قالب‌ها (STL) در C++

آموزش C++ بدون درک صحیح از ساختارهای داده (Data Structures) و کتابخانه استاندارد قالب‌ها (Standard Template Library یا STL) ناقص خواهد بود. این دو مبحث به برنامه‌نویسان کمک می‌کنند تا داده‌ها را بهینه مدیریت کرده و الگوریتم‌های مؤثر را پیاده‌سازی کنند. در این مقاله، به بررسی ساختارهای داده و کتابخانه استاندارد قالب‌ها (STL) در C++ می‌پردازیم.

ساختارهای داده (C++ Data Structures)

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

استفاده از ساختارهای داده مناسب می‌تواند تأثیر زیادی در عملکرد و بهره‌وری برنامه‌های کامپیوتری داشته باشد. برای مثال، در جایی که به جستجوی سریع نیاز است، می‌توان از نقشه‌ها (Maps) استفاده کرد، درحالی‌که برای ذخیره مقادیر منحصربه‌فرد، مجموعه‌ها (Sets) گزینه‌ای مناسب هستند. هر یک از این ساختارها مزایا و معایب خاص خود را دارند و انتخاب درست آن‌ها وابسته به نوع مسئله است.
ساختارهای داده راهکارهایی برای ذخیره و سازماندهی داده‌ها هستند. در C++، برخی از پرکاربردترین ساختارهای داده شامل آرایه‌ها، لیست‌های پیوندی، پشته‌ها، صف‌ها، مجموعه‌ها و نقشه‌ها هستند. این ساختارها پایه‌ای برای حل مسائل مختلف در علوم کامپیوتر محسوب می‌شوند.

ساختارهای داده و کتابخانه استاندارد قالب‌ها (STL)

کتابخانه استاندارد قالب‌ها (Standard Template Library یا STL) مجموعه‌ای از کلاس‌ها و توابع است که در زبان C++ برای تسهیل مدیریت داده‌ها و بهینه‌سازی عملکرد برنامه‌ها استفاده می‌شود. این کتابخانه شامل انواع مختلفی از ساختارهای داده مانند بردارها (Vectors)، لیست‌ها (Lists)، مجموعه‌ها (Sets) و نقشه‌ها (Maps) است که هر یک ویژگی‌ها و کاربردهای خاص خود را دارند.

علاوه بر این، (STL) شامل مجموعه‌ای از الگوریتم‌های بهینه‌سازی‌شده مانند مرتب‌سازی، جستجو، پر کردن داده‌ها و پردازش عددی است. این الگوریتم‌ها می‌توانند بر روی کانتینرها (Containers) اجرا شوند که امکان پردازش کارآمد داده‌ها را فراهم می‌کنند. همچنین، تکرارگرها (Iterators) ابزارهایی هستند که در این کتابخانه برای پیمایش عناصر درون کانتینرها مورد استفاده قرار می‌گیرند.

از ویژگی‌های کلیدی (STL) می‌توان به موارد زیر اشاره کرد:

افزایش سرعت توسعه: بسیاری از عملیات رایج مانند مرتب‌سازی و جستجو از پیش پیاده‌سازی شده‌اند.

استفاده از کدهای عمومی: امکان استفاده از قالب‌ها (Templates) برای نوشتن کدهای انعطاف‌پذیر و قابل استفاده مجدد.

مدیریت بهینه حافظه: بسیاری از کانتینرهای (STL) مدیریت حافظه را به صورت خودکار انجام می‌دهند.

انعطاف‌پذیری و مقیاس‌پذیری: این کتابخانه امکان پیاده‌سازی الگوریتم‌های کارآمد را برای انواع مختلفی از داده‌ها فراهم می‌کند.

با استفاده از (STL)، برنامه‌نویسان می‌توانند کدهای تمیزتر، کارآمدتر و خواناتر بنویسند، که در نهایت به توسعه نرم‌افزارهای سریع‌تر و قابل نگهداری‌تر منجر می‌شود.

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

با بهره‌گیری از (STL)، برنامه‌نویسان می‌توانند کدهای تمیزتر، قابل خواندن‌تر و با عملکرد بهینه‌تر بنویسند. این کتابخانه نه‌تنها فرآیند توسعه را تسریع می‌کند، بلکه باعث می‌شود که بسیاری از چالش‌های مدیریت حافظه به صورت خودکار مدیریت شوند.
(STL) مجموعه‌ای از کلاس‌ها و توابع است که عملیات روی داده‌ها را تسهیل می‌کند. این کتابخانه شامل چندین بخش اصلی است:

کانتینرها (Containers): برای ذخیره و مدیریت داده‌ها

تکرارگرها (Iterators): برای پیمایش داده‌ها

الگوریتم‌ها (Algorithms): برای پردازش داده‌ها

بردارها (C++ Vectors)

بردارها (Vectors) در C++ یکی از مهم‌ترین و پرکاربردترین ساختارهای داده در کتابخانه استاندارد (STL) هستند که عملکردی مشابه آرایه‌ها دارند اما با قابلیت تغییر اندازه در زمان اجرا. این قابلیت باعث افزایش انعطاف‌پذیری و مدیریت بهینه حافظه در برنامه‌های کاربردی می‌شود.

ویژگی‌های بردارها در C++:

اندازه پویا: برخلاف آرایه‌ها که اندازه ثابتی دارند، بردارها به‌طور خودکار در صورت نیاز گسترش می‌یابند.

دسترسی تصادفی سریع: به دلیل استفاده از حافظه پیوسته، دسترسی به عناصر با استفاده از اندیس با پیچیدگی زمانی (O(1 انجام می‌شود.

عملکرد بهینه در اضافه و حذف از انتها: توابع push_back() و pop_back() عملیات درج و حذف را با کمترین هزینه انجام می‌دهند.

امکان استفاده از توابع آماده STL: مانند size(), insert(), erase(), clear() و غیره.

نحوه تعریف و استفاده از بردارها:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> vec = {1, 2, 3, 4};
    vec.push_back(5); // افزودن مقدار 5 به انتهای بردار
    
    cout << "عناصر بردار: ";
    for (int num : vec) {
        cout << num << " ";
    }
    
    cout << "
اندازه بردار: " << vec.size() << endl;
    
    vec.pop_back(); // حذف آخرین عنصر
    cout << "
پس از حذف آخرین عنصر: ";
    for (int num : vec) {
        cout << num << " ";
    }
    
    return 0;
}

مقایسه بردار با آرایه معمولی:

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

مدیریت خودکار حافظه: هنگام تغییر اندازه، بردارها تخصیص و آزادسازی حافظه را مدیریت می‌کنند.

افزایش ظرفیت هزینه دارد: هنگام افزایش اندازه، داده‌ها به یک مکان جدید کپی می‌شوند که ممکن است هزینه‌بر باشد.

دسترسی سریع: به دلیل ذخیره‌سازی پیوسته در حافظه، عملکرد خواندن و نوشتن در بردارها سریع‌تر از std::list است.

نکات مهم در استفاده از بردارها:

مدیریت حافظه: بردارها هنگام افزایش اندازه، حافظه جدیدی اختصاص داده و داده‌ها را منتقل می‌کنند که می‌تواند زمان‌بر باشد. استفاده از reserve() می‌تواند کارایی را بهبود ببخشد.

دسترسی سریع: بردارها به دلیل ذخیره‌سازی پیوسته در حافظه، از آرایه‌های معمولی کمی کندتر ولی همچنان سریع‌تر از std::list هستند.

درج و حذف بهینه: درج و حذف در انتهای بردار سریع است، اما انجام این عملیات در وسط یا ابتدای بردار هزینه‌بر است.

ایمنی دسترسی: استفاده از operator[] یا at() برای دسترسی به عناصر می‌تواند منجر به خطاهای دسترسی نامعتبر شود، بنابراین بررسی اندازه بردار ضروری است.

بهینه‌سازی عملکرد: در مواردی که حجم داده‌ها زیاد است، مقداردهی اولیه با reserve() یا استفاده از shrink_to_fit() برای آزادسازی حافظه اضافی توصیه می‌شود.

در صورت نیاز به درج و حذف مکرر عناصر در وسط مجموعه، std::list گزینه بهتری محسوب می‌شود.

برای جلوگیری از تخصیص‌های پیاپی حافظه، می‌توان از reserve() برای تعیین ظرفیت اولیه استفاده کرد.

هنگام استفاده از operator[] یا at() برای دسترسی به عناصر، مراقب عدم دسترسی به اندیس‌های نامعتبر باشید.

لیست (C++ List)

لیست‌ها در C++ با استفاده از std::list پیاده‌سازی می‌شوند که از لیست‌های پیوندی دوطرفه (Doubly Linked List) استفاده می‌کنند. برخلاف بردارها (std::vector)، که داده‌ها را به‌صورت پیوسته در حافظه ذخیره می‌کنند، لیست‌ها از گره‌های (Nodes) جداگانه تشکیل شده‌اند که هر کدام شامل داده و اشاره‌گرهایی به عناصر قبلی و بعدی هستند.

ویژگی‌های کلیدی لیست‌ها:

افزودن و حذف سریع عناصر: از آنجایی که لیست‌ها نیازی به جابه‌جایی عناصر ندارند، افزودن و حذف عناصر در هر نقطه‌ای از لیست دارای پیچیدگی زمانی (O(1 است.

عدم دسترسی تصادفی: برخلاف std::vector که امکان دسترسی مستقیم به عناصر را با عملگر [] فراهم می‌کند، در std::list باید از تکرارگرها (Iterators) برای پیمایش استفاده شود که سرعت کمتری دارد.

پشتیبانی از توابع پیشرفته: توابعی مانند push_front()، push_back()، pop_front() و pop_back() برای مدیریت عناصر در ابتدا و انتهای لیست بهینه هستند.

تعریف و استفاده از لیست در C++:

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> myList = {10, 20, 30};
    myList.push_front(5); // افزودن عنصر به ابتدای لیست
    myList.push_back(40); // افزودن عنصر به انتهای لیست

    cout << "لیست: ";
    for (int num : myList) {
        cout << num << " ";
    }
    cout << endl;
    
    myList.pop_front(); // حذف عنصر از ابتدای لیست
    myList.pop_back(); // حذف عنصر از انتهای لیست
    
    cout << "پس از حذف اولین و آخرین عنصر: ";
    for (int num : myList) {
        cout << num << " ";
    }
    return 0;
}

مقایسه std::list با std::vector:

سرعت درج و حذف: لیست‌ها برای درج و حذف سریع در هر نقطه‌ای از لیست بهتر هستند، درحالی‌که بردارها هنگام حذف از ابتدای آرایه عملکرد ضعیفی دارند.

دسترسی تصادفی: بردارها امکان دسترسی سریع (O(1 به عناصر دارند، اما لیست‌ها برای یافتن یک عنصر نیاز به پیمایش دارند (O(n)).

مصرف حافظه: لیست‌ها به دلیل استفاده از اشاره‌گرها به حافظه بیشتری نسبت به بردارها نیاز دارند.

مرتب‌سازی و جستجو: برای جستجو و مرتب‌سازی سریع، بردارها بهتر عمل می‌کنند، درحالی‌که لیست‌ها برای عملیات درج و حذف بهتر هستند.

نکات مهم در استفاده از لیست‌ها:

اگر نیاز به دسترسی سریع به عناصر دارید، std::vector انتخاب بهتری است.

برای حذف و درج مکرر در وسط داده‌ها، std::list گزینه مناسب‌تری محسوب می‌شود.

برای افزایش کارایی، از تکرارگرها به‌جای استفاده مستقیم از حلقه‌ها بهره ببرید.

لیست پیوندی (List) در C++ از کلاس std::list استفاده می‌کند و قابلیت افزودن یا حذف عناصر را در زمان ثابت فراهم می‌آورد.

مثال:

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> myList = {10, 20, 30};
    myList.push_front(5);
    myList.push_back(40);
    for (int num : myList) {
        cout << num << " ";
    }
    return 0;
}

پشته‌ها (C++ Stacks)

پشته‌ها (Stacks) یکی از مهم‌ترین و پرکاربردترین ساختارهای داده در علوم کامپیوتر هستند. این ساختار داده‌ای، همان‌طور که از نام آن مشخص است، شبیه به یک پشته واقعی (مثل یک پشته کتاب یا ظروف) عمل می‌کند که در آن هر چیزی که آخرین بار اضافه شده باشد، اول از همه برداشته می‌شود. این ویژگی به عنوان اصل LIFO (Last In, First Out) شناخته می‌شود.

ویژگی‌های اصلی پشته‌ها

ترتیب ورود و خروج: آخرین عنصری که وارد پشته می‌شود، اولین عنصری است که از آن خارج می‌شود.
افزودن و حذف: پشته‌ها فقط از یک طرف (قسمت بالا) برای افزودن و حذف عناصر دسترسی دارند. این عملیات‌ها با نام‌های push و pop شناخته می‌شوند.
دسترسی به عنصر بالا: شما می‌توانید همیشه به آخرین عنصری که به پشته اضافه شده است (عنصر بالای پشته) دسترسی داشته باشید. این کار با استفاده از تابع top انجام می‌شود.

کاربردهای پشته‌ها

پشته‌ها در بسیاری از الگوریتم‌ها و برنامه‌ها کاربرد دارند. به برخی از مهم‌ترین کاربردهای آن اشاره می‌کنیم:

مدیریت وضعیت‌ها (Undo/Redo): یکی از کاربردهای معروف پشته‌ها در برنامه‌هایی مانند ویرایشگرهای متن، مرورگرهای وب و برنامه‌های طراحی است. برای مثال، در یک ویرایشگر متن، هر بار که کاربر تغییراتی ایجاد می‌کند، این تغییرات به پشته اضافه می‌شود. در صورت نیاز به برگشت به حالت قبل (Undo)، آخرین تغییر از پشته حذف می‌شود و وضعیت قبلی بازیابی می‌گردد. به همین ترتیب، برای انجام عملیات Redo، تغییرات قبلی دوباره به پشته اضافه می‌شود.

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

الگوریتم‌های جستجو و مرتب‌سازی: در برخی الگوریتم‌ها مانند DFS (Depth-First Search) در گراف‌ها و درخت‌ها، از پشته‌ها برای ذخیره‌سازی گره‌ها به منظور پیمایش عمیق در گراف‌ها استفاده می‌شود.

عملیات‌های اصلی پشته‌ها

در یک پشته، عملیات‌های اصلی شامل موارد زیر است:

push: این عملیات برای افزودن یک عنصر به پشته استفاده می‌شود.

مثال: stk.push(10); این دستور عدد 10 را به پشته اضافه می‌کند.
pop: این عملیات برای حذف آخرین عنصری که به پشته اضافه شده است، استفاده می‌شود.

مثال: stk.pop(); این دستور آخرین عنصر از پشته را حذف می‌کند.
top: این عملیات برای مشاهده آخرین عنصر پشته بدون حذف آن استفاده می‌شود.

مثال: stk.top(); این دستور آخرین عنصر پشته را برمی‌گرداند، اما آن را از پشته حذف نمی‌کند.
empty: این عملیات بررسی می‌کند که آیا پشته خالی است یا خیر.

مثال: stk.empty(); اگر پشته خالی باشد، true برمی‌گرداند.
size: این عملیات برای دریافت تعداد عناصر موجود در پشته استفاده می‌شود.

مثال: stk.size(); تعداد عناصر موجود در پشته را برمی‌گرداند.

مثال عملی از پشته‌ها در C++

برای درک بهتر نحوه کار پشته‌ها در C++، در اینجا یک مثال ساده آورده‌ایم:

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> stk; // تعریف یک پشته از نوع int

    // افزودن عناصر به پشته
    stk.push(10);
    stk.push(20);
    stk.push(30);

    cout << "آخرین عنصر پشته: " << stk.top() << endl; // مشاهده عنصر بالای پشته

    // حذف عناصر از پشته
    stk.pop(); // حذف عنصر 30
    cout << "آخرین عنصر بعد از حذف: " << stk.top() << endl; // مشاهده عنصر بعدی پشته (20)

    // بررسی اندازه پشته
    cout << "تعداد عناصر در پشته: " << stk.size() << endl; // چاپ تعداد عناصر پشته

    // بررسی اینکه آیا پشته خالی است
    if (stk.empty()) {
        cout << "پشته خالی است" << endl;
    } else {
        cout << "پشته خالی نیست" << endl;
    }

    return 0;
}

خروجی برنامه:

آخرین عنصر پشته: 30
آخرین عنصر بعد از حذف: 20
تعداد عناصر در پشته: 2
پشته خالی نیست

نکات تکمیلی:

پشته‌ها معمولا برای کارهای موقت و گذرا استفاده می‌شوند. از آن‌ها برای ذخیره‌سازی داده‌ها در حافظه به طور دائمی استفاده نمی‌شود.
در مواردی که نیازی به دسترسی تصادفی به عناصر پشته نباشد، پشته‌ها انتخاب مناسبی هستند، زیرا عملیات‌های افزودن و حذف با پیچیدگی زمانی ثابت (O(1)) انجام می‌شود.
در زبان C++، پشته‌ها به صورت پیش‌فرض از std::stack پیاده‌سازی می‌شوند که به شما این امکان را می‌دهد که به راحتی از این ساختار داده استفاده کنید

صف‌ها (C++ Queues)

صف‌ها (Queues) یکی دیگر از ساختارهای داده‌ای اساسی در علوم کامپیوتر هستند که بر اساس اصل FIFO (First In, First Out) عمل می‌کنند. این به این معناست که اولین عنصری که وارد صف می‌شود، اولین عنصری است که از آن خارج می‌شود. به عبارت ساده، صف‌ها مانند صف‌های واقعی در زندگی روزمره هستند که در آن افراد به ترتیب وارد صف می‌شوند و همانطور به ترتیب از صف خارج می‌شوند.

ویژگی‌های اصلی صف‌ها

ترتیب ورود و خروج: برخلاف پشته‌ها که بر اساس اصل LIFO (Last In, First Out) عمل می‌کنند، صف‌ها بر اساس FIFO عمل می‌کنند. این بدین معنی است که اولین عنصری که وارد صف می‌شود، ابتدا از صف خارج خواهد شد.
دسترس‌پذیری محدود: برخلاف ساختارهایی مثل آرایه‌ها یا لیست‌ها که به شما این امکان را می‌دهند که به تمامی عناصر به طور همزمان دسترسی داشته باشید، در صف‌ها تنها می‌توانید به عنصر اول (در حال حاضر) و آخر (عنصری که در صف قرار است وارد شود) دسترسی داشته باشید.

افزودن و حذف: در صف‌ها، فقط دو عملیات اصلی وجود دارد:

افزودن به انتها (enqueue): این عملیات برای اضافه کردن یک عنصر جدید به انتهای صف استفاده می‌شود.
حذف از ابتدا (dequeue): این عملیات برای حذف اولین عنصر صف استفاده می‌شود.

کاربردهای صف‌ها

صف‌ها در بسیاری از کاربردهای واقعی و الگوریتم‌ها به کار می‌روند. به برخی از کاربردهای مهم صف‌ها اشاره می‌کنیم:

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

پیاده‌سازی صف‌های مشتریان: در برنامه‌هایی که نیاز به شبیه‌سازی صف‌های واقعی دارند (مانند صف‌های مشتریان در بانک‌ها یا فروشگاه‌ها)، از صف‌ها استفاده می‌شود. در این شرایط، مشتریان به ترتیب وارد صف می‌شوند و به ترتیب از صف خارج می‌شوند تا خدمات دریافت کنند.

مدیریت صف‌های پیام‌ها: در سیستم‌های توزیع‌شده و شبکه‌ها، پیام‌ها و درخواست‌ها ممکن است در صف قرار گیرند تا در ترتیب مناسب پردازش شوند. این صف‌ها به طور معمول از ویژگی FIFO برای مدیریت درخواست‌های مختلف استفاده می‌کنند.

برنامه‌نویسی غیرهمزمان: صف‌ها همچنین در برنامه‌نویسی غیرهمزمان و برنامه‌های چندنخی (Multithreading) کاربرد دارند. وقتی که داده‌ها از چند منبع متفاوت می‌آیند، صف‌ها می‌توانند برای مدیریت ترتیب دسترسی به داده‌ها استفاده شوند.

عملیات‌های اصلی صف‌ها

در یک صف، عملیات‌های اصلی که بر روی آن انجام می‌شود عبارتند از:

push (افزودن به صف): این عملیات برای افزودن یک عنصر جدید به انتهای صف استفاده می‌شود.

مثال: q.push(10); این دستور عدد 10 را به انتهای صف اضافه می‌کند.
pop (حذف از صف): این عملیات برای حذف اولین عنصری که به صف وارد شده، استفاده می‌شود.

مثال: q.pop(); این دستور اولین عنصر از صف را حذف می‌کند.
front (دسترسی به عنصر اول صف): این عملیات برای دسترسی به اولین عنصر صف بدون حذف آن استفاده می‌شود.

مثال: q.front(); این دستور اولین عنصر از صف را برمی‌گرداند.
empty (بررسی خالی بودن صف): این عملیات برای بررسی این که آیا صف خالی است یا نه استفاده می‌شود.

مثال: q.empty(); اگر صف خالی باشد، true برمی‌گرداند.
size (دریافت اندازه صف): این عملیات برای دریافت تعداد عناصر موجود در صف استفاده می‌شود.

مثال: q.size(); این دستور تعداد عناصر موجود در صف را برمی‌گرداند.

مثال عملی از صف‌ها در C++

برای درک بهتر نحوه کار صف‌ها در C++، در اینجا یک مثال ساده آورده‌ایم:

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q; // تعریف یک صف از نوع int

    // افزودن عناصر به صف
    q.push(10); // افزودن مقدار 10 به صف
    q.push(20); // افزودن مقدار 20 به صف
    q.push(30); // افزودن مقدار 30 به صف
    
    // مشاهده اولین عنصر صف
    cout << "اولین عنصر صف: " << q.front() << endl; // مشاهده عنصر اول صف (10)

    // حذف اولین عنصر صف
    q.pop(); // حذف عنصر 10 از صف
    cout << "اولین عنصر بعد از حذف: " << q.front() << endl; // مشاهده عنصر اول صف (20)

    // بررسی اندازه صف
    cout << "تعداد عناصر در صف: " << q.size() << endl; // چاپ تعداد عناصر صف

    // بررسی اینکه آیا صف خالی است
    if (q.empty()) {
        cout << "صف خالی است" << endl;
    } else {
        cout << "صف خالی نیست" << endl;
    }

    return 0;
}

خروجی برنامه:

اولین عنصر صف: 10
اولین عنصر بعد از حذف: 20
تعداد عناصر در صف: 2
صف خالی نیست

نکات تکمیلی:

صف‌ها به طور خاص برای مواردی که نیاز به مدیریت داده‌ها به ترتیب ورود دارند، مناسب هستند. این ویژگی‌ها به آن‌ها قدرت ویژه‌ای در بسیاری از مسائل می‌دهند.
در زبان C++، صف‌ها معمولاً از std::queue پیاده‌سازی می‌شوند که به شما این امکان را می‌دهد که به راحتی از این ساختار داده استفاده کنید.
عملیات‌های افزودن و حذف از صف‌ها در پیچیدگی زمانی O(1) انجام می‌شوند، یعنی این عملیات‌ها بسیار سریع هستند و زمان اجرای آن‌ها به اندازه تعداد عناصر صف بستگی ندارد.

دک (C++ Deque)

دک (Deque) که مخفف “Double-Ended Queue” به معنای صف دوطرفه است، یکی از ساختارهای داده‌ای در C++ است که به شما این امکان را می‌دهد که داده‌ها را هم از ابتدا و هم از انتهای آن اضافه یا حذف کنید. برخلاف صف‌ها (Queues) که فقط از یک سمت قابل دسترسی هستند، در دک می‌توان به طور همزمان از دو طرف به داده‌ها دسترسی داشت.

ویژگی‌های اصلی دک‌ها

دسترسی دوطرفه: در دک‌ها شما می‌توانید عملیات افزودن (push) و حذف (pop) را هم از ابتدای دک و هم از انتهای آن انجام دهید.
دسترسی به عناصر: مانند آرایه‌ها و لیست‌ها، دک‌ها این امکان را می‌دهند که به عناصر موجود در آن‌ها دسترسی مستقیم داشته باشید. در حقیقت، شما می‌توانید به هر دو طرف دک (ابتدا و انتها) به راحتی دسترسی پیدا کنید.
عملیات‌های دوطرفه: از آنجا که دک‌ها صف‌های دوطرفه هستند، عملیات‌های push_front, push_back, pop_front, و pop_back در دسترس هستند که این اجازه را به شما می‌دهند که داده‌ها را از هر دو طرف اضافه و حذف کنید.

کاربردهای دک‌ها

دک‌ها برای مواردی که نیاز به دسترسی به داده‌ها از هر دو طرف دارند بسیار مناسب هستند. به برخی از کاربردهای دک‌ها اشاره می‌کنیم:

اجرای الگوریتم‌های پیچیده: در الگوریتم‌هایی مانند الگوریتم‌های جستجو و مرتب‌سازی که نیاز دارند از هر دو سمت داده‌ها را پردازش کنند، دک‌ها می‌توانند بسیار مفید باشند.

پیاده‌سازی صف‌های اولویت: دک‌ها می‌توانند برای پیاده‌سازی صف‌های اولویت (Priority Queues) استفاده شوند که در آن‌ها نیاز به افزودن یا حذف داده‌ها از هر دو طرف وجود دارد.

مدیریت داده‌های دودویی: در بسیاری از الگوریتم‌ها مانند الگوریتم‌های پیمایش درخت و گراف که نیاز دارند از هر دو طرف داده‌ها به طور همزمان پردازش شوند، دک‌ها استفاده می‌شوند.

پیاده‌سازی فیلترها و استراتژی‌های بازی: در برخی بازی‌ها و شبیه‌سازی‌ها که نیاز به مدیریت داده‌ها از دو سمت دارند (مانند بازی‌هایی که به ترتیب و نوبت‌های مختلف نیاز دارند)، دک‌ها به خوبی جوابگو هستند.

عملیات‌های اصلی دک‌ها

در دک‌ها شما می‌توانید به راحتی داده‌ها را هم از ابتدای دک و هم از انتهای آن اضافه و حذف کنید. عملیات‌های اصلی دک‌ها شامل موارد زیر است:

push_front (افزودن به ابتدای دک): این عملیات برای افزودن یک عنصر به ابتدای دک استفاده می‌شود.
مثال: dq.push_front(10); این دستور عدد 10 را به ابتدای دک اضافه می‌کند.
push_back (افزودن به انتهای دک): این عملیات برای افزودن یک عنصر به انتهای دک استفاده می‌شود.
مثال: dq.push_back(20); این دستور عدد 20 را به انتهای دک اضافه می‌کند.
pop_front (حذف از ابتدای دک): این عملیات برای حذف اولین عنصر دک استفاده می‌شود.
مثال: dq.pop_front(); این دستور اولین عنصر از دک را حذف می‌کند.
pop_back (حذف از انتهای دک): این عملیات برای حذف آخرین عنصر دک استفاده می‌شود.
مثال: dq.pop_back(); این دستور آخرین عنصر از دک را حذف می‌کند.
front (دسترسی به اولین عنصر دک): این عملیات برای دسترسی به اولین عنصر دک بدون حذف آن استفاده می‌شود.
مثال: dq.front(); این دستور اولین عنصر از دک را برمی‌گرداند.
back (دسترسی به آخرین عنصر دک): این عملیات برای دسترسی به آخرین عنصر دک بدون حذف آن استفاده می‌شود.
مثال: dq.back(); این دستور آخرین عنصر از دک را برمی‌گرداند.
size (دریافت اندازه دک): این عملیات برای دریافت تعداد عناصر موجود در دک استفاده می‌شود.
مثال: dq.size(); این دستور تعداد عناصر موجود در دک را برمی‌گرداند.

مثال عملی از دک‌ها در C++

برای درک بهتر نحوه کار دک‌ها در C++، در اینجا یک مثال ساده آورده‌ایم:

#include <iostream>
#include <deque>
using namespace std;

int main() {
    deque<int> dq; // تعریف یک دک از نوع int

    // افزودن عناصر به ابتدای دک
    dq.push_front(10); // افزودن مقدار 10 به ابتدای دک
    dq.push_front(5);  // افزودن مقدار 5 به ابتدای دک

    // افزودن عناصر به انتهای دک
    dq.push_back(20);  // افزودن مقدار 20 به انتهای دک
    dq.push_back(30);  // افزودن مقدار 30 به انتهای دک
    
    // مشاهده اولین و آخرین عنصر دک
    cout << "اولین عنصر دک: " << dq.front() << endl;  // مشاهده اولین عنصر (5)
    cout << "آخرین عنصر دک: " << dq.back() << endl;   // مشاهده آخرین عنصر (30)
    
    // حذف اولین و آخرین عنصر دک
    dq.pop_front();  // حذف اولین عنصر (5)
    dq.pop_back();   // حذف آخرین عنصر (30)

    // مشاهده اولین و آخرین عنصر بعد از حذف
    cout << "اولین عنصر بعد از حذف: " << dq.front() << endl;  // مشاهده اولین عنصر (10)
    cout << "آخرین عنصر بعد از حذف: " << dq.back() << endl;   // مشاهده آخرین عنصر (20)

    return 0;
}

خروجی برنامه:

اولین عنصر دک: 5
آخرین عنصر دک: 30
اولین عنصر بعد از حذف: 10
آخرین عنصر بعد از حذف: 20

نکات تکمیلی:

دک‌ها به دلیل توانایی انجام عملیات‌ها از هر دو سمت، برای بسیاری از الگوریتم‌ها که نیاز به پردازش داده‌ها از هر دو طرف دارند، بسیار کارآمد هستند.
عملیات‌های push_front و push_back در دک‌ها در O(1) زمان انجام می‌شوند، به این معنی که زمان اجرای آن‌ها بستگی به تعداد عناصر موجود در دک ندارد و همواره ثابت است.
دک‌ها برخلاف لیست‌ها و آرایه‌ها، به شما این امکان را می‌دهند که به راحتی به دو طرف داده‌ها دسترسی پیدا کنید و این ویژگی در بسیاری از الگوریتم‌ها مفید است.

مجموعه‌ها (C++ Sets)

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

ویژگی‌های اصلی مجموعه‌ها

یگانگی مقادیر: در مجموعه‌ها، هیچ‌گونه عنصر تکراری مجاز نیست. وقتی که شما سعی کنید عنصری را که قبلاً در مجموعه وجود دارد وارد کنید، آن عنصر نادیده گرفته می‌شود.
مرتب‌سازی خودکار: عناصر داخل مجموعه‌ها به طور خودکار به ترتیب مرتب می‌شوند. این ترتیب معمولاً به ترتیب صعودی برای انواع داده‌های عددی (مانند int یا float) است، اما برای انواع داده‌های پیچیده‌تر نیز می‌توان ترتیبی خاص تعیین کرد.
عملیات‌های سریع: بسیاری از عملیات‌ها بر روی مجموعه‌ها مانند جستجو، اضافه کردن یا حذف عنصر در مجموعه‌ها در زمان O(logn) انجام می‌شود که این ویژگی باعث می‌شود مجموعه‌ها برای استفاده در جستجوها و پردازش‌های سریع بسیار مفید باشند.
دسترسی محدود: برخلاف آرایه‌ها یا لیست‌ها که دسترسی تصادفی به عناصر دارند، در مجموعه‌ها نمی‌توانید به طور مستقیم به یک عنصر خاص با استفاده از اندیس دسترسی پیدا کنید. دسترسی به عناصر از طریق پیمایش (iterating) یا جستجو (search) انجام می‌شود.

کاربردهای مجموعه‌ها

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

حذف عناصر تکراری: یکی از رایج‌ترین کاربردهای مجموعه‌ها در حذف مقادیر تکراری از مجموعه‌ای از داده‌ها است. اگر بخواهید مجموعه‌ای از داده‌ها را وارد کرده و سپس تمام مقادیر تکراری را حذف کنید، مجموعه‌ها گزینه‌ای عالی هستند.

جستجو و پردازش سریع: از آنجا که مجموعه‌ها عملیات جستجو، افزودن و حذف را در زمان O(logn) انجام می‌دهند، می‌توان از آنها برای انجام عملیات‌های جستجوی سریع و پردازش‌های پیچیده استفاده کرد.

حل مسائل الگوریتمی: بسیاری از مسائل الگوریتمی نیاز به استفاده از مجموعه‌ها دارند. به طور مثال، در الگوریتم‌های مرتب‌سازی، جستجو یا حتی شبیه‌سازی‌ها، استفاده از مجموعه‌ها می‌تواند به سرعت و دقت الگوریتم کمک کند.

پیاده‌سازی مجموعه‌های ریاضی: مجموعه‌ها به طور طبیعی برای پیاده‌سازی عملیات مجموعه‌های ریاضی مانند اتحاد (Union)، اشتراک (Intersection) و تفاوت (Difference) استفاده می‌شوند.

عملیات‌های اصلی مجموعه‌ها

مجموعه‌ها در C++ عملیات‌های مختلفی دارند که از آن‌ها برای مدیریت داده‌ها استفاده می‌شود. برخی از عملیات‌های اصلی عبارتند از:

insert (افزودن عنصر به مجموعه): این عملیات برای افزودن یک عنصر جدید به مجموعه استفاده می‌شود. اگر عنصر قبلاً وجود داشته باشد، به مجموعه افزوده نخواهد شد.

مثال: s.insert(10); این دستور عدد 10 را به مجموعه اضافه می‌کند.
erase (حذف عنصر از مجموعه): این عملیات برای حذف یک عنصر از مجموعه استفاده می‌شود.

مثال: s.erase(10); این دستور عدد 10 را از مجموعه حذف می‌کند.
find (جستجو برای یک عنصر): این عملیات برای جستجوی یک عنصر در مجموعه استفاده می‌شود. اگر عنصر موجود باشد، اشاره‌گر به آن باز می‌گردد و در غیر این صورت اشاره‌گر به end() برمی‌گردد.

مثال: s.find(10); این دستور بررسی می‌کند که آیا عدد 10 در مجموعه وجود دارد یا خیر.
size (دریافت اندازه مجموعه): این عملیات برای دریافت تعداد عناصر موجود در مجموعه استفاده می‌شود.

مثال: s.size(); این دستور تعداد عناصر موجود در مجموعه را برمی‌گرداند.
empty (بررسی خالی بودن مجموعه): این عملیات برای بررسی این که آیا مجموعه خالی است یا خیر استفاده می‌شود.

مثال: s.empty(); این دستور بررسی می‌کند که آیا مجموعه خالی است یا خیر.

مثال عملی از مجموعه‌ها در C++

برای درک بهتر نحوه کار مجموعه‌ها در C++، در اینجا یک مثال ساده آورده‌ایم:

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s; // تعریف یک مجموعه از نوع int

    // افزودن عناصر به مجموعه
    s.insert(10); // افزودن مقدار 10 به مجموعه
    s.insert(20); // افزودن مقدار 20 به مجموعه
    s.insert(10); // تلاش برای افزودن مقدار 10 مجدداً (که نادیده گرفته می‌شود)

    // چاپ مقادیر مجموعه
    for (auto& num : s) {
        cout << num << " "; // چاپ مقادیر مجموعه (10 و 20)
    }
    
    return 0;
}

خروجی برنامه:

10 20

در این مثال:

مقدار 10 برای بار دوم وارد مجموعه شد، اما چون مجموعه‌ها فقط مقادیر منحصر به فرد را نگه می‌دارند، این عملیات نادیده گرفته شد.
مقادیر مجموعه به ترتیب مرتب شده‌اند (10 قبل از 20).

نکات تکمیلی:

مجموعه‌ها به طور خودکار مقادیر را مرتب می‌کنند. برای انواع داده‌های استاندارد مانند int یا float, این مرتب‌سازی به ترتیب صعودی انجام می‌شود. اگر نیاز به مرتب‌سازی متفاوتی دارید، می‌توانید از توابع سفارشی برای مقایسه استفاده کنید.
از آنجا که مجموعه‌ها برای جستجو و حذف سریع طراحی شده‌اند، عملیات‌هایی مانند insert، erase و find معمولاً در زمان O(logn) انجام می‌شوند.
مجموعه‌ها در C++ از std::set پیاده‌سازی شده‌اند و به طور پیش‌فرض از الگوریتم درخت جستجوی دودویی متوازن (Balanced Binary Search Tree) برای ذخیره‌سازی استفاده می‌کنند.

نقشه‌ها (C++ Maps)

نقشه‌ها (Maps) در C++ یکی از ساختارهای داده‌ای هستند که امکان ذخیره‌سازی داده‌ها را به صورت زوج‌های کلید-مقدار فراهم می‌کنند. در این ساختار داده، هر عنصر از یک کلید و یک مقدار تشکیل شده است. شما می‌توانید داده‌ها را با استفاده از کلیدهای منحصر به فرد ذخیره کرده و به راحتی مقدار متناظر با هر کلید را جستجو کنید. این ساختار مشابه دیکشنری‌ها (dictionaries) در زبان‌های دیگر است.

ویژگی‌های اصلی نقشه‌ها

زوج‌های کلید-مقدار: نقشه‌ها به شما این امکان را می‌دهند که داده‌ها را به صورت زوج‌های کلید-مقدار ذخیره کنید. هر کلید باید منحصر به فرد باشد و برای هر کلید تنها یک مقدار وجود دارد.
دسترسی سریع به مقدارها: شما می‌توانید به سرعت به مقدار متناظر با هر کلید دسترسی پیدا کنید، چون دسترسی به مقادیر در نقشه‌ها به طور معمول در زمان
O(logn) انجام می‌شود.
مرتب‌سازی خودکار: عناصر در نقشه‌ها به طور خودکار بر اساس کلیدها مرتب می‌شوند. به این معنی که اگر کلیدها اعداد صحیح یا مقادیر قابل مقایسه باشند، آنها به ترتیب صعودی (یا ترتیب دلخواه با استفاده از توابع مقایسه) مرتب خواهند شد.
اصلاح داده‌ها: با استفاده از کلید، شما می‌توانید مقدار متناظر را به‌روز کنید یا حتی حذف کنید.

کاربردهای نقشه‌ها

نقشه‌ها به دلیل ساختار کلید-مقدار خود برای کاربردهای بسیاری مفید هستند:

ذخیره داده‌ها با کلید منحصر به فرد: زمانی که شما نیاز دارید مقادیر را با استفاده از یک شناسه منحصر به فرد (کلید) ذخیره کنید، نقشه‌ها گزینه خوبی هستند. برای مثال، می‌توانید اطلاعات مربوط به مشتریان را با استفاده از شناسه مشتری به عنوان کلید ذخیره کنید.

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

ذخیره‌سازی تنظیمات یا پیکربندی: نقشه‌ها می‌توانند برای ذخیره‌سازی تنظیمات برنامه، مانند مقادیر مربوط به پیکربندی، مورد استفاده قرار گیرند.

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

عملیات‌های اصلی نقشه‌ها

نقشه‌ها در C++ عملیات‌های مختلفی دارند که به شما این امکان را می‌دهند که داده‌ها را مدیریت کنید. برخی از عملیات‌های اصلی عبارتند از:

insert (افزودن زوج کلید-مقدار): این عملیات برای افزودن یک زوج جدید به نقشه استفاده می‌شود. اگر کلید قبلاً وجود داشته باشد، مقدار جدید جایگزین مقدار قبلی می‌شود.

مثال: m[1] = “Apple”; این دستور کلید 1 را به مقدار “Apple” می‌افزاید یا مقدار آن را به‌روز می‌کند.
erase (حذف یک زوج کلید-مقدار): این عملیات برای حذف یک زوج کلید-مقدار از نقشه استفاده می‌شود.

مثال: m.erase(1); این دستور زوج کلید-مقدار با کلید 1 را از نقشه حذف می‌کند.
find (جستجو برای یک کلید): این عملیات برای جستجوی یک کلید در نقشه استفاده می‌شود. اگر کلید موجود باشد، اشاره‌گر به زوج کلید-مقدار آن باز می‌گردد.

مثال: m.find(1); این دستور بررسی می‌کند که آیا کلید 1 در نقشه وجود دارد یا خیر.
size (دریافت اندازه نقشه): این عملیات برای دریافت تعداد زوج‌های کلید-مقدار موجود در نقشه استفاده می‌شود.

مثال: m.size(); این دستور تعداد زوج‌های کلید-مقدار در نقشه را برمی‌گرداند.
empty (بررسی خالی بودن نقشه): این عملیات برای بررسی اینکه آیا نقشه خالی است یا خیر استفاده می‌شود.

مثال: m.empty(); این دستور بررسی می‌کند که آیا نقشه خالی است یا خیر.
access (دسترسی به مقدار با استفاده از کلید): می‌توان از عملگر [] برای دسترسی به مقدار متناظر با یک کلید استفاده کرد. اگر کلید وجود نداشته باشد، یک مقدار پیش‌فرض برای آن کلید تنظیم می‌شود.

مثال: m[3] = “Cherry”; این دستور یک کلید جدید به نام 3 با مقدار “Cherry” به نقشه اضافه می‌کند.

مثال عملی از نقشه‌ها در C++

برای درک بهتر نحوه کار نقشه‌ها در C++، در اینجا یک مثال ساده آورده‌ایم:

#include <iostream>
#include <map>
using namespace std;

int main() {
    map<int, string> m; // تعریف یک نقشه با کلید int و مقدار string

    // افزودن زوج کلید-مقدار به نقشه
    m[1] = "Apple"; // افزودن کلید 1 با مقدار "Apple"
    m[2] = "Banana"; // افزودن کلید 2 با مقدار "Banana"
    m[3] = "Cherry"; // افزودن کلید 3 با مقدار "Cherry"
    m[4] = "Date";   // افزودن کلید 4 با مقدار "Date"
    
    // پیمایش و چاپ تمام عناصر نقشه
    for (auto& pair : m) {
        cout << pair.first << ": " << pair.second << endl; // چاپ کلید و مقدار
    }
    
    // جستجوی یک کلید خاص
    auto it = m.find(2);
    if (it != m.end()) {
        cout << "مقدار کلید 2: " << it->second << endl; // چاپ مقدار کلید 2 (Banana)
    }

    // حذف یک کلید از نقشه
    m.erase(3); // حذف کلید 3
    cout << "بعد از حذف کلید 3:" << endl;
    
    // چاپ مجدد تمام عناصر نقشه
    for (auto& pair : m) {
        cout << pair.first << ": " << pair.second << endl;
    }

    return 0;
}

خروجی برنامه:

1: Apple
2: Banana
3: Cherry
4: Date
مقدار کلید 2: Banana
بعد از حذف کلید 3:
1: Apple
2: Banana
4: Date

در این مثال:

ابتدا چهار زوج کلید-مقدار به نقشه افزوده شد.
سپس با استفاده از حلقه for، تمامی عناصر نقشه چاپ شدند.
با استفاده از متد find، مقدار کلید 2 جستجو و چاپ شد.
در نهایت، کلید 3 از نقشه حذف شد و دوباره مقادیر نقشه چاپ شدند.

نکات تکمیلی:

نقشه‌ها در C++ به طور پیش‌فرض از درخت جستجوی دودویی متوازن (Balanced Binary Search Tree) برای ذخیره‌سازی استفاده می‌کنند، بنابراین عملیات‌های insert, erase, و find در زمانO(logn) انجام می‌شوند.
می‌توانید از std::map برای ساختارهای داده‌ای با کلیدهای مرتب استفاده کنید. همچنین برای مجموعه‌های بدون ترتیب از std::unordered_map استفاده می‌شود که به جای درخت از هش‌جدول‌ها استفاده می‌کند و معمولاً زمان دسترسی به مقادیر در آن O(1) است.

تکرارگرها (C++ Iterators)

تکرارگرها (Iterators) در C++ ابزارهایی هستند که به شما اجازه می‌دهند که به راحتی درون containers مختلف پیمایش کنید و به عناصر آن‌ها دسترسی داشته باشید. تکرارگرها به عنوان رابطی برای دسترسی به داده‌های ذخیره‌شده در containers عمل می‌کنند و این کار را به روشی مشابه نشانگرها (pointers) انجام می‌دهند. به عبارت دیگر، تکرارگرها مانند یک نشانگر عمل می‌کنند که به شما اجازه می‌دهند به طور مستقیم به عناصر container دسترسی پیدا کنید.

ویژگی‌های تکرارگرها

دسترس‌پذیری به عناصر: تکرارگرها به شما این امکان را می‌دهند که به راحتی به هر عنصر در container دسترسی پیدا کنید، حتی در containers پیچیده مانند vector, list, map و غیره.

پیمایش در containers: می‌توانید از تکرارگرها برای پیمایش در داخل containers و اجرای عملیات مختلف روی داده‌ها استفاده کنید. تکرارگرها به شما این امکان را می‌دهند که به صورت مؤثری داده‌ها را پردازش کنید، بدون اینکه نیاز به استفاده از ایندکس‌های دستی یا ساختارهای پیچیده داشته باشید.

ساده‌سازی کد: با استفاده از تکرارگرها، کد شما تمیزتر و ساده‌تر خواهد بود زیرا نیازی به دسترسی مستقیم به ایندکس‌ها یا استفاده از روش‌های مختلف برای هر نوع container نیست.

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

Input Iterators: برای دسترسی به داده‌ها به صورت تک‌طرفه (برای خواندن).
Output Iterators: برای نوشتن داده‌ها به صورت تک‌طرفه.
Forward Iterators: برای خواندن و نوشتن داده‌ها به صورت یک‌طرفه.
Bidirectional Iterators: مشابه Forward Iterators با این تفاوت که می‌توانند به جلو و عقب پیمایش کنند.
Random Access Iterators: مشابه نشانگرها که می‌توانند به هر عنصر دسترسی تصادفی و مستقیم داشته باشند.

عملیات‌های تکرارگرها: تکرارگرها از چندین عملیات پشتیبانی می‌کنند، مانند:

++it: حرکت به عنصر بعدی.
–it: حرکت به عنصر قبلی (برای تکرارگرهای دوطرفه).
*it: دسترسی به مقدار عنصر جاری.
it == it2: مقایسه دو تکرارگر برای بررسی برابری آن‌ها.

کاربردهای تکرارگرها

پیمایش در داده‌ها: تکرارگرها برای پیمایش در داده‌های ذخیره‌شده در containers مختلف مفید هستند. برای مثال، اگر بخواهید در یک vector یا list از ابتدا تا انتها پیمایش کنید، می‌توانید از تکرارگرها استفاده کنید.

الگوریتم‌ها: بسیاری از الگوریتم‌های استاندارد در C++ (مانند sort, find, accumulate, count, و غیره) به تکرارگرها نیاز دارند. این الگوریتم‌ها به جای کار کردن با ایندکس‌ها یا داده‌های مستقیم، از تکرارگرها برای دسترسی به داده‌ها استفاده می‌کنند.

عملیات بر روی داده‌ها: تکرارگرها اجازه می‌دهند که به سادگی با داده‌های داخل containers کار کنید، چه بخواهید به صورت موقتی مقادیر را تغییر دهید یا داده‌ها را جستجو کنید.

مثال عملی از تکرارگرها

در اینجا یک مثال ساده آورده شده است که نشان می‌دهد چگونه می‌توان از تکرارگرها برای پیمایش درون یک vector استفاده کرد:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> vec = {1, 2, 3, 4, 5};

    // استفاده از تکرارگر برای پیمایش درون vector
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        cout << *it << " "; // دسترسی به مقدار عنصر با استفاده از تکرارگر
    }

    return 0;
}

توضیح کد:
vec.begin(): این متد تکرارگر را به اولین عنصر vector ارجاع می‌دهد.
vec.end(): این متد به عنصر پس از آخرین عنصر vector ارجاع می‌دهد که به عنوان نشانگر پایان استفاده می‌شود.
++it: این عملیات تکرارگر را به عنصر بعدی حرکت می‌دهد.
*it: این عملیات به شما اجازه می‌دهد که به مقدار عنصر جاری دسترسی پیدا کنید.

خروجی برنامه:

1 2 3 4 5 

انواع دیگر تکرارگرها

Bidirectional Iterator: در containers مانند list که قابلیت حرکت به جلو و عقب را دارند، می‌توانید از تکرارگرهای دوطرفه استفاده کنید. این تکرارگرها به شما این امکان را می‌دهند که علاوه بر حرکت به جلو، به عقب نیز حرکت کنید.

list<int> mylist = {1, 2, 3, 4, 5};
for (auto it = mylist.begin(); it != mylist.end(); ++it) {
    cout << *it << " ";
}

Random Access Iterator: در containers مانند vector و deque، که می‌توانند به طور تصادفی به عناصر دسترسی پیدا کنند، از تکرارگرهای دسترسی تصادفی استفاده می‌شود. این نوع تکرارگرها به شما اجازه می‌دهند که مستقیماً به هر عنصر دسترسی پیدا کنید.

vector<int> vec = {10, 20, 30, 40, 50};
cout << vec[2];  // دسترسی به عنصر سوم با استفاده از ایندکس

نکات تکمیلی:

استفاده از تکرارگرها باعث می‌شود که کد شما جنس‌پذیرتر و مقیاس‌پذیرتر باشد، زیرا نیازی به تغییر کد برای هر نوع container مختلف ندارید. این ویژگی در هنگام کار با انواع مختلف داده‌ها و containers بسیار مفید است.
تکرارگرها اجازه می‌دهند که از الگوریتم‌های استاندارد موجود در کتابخانه STL (مانند std::sort, std::reverse, std::find, و غیره) استفاده کنید، که به طور گسترده در پروژه‌های C++ به کار می‌روند.

الگوریتم‌ها (C++ Algorithms)

کتابخانه STL (Standard Template Library) در C++ شامل مجموعه‌ای از الگوریتم‌های آماده است که می‌توانند به راحتی برای انجام عملیات‌های مختلف بر روی داده‌ها استفاده شوند. این الگوریتم‌ها بسیار قدرتمند و کارآمد هستند و شما را قادر می‌سازند تا بر روی داده‌های ذخیره‌شده در containers مختلف (مانند vector, list, map, و غیره) به سادگی عملیات‌های مختلفی انجام دهید. الگوریتم‌های C++ به طور معمول شامل عملیات‌هایی مانند جستجو، مرتب‌سازی، فیلتر کردن، تغییرات در داده‌ها و غیره می‌شوند.

ویژگی‌های الگوریتم‌ها در C++

سادگی در استفاده: بسیاری از الگوریتم‌های موجود در STL به سادگی قابل استفاده هستند و تنها با دادن تکرارگرهای مناسب به آن‌ها، عملیات‌های پیچیده انجام می‌شود.

عملکرد بهینه: الگوریتم‌های STL به طور کارآمد طراحی شده‌اند و معمولاً زمان اجرای آن‌ها بهینه است. این الگوریتم‌ها بر اساس بهترین شیوه‌های طراحی الگوریتم‌ها پیاده‌سازی شده‌اند و بنابراین از نظر سرعت و استفاده بهینه از منابع سیستم کارآمد هستند.

جنریک بودن: الگوریتم‌های STL به طور عمومی و جنریک (Generic) طراحی شده‌اند و می‌توانند با انواع مختلف داده‌ها و containers کار کنند. این به این معناست که شما می‌توانید از یک الگوریتم خاص برای انواع مختلف داده‌ها و containers استفاده کنید.

پشتیبانی از انواع عملیات: کتابخانه STL از انواع مختلف عملیات‌ها پشتیبانی می‌کند که شامل جستجو، مرتب‌سازی، تغییر داده‌ها، مقایسه، و فیلتر کردن است.

انواع مختلف الگوریتم‌ها در C++

کتابخانه استاندارد C++ بیش از 70 الگوریتم مختلف را در خود جای داده است. این الگوریتم‌ها به طور کلی به چند دسته تقسیم می‌شوند:

الگوریتم‌های جستجو (Search Algorithms):

find: برای پیدا کردن یک عنصر خاص در یک container.
binary_search: برای جستجوی باینری یک عنصر در یک container مرتب‌شده.

مثال:

vector<int> vec = {1, 2, 3, 4, 5};
auto it = find(vec.begin(), vec.end(), 3); // جستجوی عنصر 3
if (it != vec.end()) {
    cout << "Element found!" << endl;
} else {
    cout << "Element not found!" << endl;
}

الگوریتم‌های مرتب‌سازی (Sorting Algorithms):

sort: برای مرتب‌سازی یک container از عناصر آن.
reverse: برای معکوس کردن ترتیب عناصر یک container.

مثال:

vector<int> vec = {5, 2, 9, 1, 5, 6};
sort(vec.begin(), vec.end()); // مرتب‌سازی بردار
for (auto& num : vec) {
    cout << num << " "; // چاپ بردار مرتب‌شده
}

الگوریتم‌های فیلتر کردن و تغییر (Filtering and Transforming Algorithms):

remove: برای حذف مقادیری از یک container.
transform: برای اعمال یک عملیات به تمام عناصر یک container.

مثال:

vector<int> vec = {1, 2, 3, 4, 5};
transform(vec.begin(), vec.end(), vec.begin(), [](int x) { return x * x; }); // محاسبه مربع هر عنصر
for (auto& num : vec) {
    cout << num << " "; // چاپ مقادیر تغییر یافته
}

الگوریتم‌های مقایسه (Comparison Algorithms):

equal: برای مقایسه دو container یا بخشی از آن‌ها.
max_element: برای پیدا کردن بزرگترین عنصر در یک container.

مثال:

vector<int> vec = {5, 3, 9, 1};
auto it = max_element(vec.begin(), vec.end()); // پیدا کردن بزرگترین عنصر
cout << "Max element: " << *it << endl;

الگوریتم‌های کاهش (Reduction Algorithms):

accumulate: برای جمع کردن مقادیر یک container.
count: برای شمارش تعداد تکرار یک مقدار خاص در یک container.

مثال:

vector<int> vec = {1, 2, 3, 4, 5};
int sum = accumulate(vec.begin(), vec.end(), 0); // جمع عناصر بردار
cout << "Sum of elements: " << sum << endl;

الگوریتم‌های تغییر ترتیب (Rearrangement Algorithms):

shuffle: برای مخلوط کردن تصادفی عناصر یک container.
rotate: برای چرخاندن عناصر یک container.

مثال عملی: مرتب‌سازی و جستجو

در این مثال، ابتدا یک vector از اعداد داریم و سپس از دو الگوریتم sort و find استفاده می‌کنیم.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> vec = {5, 2, 9, 1, 5, 6};

    // مرتب‌سازی بردار
    sort(vec.begin(), vec.end());

    cout << "Sorted vector: ";
    for (auto& num : vec) {
        cout << num << " ";
    }
    cout << endl;

    // جستجوی یک عنصر
    auto it = find(vec.begin(), vec.end(), 5); // جستجوی عنصر 5
    if (it != vec.end()) {
        cout << "Element found!" << endl;
    } else {
        cout << "Element not found!" << endl;
    }

    return 0;
}

خروجی برنامه:

Sorted vector: 1 2 5 5 6 9 
Element found!

نکات تکمیلی:

عملکرد الگوریتم‌ها: الگوریتم‌های C++ معمولاً به گونه‌ای طراحی شده‌اند که زمان اجرای بهینه داشته باشند. برای مثال، الگوریتم sort در STL معمولاً از الگوریتم quicksort یا heap sort استفاده می‌کند که دارای پیچیدگی زمانی O(n log n) است.

جنریک بودن الگوریتم‌ها: الگوریتم‌های STL به صورت جنریک طراحی شده‌اند به این معنا که می‌توانند با هر نوع container و هر نوع داده‌ای که قابل مقایسه یا قابل تغییر است، کار کنند. برای مثال، شما می‌توانید از الگوریتم sort برای مرتب‌سازی یک vector از نوع int یا double استفاده کنید، بدون نیاز به تغییر در کد.

استفاده از عملکردهای کاربردی: کتابخانه STL همچنین مجموعه‌ای از توابع مفید را برای عملیات‌های روزمره مانند جمع، میانگین، شمارش، فیلتر کردن و تغییر داده‌ها در اختیار شما قرار می‌دهد. این توابع باعث کاهش زمان کدنویسی و تسهیل انجام کارهای پیچیده می‌شود.

نتیجه‌گیری

در این مقاله، به بررسی جامع و کامل ساختارهای داده و (STL) در C++ پرداختیم و توضیحاتی مفصل درباره انواع مختلف ساختارهای داده مانند بردارها (Vectors)، لیست‌ها (Lists)، پشته‌ها (Stacks)، صف‌ها (Queues)، دک‌ها (Deque)، مجموعه‌ها (Sets) و نقشه‌ها (Maps) ارائه دادیم. همچنین نحوه استفاده از تکرارگرها (Iterators) و الگوریتم‌ها (Algorithms) در C++ به طور دقیق شرح داده شد.

کتابخانه استاندارد قالب‌ها (STL) در C++ با فراهم آوردن ابزارهای قدرتمند برای مدیریت داده‌ها و انجام عملیات‌های مختلف، برنامه‌نویسان را قادر می‌سازد تا کدهای خود را ساده، بهینه و قابل خواندن بنویسند. استفاده صحیح از این ساختارهای داده و الگوریتم‌ها می‌تواند به بهبود کارایی و عملکرد برنامه‌های پیچیده کمک کند.

در نهایت، ساختارهای داده و (STL) در C++ بخش جدایی‌ناپذیر از توسعه نرم‌افزارهای پیچیده و بهینه است که هر برنامه‌نویس C++ باید با آن‌ها آشنایی کامل داشته باشد. امیدواریم این مقاله به شما در درک بهتر این مفاهیم کمک کرده و شما را برای استفاده مؤثر از STL در پروژه‌های خود آماده کرده باشد.