آموزش مدیریت فایل و استثناها در C++

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

فایل‌ها (C++ Files)

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

C++ برای مدیریت فایل‌ها از کتابخانه <fstream> استفاده می‌کند که شامل سه کلاس اصلی زیر است:

ifstream (ورودی فایل – برای خواندن داده‌ها از فایل)
ofstream (خروجی فایل – برای نوشتن داده‌ها در فایل)
fstream (ورودی/خروجی فایل – برای خواندن و نوشتن همزمان)
فایل‌ها در C++ می‌توانند دو نوع اصلی داشته باشند:

فایل‌های متنی (Text Files): شامل داده‌های قابل خواندن برای انسان، مانند فایل‌های .txt و .csv.
فایل‌های باینری (Binary Files): شامل داده‌هایی که به صورت خام ذخیره می‌شوند و فقط توسط برنامه قابل پردازش هستند، مانند فایل‌های تصویری و صوتی.
در ادامه، به نحوه باز کردن، خواندن و نوشتن در این فایل‌ها پرداخته می‌شود.

باز کردن فایل‌ها در C++

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

نحوه باز کردن فایل‌ها در حالت‌های مختلف:

#include <iostream>
#include <fstream>

int main() {
    std::ofstream outFile;  
    outFile.open("example.txt");  // باز کردن فایل برای نوشتن

    if (outFile.is_open()) {
        outFile << "این یک فایل نمونه است.";  // نوشتن در فایل
        outFile.close();  // بستن فایل
    } else {
        std::cout << "خطا در باز کردن فایل!" << std::endl;
    }
    return 0;
}

خواندن از فایل‌ها در C++

برای خواندن داده‌ها از فایل، از کلاس ifstream استفاده می‌شود. این کلاس امکان خواندن داده‌ها به‌صورت خط به خط، کلمه به کلمه یا حتی کاراکتر به کاراکتر را فراهم می‌کند.

خواندن یک فایل به‌صورت خط به خط:

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ifstream inFile("example.txt");  // باز کردن فایل برای خواندن
    std::string line;
    
    if (inFile.is_open()) {
        while (getline(inFile, line)) {  // خواندن هر خط از فایل
            std::cout << line << std::endl;
        }
        inFile.close();  // بستن فایل
    } else {
        std::cout << "فایل یافت نشد!" << std::endl;
    }
    return 0;
}

خواندن فایل به‌صورت کاراکتر به کاراکتر:

#include <iostream>
#include <fstream>

int main() {
    std::ifstream inFile("example.txt");
    char ch;

    if (inFile.is_open()) {
        while (inFile.get(ch)) {  // خواندن کاراکتر به کاراکتر
            std::cout << ch;
        }
        inFile.close();
    } else {
        std::cout << "خطا در باز کردن فایل!" << std::endl;
    }
    return 0;
}

نوشتن در فایل‌ها در C++

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

نوشتن در فایل (جایگزینی محتوای قبلی):

#include <iostream>
#include <fstream>

int main() {
    std::ofstream outFile("example.txt");  // باز کردن فایل برای نوشتن
    if (outFile.is_open()) {
        outFile << "سلام، این یک متن جدید است.";  // نوشتن در فایل
        outFile.close();
    } else {
        std::cout << "فایل باز نشد!" << std::endl;
    }
    return 0;
}

اضافه کردن به انتهای فایل:

#include <iostream>
#include <fstream>

int main() {
    std::ofstream outFile("example.txt", std::ios::app);  // باز کردن فایل در حالت append
    if (outFile.is_open()) {
        outFile << "\nمتن جدید به انتهای فایل اضافه شد.";  // اضافه کردن به انتهای فایل
        outFile.close();
    } else {
        std::cout << "خطا در باز کردن فایل!" << std::endl;
    }
    return 0;
}

فایل‌های باینری در C++

برخلاف فایل‌های متنی که داده‌ها را به‌صورت رشته‌های خوانا ذخیره می‌کنند، فایل‌های باینری داده‌ها را به‌صورت خام و فشرده ذخیره می‌کنند. این روش برای ذخیره داده‌های پیچیده‌تر مانند ساختارهای داده‌ای یا تصاویر استفاده می‌شود.

نوشتن داده در یک فایل باینری:

#include <iostream>
#include <fstream>

