텍스트 파일 쓰기

#include <fstream>  // std::ofstream을 위해
#include <iostream> // std::cerr를 위해

int main() {
    // 방법 1: 생성과 동시에 파일 열기
    std::ofstream outFile1("output1.txt");
    if (!outFile1.is_open()) { // 파일 연결 여부 확인
        std::cerr << "output1.txt를 열 수 없습니다!\n";
    } else {
        // 파일 처리...
        outFile1.close();
    }

    // 방법 2: 객체 생성 후 open() 호출
    std::ofstream outFile2;
    outFile2.open("output2.txt");
    if (!outFile2) { // 스트림 객체 자체를 bool 컨텍스트에서 사용하여 성공 여부 확인 가능
        std::cerr << "output2.txt를 열 수 없습니다!\n";
    } else {
        // 파일 처리...
        outFile2.close();
    }

    return 0;
}

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

int main() {
    std::ofstream outFile("my_data.txt"); // my_data.txt 파일을 쓰기 모드로 엶

    if (!outFile.is_open()) {
        std::cerr << "오류: my_data.txt 파일을 열 수 없습니다!\n";
        return 1;
    }

    // 문자열 쓰기
    outFile << "Hello, File World!\n"; // '\n'은 개행 문자
    outFile << "C++ 파일 입출력 예제입니다.\n";

    // 숫자 쓰기
    int age = 30;
    double temperature = 25.7;
    outFile << "나이: " << age << "세\n";
    outFile << "오늘의 온도: " << temperature << "도\n";

    // 여러 값 한 줄에 쓰기
    std::string product = "Laptop";
    int quantity = 5;
    double price = 1200.50;
    outFile << product << ", " << quantity << ", " << price << '\n';

    // 중요한 출력은 close()가 보고하는 동기화 오류까지 확인
    outFile.close();
    if (!outFile) {
        std::cerr << "오류: my_data.txt 기록을 완료하지 못했습니다.\n";
        return 1;
    }

    std::cout << "데이터가 'my_data.txt' 파일에 기록되었습니다.\n";
    return 0;
}

Hello, File World!
C++ 파일 입출력 예제입니다.
나이: 30세
오늘의 온도: 25.7도
Laptop, 5, 1200.5

#include <iostream>
#include <fstream>
#include <string>
#include <chrono> // 현재 시간을 위해
#include <ctime> // std::localtime을 위해
#include <iomanip> // std::put_time을 위해

int main() {
    std::ofstream logFile;
    // std::ios::app 모드로 파일 열기. 파일이 없으면 생성, 있으면 끝에 추가
    logFile.open("application_log.txt", std::ios::app);

    if (!logFile.is_open()) {
        std::cerr << "오류: application_log.txt 파일을 열 수 없습니다!\n";
        return 1;
    }

    // 현재 시간을 가져와서 로그에 포함
    auto now = std::chrono::system_clock::now();
    auto in_time_t = std::chrono::system_clock::to_time_t(now);
    const std::tm* localTime = std::localtime(&in_time_t);
    if (localTime == nullptr) {
        std::cerr << "오류: 로컬 시간을 변환할 수 없습니다.\n";
        return 1;
    }

    // 시간 형식을 지정하여 출력
    // std::put_time은 C++11부터 사용 가능하며, <iomanip> 헤더 필요
    logFile << std::put_time(localTime, "%Y-%m-%d %H:%M:%S") << ": ";

    logFile << "애플리케이션이 실행되었습니다.\n";
    logFile << std::put_time(localTime, "%Y-%m-%d %H:%M:%S") << ": ";
    logFile << "사용자 'Admin'이 로그인했습니다.\n";

    logFile.close();
    if (!logFile) {
        std::cerr << "오류: 로그 쓰기 또는 닫기에 실패했습니다.\n";
        return 1;
    }

    std::cout << "로그가 'application_log.txt'에 추가되었습니다.\n";
    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <thread> // std::this_thread::sleep_for
#include <chrono> // std::chrono::seconds

int main() {
    std::ofstream outFile("buffered_output.txt");

    if (!outFile.is_open()) {
        std::cerr << "오류: buffered_output.txt 파일을 열 수 없습니다!\n";
        return 1;
    }

    outFile << "이것은 첫 번째 줄입니다.\n"; // '\n'만 사용, flush 안됨
    std::cout << "버퍼에만 쓰여졌을 수 있습니다. 잠시 대기...\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 2초 대기

    // 버퍼의 내용을 강제로 파일에 기록
    outFile.flush();
    std::cout << "스트림 버퍼 동기화를 요청했습니다. 잠시 대기...\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 2초 대기

    outFile << "이것은 두 번째 줄입니다." << std::endl; // 의도적인 개행 + flush
    std::cout << "std::endl로 스트림 버퍼 동기화를 요청했습니다.\n";

    outFile.close(); // 닫기 과정의 동기화 실패는 상태 비트에 반영될 수 있음
    if (!outFile) {
        std::cerr << "오류: 쓰기 또는 닫기에 실패했습니다.\n";
        return 1;
    }
    std::cout << "파일을 닫고 스트림 상태를 확인했습니다.\n";

    return 0;
}

#include <iostream>
#include <fstream>

int main() {
    std::ofstream outFile("protected_file.txt"); // 쓰기 권한이 없는 파일 또는 디스크 가득 참 가정

    if (!outFile.is_open()) {
        std::cerr << "파일을 열 수 없습니다. 쓰기 권한을 확인하세요.\n";
        return 1;
    }

    outFile << "데이터를 씁니다.\n";

    if (outFile.bad()) {
        std::cerr << "파일 쓰기 중 심각한 오류가 발생했습니다. (bad())\n";
    } else if (outFile.fail()) { // fail()은 failbit뿐 아니라 badbit도 포함
        std::cerr << "파일 쓰기 중 오류가 발생했습니다. (fail())\n";
    }

    outFile.close();
    if (!outFile) {
        std::cerr << "쓰기 또는 닫기를 완료하지 못했습니다.\n";
        return 1;
    }
    return 0;
}