int main() {
    std::ofstream outFile("example.bin", std::ios::binary);  // باز کردن فایل در حالت باینری
    if (outFile.is_open()) {
        int data = 12345;
        outFile.write(reinterpret_cast<char*>(&data), sizeof(data));  // نوشتن داده باینری
        outFile.close();
    } else {
        std::cout << "خطا در باز کردن فایل!" << std::endl;
    }
    return 0;
}

خواندن داده از یک فایل باینری:

#include <iostream>
#include <fstream>

int main() {
    std::ifstream inFile("example.bin", std::ios::binary);  // باز کردن فایل در حالت باینری
    if (inFile.is_open()) {
        int data;
        inFile.read(reinterpret_cast<char*>(&data), sizeof(data));  // خواندن داده باینری
        std::cout << "عدد خوانده شده: " << data << std::endl;
        inFile.close();
    } else {
        std::cout << "فایل یافت نشد!" << std::endl;
    }
    return 0;
}

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

مدیریت استثنا (C++ Exceptions)

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

معرفی استثناها در C++

در C++، استثناها با استفاده از کلمه‌کلیدی throw پرتاب شده و در بلوک try پردازش می‌شوند. اگر یک استثنا رخ دهد، کنترل برنامه به اولین بلوک catch مناسب که قادر به دریافت آن استثنا باشد، منتقل می‌شود.

ساختار کلی مدیریت استثنا در C++:

try {
    // کد مستعد ایجاد استثنا
} catch (نوع_استثنا) {
    // کد برای مدیریت استثنا
}

مثال ساده از مدیریت استثنا در C++

در این مثال، اگر مقدار ورودی منفی باشد، یک استثنای std::invalid_argument پرتاب می‌شود و در catch پردازش خواهد شد:

#include <iostream>
#include <stdexcept>  

void checkValue(int value) {
    if (value < 0) {
        throw std::invalid_argument("مقدار نمی‌تواند منفی باشد.");  
    }
}

int main() {
    try {
        checkValue(-5);  
    } catch (const std::exception& e) {
        std::cout << "خطا: " << e.what() << std::endl;  
    }
    return 0;
}

در این کد:

اگر مقدار ورودی منفی باشد، throw std::invalid_argument یک استثنا ایجاد می‌کند.
catch (const std::exception& e) این استثنا را دریافت کرده و پیام مناسب را نمایش می‌دهد.

انواع استثناهای استاندارد در C++

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

std::exception: کلاس پایه برای تمام استثناهای استاندارد. سایر کلاس‌های استثنا از این کلاس مشتق می‌شوند.
std::runtime_error: برای خطاهای زمان اجرا مانند تقسیم بر صفر یا خطاهای غیرمنتظره.
std::logic_error: برای خطاهای منطقی که به دلیل اشتباهات برنامه‌نویسی رخ می‌دهند.
std::invalid_argument: زمانی که یک آرگومان نامعتبر به تابع ارسال شود.
std::out_of_range: در صورت تلاش برای دسترسی به عنصری خارج از محدوده یک آرایه یا بردار.
std::overflow_error: هنگامی که یک محاسبه ریاضی باعث سرریز شود.
std::underflow_error: زمانی که مقدار یک متغیر از حداقل مقدار قابل نمایش کمتر شود.

پرتاب و پردازش چندین نوع استثنا

گاهی ممکن است یک تابع بیش از یک نوع استثنا پرتاب کند. در این حالت می‌توان چندین بلوک catch برای مدیریت خطاهای مختلف تعریف کرد.

مثال: مدیریت چندین نوع استثنا

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("تقسیم بر صفر مجاز نیست!");  
    }
    if (a < 0 || b < 0) {
        throw std::invalid_argument("اعداد نباید منفی باشند!");  
    }
    return a / b;
}

int main() {
    try {
        std::cout << divide(-10, 2) << std::endl;  
    } catch (const std::runtime_error& e) {
        std::cout << "خطای زمان اجرا: " << e.what() << std::endl;  
    } catch (const std::invalid_argument& e) {
        std::cout << "خطای آرگومان نامعتبر: " << e.what() << std::endl;  
    }
    return 0;
}

در این مثال:

اگر b برابر صفر باشد، استثنای std::runtime_error پرتاب می‌شود.
اگر هر یک از اعداد ورودی منفی باشند، استثنای std::invalid_argument پرتاب می‌شود.
دو بلوک catch مختلف برای دریافت و مدیریت این استثناها در نظر گرفته شده است.

استثناهای سفارشی در C++

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

مثال: ایجاد یک کلاس استثنای سفارشی

#include <iostream>
#include <exception>

class CustomException : public std::exception {
public:
    const char* what() const noexcept override {
        return "این یک استثنای سفارشی است!";
    }
};

int main() {
    try {
        throw CustomException();  
    } catch (const std::exception& e) {
        std::cout << "خطا: " << e.what() << std::endl;  
    }
    return 0;
}

در این مثال:

کلاس CustomException از std::exception مشتق شده است.
متد what() بازنویسی شده تا پیام مناسبی را برگرداند.
درون بلوک try، استثنای CustomException پرتاب شده و سپس در catch پردازش می‌شود.

مدیریت استثنا در کلاس‌ها و سازنده‌ها

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

مثال: پرتاب استثنا در سازنده کلاس

#include <iostream>
#include <stdexcept>

class Person {
private:
    int age;
public:
    Person(int a) {
        if (a < 0) {
            throw std::invalid_argument("سن نمی‌تواند منفی باشد!");  
        }
        age = a;
    }
};

int main() {
    try {
        Person p(-5);  
    } catch (const std::exception& e) {
        std::cout << "خطا در مقداردهی شیء: " << e.what() << std::endl;  
    }
    return 0;
}

در این مثال:

اگر مقدار age منفی باشد، استثنای std::invalid_argument پرتاب می‌شود.
این استثنا در catch دریافت شده و پیام مناسب نمایش داده می‌شود.

استفاده از مدیریت استثنا در C++ به ما این امکان را می‌دهد که برنامه‌های مقاوم‌تری در برابر خطاها بنویسیم. با استفاده از try، catch و throw می‌توان به‌طور مؤثری از توقف ناگهانی برنامه جلوگیری کرد. همچنین، با بهره‌گیری از استثناهای استاندارد و سفارشی، می‌توان خطاها را به شیوه‌ای بهتر مدیریت کرد.

تاریخ در C++ (C++ Date)

مدیریت تاریخ و زمان یکی از قابلیت‌های مهم در بسیاری از برنامه‌های کاربردی است. در C++، می‌توان با استفاده از کتابخانه‌های استاندارد، تاریخ و زمان را پردازش کرد، اختلاف زمانی را محاسبه نمود و نمایش‌های مختلفی از زمان ارائه داد.

استفاده از کتابخانه chrono

کتابخانه chrono یکی از قوی‌ترین ابزارهای مدیریت زمان در C++ است که از C++11 به بعد معرفی شده است. این کتابخانه امکانات متنوعی برای کار با تاریخ، زمان و محاسبه بازه‌های زمانی ارائه می‌دهد.

دریافت زمان کنونی

برای دریافت زمان کنونی از std::chrono::system_clock استفاده می‌کنیم:

#include <iostream>
#include <chrono>

int main() {
    auto now = std::chrono::system_clock::now();  // دریافت زمان کنونی
    auto duration = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch());  // محاسبه مدت زمان از زمان آغاز (epoch)

    std::cout << "مدت زمان از آغاز سیستم: " << duration.count() << " ثانیه" << std::endl;
    return 0;
}

در این مثال:

system_clock::now() زمان فعلی سیستم را می‌گیرد.
time_since_epoch() مدت زمانی که از آغاز زمان مبدأ (epoch) گذشته است را برمی‌گرداند.
مقدار نهایی بر حسب ثانیه محاسبه و نمایش داده می‌شود.

محاسبه اختلاف بین دو زمان

می‌توان از chrono برای محاسبه مدت زمان سپری‌شده بین دو نقطه زمانی استفاده کرد:

#include <iostream>
#include <chrono>
#include <thread>  

int main() {
    auto start = std::chrono::high_resolution_clock::now();  // ذخیره زمان شروع  

    std::this_thread::sleep_for(std::chrono::seconds(3));  // شبیه‌سازی یک تأخیر 3 ثانیه‌ای  

    auto end = std::chrono::high_resolution_clock::now();  // ذخیره زمان پایان  

    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);  // محاسبه اختلاف زمانی  

    std::cout << "مدت زمان اجرا: " << duration.count() << " میلی‌ثانیه" << std::endl;
    return 0;
}

در این مثال:

زمان شروع ذخیره می‌شود.
برنامه به مدت 3 ثانیه متوقف می‌شود (std::this_thread::sleep_for).
سپس زمان پایان ثبت شده و اختلاف آن‌ها محاسبه می‌شود.

تبدیل تاریخ به فرمت‌های مختلف

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

#include <iostream>
#include <ctime>

int main() {
    std::time_t now = std::time(nullptr);  // دریافت زمان جاری
    std::tm* localTime = std::localtime(&now);  // تبدیل به زمان محلی

    std::cout << "تاریخ و زمان فعلی: " 
              << 1900 + localTime->tm_year << "-" 
              << 1 + localTime->tm_mon << "-" 
              << localTime->tm_mday << " " 
              << localTime->tm_hour << ":" 
              << localTime->tm_min << ":" 
              << localTime->tm_sec << std::endl;

    return 0;
}

در این مثال:

std::time(nullptr) زمان جاری را بر حسب ثانیه از epoch دریافت می‌کند.
std::localtime(&now) این مقدار را به زمان محلی تبدیل می‌کند.
سپس تاریخ و زمان در قالب YYYY-MM-DD HH:MM:SS نمایش داده می‌شود.

فرمت‌بندی تاریخ با strftime

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

#include <iostream>
#include <ctime>

int main() {
    std::time_t now = std::time(nullptr);
    std::tm* localTime = std::localtime(&now);
    char buffer[100];

    std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", localTime);
    std::cout << "فرمت استاندارد: " << buffer << std::endl;

    std::strftime(buffer, sizeof(buffer), "%A, %d %B %Y", localTime);
    std::cout << "فرمت سفارشی: " << buffer << std::endl;

    return 0;
}

در این مثال:

از strftime برای تغییر فرمت نمایش تاریخ استفاده شده است.
فرمت “Y-%m-%d %H:%M:%S” تاریخ را به صورت YYYY-MM-DD HH:MM:SS نمایش می‌دهد.
فرمت “A, %d %B %Y” نام روز هفته، شماره روز، نام ماه و سال را نمایش می‌دهد.

استفاده از زمان با منطقه‌های زمانی مختلف

C++ به صورت پیش‌فرض از زمان سیستم استفاده می‌کند، اما می‌توان با استفاده از gmtime، زمان جهانی را دریافت کرد:

#include <iostream>
#include <ctime>

int main() {
    std::time_t now = std::time(nullptr);
    std::tm* gmt = std::gmtime(&now);  

    std::cout << "زمان جهانی (UTC): " 
              << 1900 + gmt->tm_year << "-" 
              << 1 + gmt->tm_mon << "-" 
              << gmt->tm_mday << " " 
              << gmt->tm_hour << ":" 
              << gmt->tm_min << ":" 
              << gmt->tm_sec << std::endl;

    return 0;
}

در این مثال، gmtime برای تبدیل زمان محلی به زمان جهانی (UTC) استفاده شده است.

جمع و تفریق روی تاریخ و زمان

برای انجام عملیات ریاضی روی تاریخ، می‌توان از chrono استفاده کرد:

#include <iostream>
#include <chrono>

int main() {
    auto now = std::chrono::system_clock::now();
    auto future_time = now + std::chrono::hours(24);  // 24 ساعت بعد

    auto future_time_t = std::chrono::system_clock::to_time_t(future_time);
    std::cout << "زمان 24 ساعت بعد: " << std::ctime(&future_time_t);

    return 0;
}

در این مثال، 24 ساعت به زمان کنونی اضافه شده و زمان جدید نمایش داده می‌شود.

مدیریت تاریخ و زمان در C++ با استفاده از کتابخانه‌های chrono و ctime امکان‌پذیر است.

chrono برای پردازش‌های دقیق و محاسبات زمانی مناسب است.
ctime برای نمایش تاریخ و زمان به شکل خوانا کاربرد دارد.
امکان فرمت‌بندی تاریخ با strftime و انجام عملیات روی تاریخ با chrono وجود دارد.
این قابلیت‌ها به برنامه‌نویسان کمک می‌کند تا عملیات مرتبط با زمان را به شکل بهینه و دقیق پیاده‌سازی کنند.

نتیجه‌گیری

در این مقاله، به بررسی کامل مدیریت فایل و استثناها در C++ پرداختیم. یاد گرفتیم که چگونه با استفاده از کلاس‌های fstream عملیات خواندن و نوشتن روی فایل‌های متنی و باینری را انجام دهیم. همچنین، روش‌های مدیریت استثناها را بررسی کردیم و دیدیم که چگونه با استفاده از بلوک‌های try و catch می‌توان خطاهای احتمالی را کنترل کرد. در نهایت، با نحوه کار با تاریخ و زمان در C++ آشنا شدیم و یاد گرفتیم که چگونه از کتابخانه‌های chrono و ctime برای پردازش و نمایش تاریخ استفاده کنیم.

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