Chapter 17 输入、输出和文件

#include <iostream> // 包含 iostream 以使用 cin, cout, cerr, clog

int main() {
    int age;
    std::cout << "Enter your age: "; // 使用 cout 输出提示信息到标准输出
    std::cin >> age;                 // 使用 cin 从标准输入读取整数

    if (age < 0) {
        std::cerr << "Error: Age cannot be negative." << std::endl; // 使用 cerr 输出错误信息到标准错误
        std::clog << "Log: Invalid age entered." << std::endl;     // 使用 clog 输出日志信息
        return 1;
    }

    std::cout << "You entered: " << age << std::endl; // 输出结果到标准输出

    return 0;
}

#include <iostream>
#include <string>

int main() {
    int age = 30;
    double weight = 65.5;
    char initial = 'J';
    const char* name = "John Doe";
    std::string city = "New York";

    std::cout << "--- Basic Output ---" << std::endl; // endl 插入换行符并刷新缓冲区
    std::cout << "Name: " << name << std::endl;
    std::cout << "Initial: " << initial << std::endl;
    std::cout << "Age: " << age << std::endl;
    std::cout << "Weight: " << weight << " kg" << std::endl;
    std::cout << "City: " << city << std::endl;

    // 链接输出
    std::cout << "\n--- Chained Output ---" << std::endl;
    std::cout << name << " (" << initial << "), age " << age
              << ", lives in " << city << "." << std::endl;

    // 输出指针地址 (通常以十六进制显示)
    int* ptr_age = &age;
    std::cout << "\nAddress of age: " << ptr_age << std::endl;

    return 0;
}

#include <iostream>

int main() {
    int num = 255;
    std::cout << "Default (decimal): " << num << std::endl; // 输出 255
    std::cout << std::hex; // 设置为十六进制
    std::cout << "Hexadecimal: " << num << std::endl; // 输出 ff
    std::cout << std::oct; // 设置为八进制
    std::cout << "Octal: " << num << std::endl; // 输出 377
    std::cout << std::dec; // 恢复为十进制
    std::cout << "Decimal again: " << num << std::endl; // 输出 255

    // 配合 showbase 和 uppercase
    std::cout << std::showbase << std::uppercase; // 显示基数前缀并使用大写字母
    std::cout << "Hex with base and uppercase: " << std::hex << num << std::endl; // 输出 0XFF
    std::cout << "Octal with base: " << std::oct << num << std::endl; // 输出 0377
    std::cout << std::noshowbase << std::nouppercase << std::dec; // 恢复默认

    return 0;
}

#include <iostream>
#include <iomanip> // for setw

int main() {
    double val = 12.3;
    std::cout << "*" << val << "*" << std::endl; // 输出 *12.3*

    std::cout.width(10); // 设置宽度为 10
    std::cout << "*" << val << "*" << std::endl; // 输出 *      12.3* (右对齐)
    // 宽度设置失效
    std::cout << "*" << val << "*" << std::endl; // 输出 *12.3*

    // 使用 setw
    std::cout << "*" << std::setw(10) << val << "*" << std::setw(5) << "Hi" << "*" << std::endl;
    // 输出 *      12.3*   Hi*

    return 0;
}

#include <iostream>
#include <iomanip> // for setw, setfill

int main() {
    int num = 42;
    std::cout << "Default fill: *" << std::setw(6) << num << "*" << std::endl; // 输出 *    42*

    std::cout.fill('*'); // 设置填充字符为 '*'
    std::cout << "Star fill: *" << std::setw(6) << num << "*" << std::endl; // 输出 ****42*

    // 使用 setfill
    std::cout << "Dash fill: *" << std::setfill('-') << std::setw(6) << num << "*" << std::endl; // 输出 ----42*

    std::cout.fill(' '); // 恢复默认填充字符
    return 0;
}

#include <iostream>
#include <iomanip> // for setprecision
#include <cmath>   // for M_PI

int main() {
    double pi = M_PI; // 大约 3.14159265...
    std::cout << "Default precision: " << pi << std::endl; // 通常输出 6 位有效数字

    std::cout.precision(4); // 设置精度为 4
    std::cout << "Precision 4: " << pi << std::endl; // 输出 3.142 (默认模式下是有效数字)

    // 使用 setprecision
    std::cout << "Precision 8: " << std::setprecision(8) << pi << std::endl; // 输出 3.1415927

    std::cout.precision(6); // 恢复默认精度
    return 0;
}

#include <iostream>
#include <iomanip> // for fixed, scientific, setprecision

int main() {
    double num1 = 12345.6789;
    double num2 = 0.000012345;

    std::cout << std::setprecision(5); // 设置精度为 5

    std::cout << "Default format:\n";
    std::cout << num1 << "\t" << num2 << std::endl; // 输出 12346	1.2345e-05 (精度5表示有效数字)

    std::cout << std::fixed; // 设置为定点格式
    std::cout << "Fixed format:\n";
    std::cout << num1 << "\t" << num2 << std::endl; // 输出 12345.67890	0.00001 (精度5表示小数位数)

    std::cout << std::scientific; // 设置为科学计数法格式
    std::cout << "Scientific format:\n";
    std::cout << num1 << "\t" << num2 << std::endl; // 输出 1.23457e+04	1.23450e-05 (精度5表示小数位数)

    // 恢复默认格式 (需要清除 floatfield)
    std::cout.unsetf(std::ios_base::floatfield);
    std::cout << "Back to default format:\n";
    std::cout << num1 << "\t" << num2 << std::endl; // 输出 12346	1.2345e-05

    return 0;
}

#include <iostream>
#include <iomanip>

int main() {
    // 保存当前格式状态
    std::ios_base::fmtflags original_flags = std::cout.flags();
    std::streamsize original_precision = std::cout.precision();

    // 进行一些格式化输出
    std::cout << std::fixed << std::setprecision(2) << std::showpos;
    std::cout << "Formatted: " << 12.345 << " " << -6.7 << std::endl;

    // 恢复原始格式状态
    std::cout.flags(original_flags);
    std::cout.precision(original_precision);

    std::cout << "Restored: " << 12.345 << " " << -6.7 << std::endl;

    return 0;
}

#include <iostream>
#include <string>

int main() {
    int age;
    double price;
    std::string name;
    char initial;

    std::cout << "Enter age, price, initial, and name (separated by spaces): ";
    // Example input: 30 99.99 J Doe

    std::cin >> age >> price >> initial >> name; // 可以链接读取

    std::cout << "\n--- You entered ---" << std::endl;
    std::cout << "Age: " << age << std::endl;       // Output: 30
    std::cout << "Price: " << price << std::endl;   // Output: 99.99
    std::cout << "Initial: " << initial << std::endl; // Output: J
    std::cout << "Name: " << name << std::endl;     // Output: Doe (只读取到空格前)

    // 此时，输入缓冲区中可能还留有 " Doe" 后面的换行符

    return 0;
}

#include <iostream>

int main() {
    int value;
    std::cout << "Enter numbers (non-number to quit): ";
    // 当 cin >> value 成功读取一个整数时，cin 状态良好，循环继续
    // 当输入非数字导致读取失败时，cin 进入 fail 状态，循环终止
    while (std::cin >> value) {
        std::cout << "You entered: " << value << std::endl;
        std::cout << "Enter next number: ";
    }
    std::cout << "Input terminated or failed." << std::endl;
    return 0;
}

#include <iostream>
#include <limits> // for numeric_limits

int main() {
    int number;
    std::cout << "Enter an integer: ";

    while (!(std::cin >> number)) { // 如果读取失败 (cin 返回 false)
        std::cout << "Invalid input. Please enter an integer: ";

        // 1. 清除错误状态
        std::cin.clear();

        // 2. 丢弃缓冲区中的错误输入
        // 读取并忽略直到下一个换行符或缓冲区结束的所有字符
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }

    std::cout << "You entered: " << number << std::endl;

    return 0;
}

#include <iostream>

int main() {
    char ch;
    std::cout << "Enter characters (Ctrl+D/Ctrl+Z to end):" << std::endl;

    // 使用 get(char&)
    while (std::cin.get(ch)) { // 读取成功则循环继续
        std::cout.put(ch); // 逐个输出读到的字符
    }
    std::cout << "\nEnd of input (using get(char&)).\n";

    std::cin.clear(); // 清除 eof 状态以便继续演示

    std::cout << "\nEnter characters again:" << std::endl;
    // 使用 int get()
    int char_code;
    while ((char_code = std::cin.get()) != EOF) {
        std::cout.put(static_cast<char>(char_code));
    }
     std::cout << "\nEnd of input (using int get()).\n";

    return 0;
}

#include <iostream>

int main() {
    char line1[50];
    char line2[50];

    std::cout << "Enter line 1: ";
    std::cin.getline(line1, 50); // 读取整行，丢弃换行符

    std::cout << "Enter line 2: ";
    std::cin.get(line2, 50); // 读取整行，换行符留在缓冲区

    std::cout << "Line 1: " << line1 << std::endl;
    std::cout << "Line 2: " << line2 << std::endl;

    // 检查 get() 之后缓冲区的内容
    char next_char;
    std::cout << "Character after get(): ";
    std::cin.get(next_char); // 读取留在缓冲区的换行符
    if (next_char == '\n') {
        std::cout << "'\\n'" << std::endl;
    } else {
        std::cout << "'" << next_char << "'" << std::endl;
    }

    return 0;
}

#include <iostream>
#include <limits>

int main() {
    char buffer[10];
    std::cout << "Enter some text (e.g., abcdefghij): ";
    std::cin.read(buffer, 5); // 读取 5 个字节到 buffer
    std::cout << "Read " << std::cin.gcount() << " bytes: ";
    std::cout.write(buffer, std::cin.gcount()) << std::endl; // 输出读取的内容

    char next = std::cin.peek(); // 查看下一个字符
    std::cout << "Next char (peek): '" << static_cast<char>(next) << "'" << std::endl;

    char actual_next;
    std::cin.get(actual_next); // 实际读取下一个字符
    std::cout << "Actual next char (get): '" << actual_next << "'" << std::endl;

    std::cin.putback(actual_next); // 将字符放回
    std::cin.get(actual_next); // 再次读取
    std::cout << "Read again after putback: '" << actual_next << "'" << std::endl;

    std::cout << "Ignoring rest of the line..." << std::endl;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 忽略到行尾

    std::cout << "Enter a final character: ";
    char final_char;
    std::cin >> final_char; // 现在可以读取新行的字符了
    std::cout << "Final char: " << final_char << std::endl;

    return 0;
}

#include <fstream> // 包含 fstream 头文件
#include <iostream>
#include <string>

int main() {
    // 1. 创建 ofstream 对象并通过构造函数关联文件
    // 默认以输出模式 (ios_base::out) 打开，如果文件存在则清空内容
    std::ofstream outFile("mydata.txt");

    // 2. 检查文件是否成功打开
    if (!outFile.is_open()) { // 或者 if (!outFile)
        std::cerr << "Error opening file for writing!" << std::endl;
        return 1;
    }

    // 3. 向文件写入数据 (类似 cout)
    std::string name = "Alice";
    int age = 25;
    double score = 95.5;

    outFile << "Name: " << name << std::endl;
    outFile << "Age: " << age << std::endl;
    outFile << "Score: " << score << std::endl;

    std::cout << "Data written to mydata.txt" << std::endl;

    // 4. 关闭文件 (可选，析构函数会自动调用)
    // outFile.close();

    return 0; // outFile 在这里离开作用域，析构函数调用 close()
}

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

int main() {
    // 1. 创建 ifstream 对象并关联文件
    // 默认以输入模式 (ios_base::in) 打开
    std::ifstream inFile("mydata.txt");

    // 2. 检查文件是否成功打开
    if (!inFile.is_open()) {
        std::cerr << "Error opening file for reading!" << std::endl;
        return 1;
    }

    std::cout << "Reading data from mydata.txt:" << std::endl;

    // 3. 从文件读取数据 (类似 cin)
    std::string line;
    // 逐行读取
    while (getline(inFile, line)) { // 使用全局 getline 读取整行到 string
        std::cout << line << std::endl;
    }

    // 或者，如果知道格式，可以像 cin 一样读取
    /*
    std::string label1, name, label2, label3;
    int age;
    double score;
    inFile >> label1 >> name >> label2 >> age >> label3 >> score;
    if (inFile) { // 检查读取是否成功
        std::cout << "Read Name: " << name << std::endl;
        std::cout << "Read Age: " << age << std::endl;
        std::cout << "Read Score: " << score << std::endl;
    } else {
        std::cerr << "Error reading data format." << std::endl;
    }
    */

    // 4. 关闭文件 (可选)
    // inFile.close();

    return 0;
}

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

int main() {
    std::ifstream sourceFile("input.txt");
    std::ofstream destFile("output.txt");

    if (!sourceFile.is_open()) {
        std::cerr << "Error opening input.txt" << std::endl;
        return 1;
    }
    if (!destFile.is_open()) {
        std::cerr << "Error opening output.txt" << std::endl;
        return 1; // sourceFile 会自动关闭
    }

    std::string line;
    while (getline(sourceFile, line)) {
        // 处理 line ...
        destFile << "Copied: " << line << std::endl; // 写入到目标文件
    }

    std::cout << "File copy finished." << std::endl;

    // sourceFile 和 destFile 会在 main 结束时自动关闭
    return 0;
}

int main(int argc, char *argv[]) {
    // ...
}

#include <fstream>
#include <iostream>
#include <string>
#include <vector> // 用于存储参数

int main(int argc, char *argv[]) {
    // 检查参数数量是否正确
    if (argc != 3) { // 需要程序名 + 输入文件名 + 输出文件名
        std::cerr << "Usage: " << argv[0] << " <input_file> <output_file>" << std::endl;
        return 1;
    }

    // argv[1] 是输入文件名, argv[2] 是输出文件名
    std::ifstream sourceFile(argv[1]);
    std::ofstream destFile(argv[2]);

    if (!sourceFile.is_open()) {
        std::cerr << "Error opening input file: " << argv[1] << std::endl;
        return 1;
    }
    if (!destFile.is_open()) {
        std::cerr << "Error opening output file: " << argv[2] << std::endl;
        return 1;
    }

    // ... (文件处理逻辑，例如复制) ...
    char ch;
    while (sourceFile.get(ch)) {
        destFile.put(ch);
    }

    std::cout << "Processed " << argv[1] << " to " << argv[2] << std::endl;

    return 0;
}

ofstream outFile;
outFile.open("config.cfg", ios_base::out | ios_base::trunc); // 显式指定覆盖写入

ifstream dataFile;
dataFile.open("image.bin", ios_base::in | ios_base::binary); // 以二进制读取模式打开

fstream ioFile;
// 以读写模式打开，如果不存在则创建，不清空内容
ioFile.open("log.dat", ios_base::in | ios_base::out | ios_base::binary);

#include <fstream>
#include <iostream>
#include <vector>

struct Record {
    int id;
    char name[20];
    double value;
};

int main() {
    const char* filename = "records.dat";
    const size_t recordSize = sizeof(Record);

    // --- 写入一些记录 ---
    std::ofstream outFile(filename, std::ios::out | std::ios::binary | std::ios::trunc);
    if (!outFile) { /* error check */ return 1; }

    std::vector<Record> records = {
        {1, "Rec A", 10.1},
        {2, "Rec B", 20.2},
        {3, "Rec C", 30.3},
        {4, "Rec D", 40.4}
    };
    for (const auto& rec : records) {
        outFile.write(reinterpret_cast<const char*>(&rec), recordSize);
    }
    outFile.close();

    // --- 随机读取和修改记录 ---
    std::fstream ioFile(filename, std::ios::in | std::ios::out | std::ios::binary);
    if (!ioFile) { /* error check */ return 1; }

    Record tempRec;

    // 1. 读取第三条记录 (索引为 2)
    long position = 2 * recordSize;
    ioFile.seekg(position, std::ios::beg); // 定位到第三条记录的开头
    if (ioFile.read(reinterpret_cast<char*>(&tempRec), recordSize)) {
        std::cout << "Read record at index 2: ID=" << tempRec.id << ", Name=" << tempRec.name << std::endl;
    } else {
        std::cerr << "Failed to read record at index 2." << std::endl;
    }

    // 2. 修改第二条记录 (索引为 1)
    if (ioFile.good()) { // 确保流状态良好
        position = 1 * recordSize;
        ioFile.seekp(position, std::ios::beg); // 定位输出指针到第二条记录开头

        // 读取原始记录 (可选，如果需要基于原始值修改)
        // ioFile.seekg(position, std::ios::beg);
        // ioFile.read(reinterpret_cast<char*>(&tempRec), recordSize);

        // 准备新数据并写入
        Record updatedRec = {2, "Record B Updated", 25.5};
        ioFile.write(reinterpret_cast<const char*>(&updatedRec), recordSize);

        if (ioFile.fail()) {
            std::cerr << "Failed to write updated record at index 1." << std::endl;
        } else {
             std::cout << "Updated record at index 1." << std::endl;
        }
    }

    // 3. 获取文件大小
    ioFile.seekg(0, std::ios::end); // 定位到文件末尾
    long fileSize = ioFile.tellg(); // 获取当前位置 (即文件大小)
    std::cout << "File size: " << fileSize << " bytes." << std::endl;
    std::cout << "Number of records: " << fileSize / recordSize << std::endl;

    ioFile.close();

    return 0;
}

#include <sstream> // 包含 sstream 头文件
#include <iostream>
#include <string>
#include <iomanip> // for setprecision, fixed

int main() {
    // 1. 创建 ostringstream 对象
    std::ostringstream oss;

    // 2. 向流中插入数据并格式化
    std::string item = "Gadget";
    int quantity = 3;
    double price = 12.99;
    double total = quantity * price;

    oss << "Item: " << item << "\n"; // 插入字符串和换行符
    oss << "Quantity: " << quantity << "\n";
    oss << "Price: $" << std::fixed << std::setprecision(2) << price << "\n"; // 格式化浮点数
    oss << "Total: $" << total; // 格式化设置是粘性的

    // 3. 获取格式化后的字符串
    std::string formatted_string = oss.str();

    // 4. 输出或使用该字符串
    std::cout << "--- Formatted Output String ---" << std::endl;
    std::cout << formatted_string << std::endl;
    /* Output:
       Item: Gadget
       Quantity: 3
       Price: $12.99
       Total: $38.97
    */

    // ostringstream 对象可以重用，但内容会继续累加
    // oss << "\nAnother line.";
    // std::cout << "\nAfter adding more:\n" << oss.str() << std::endl;

    // 如果要清空并重用，可以调用 str("") 或重新构造
    oss.str(""); // 清空缓冲区
    oss.clear(); // 清除可能存在的流状态 (虽然这里通常不需要)
    oss << "New content.";
    std::cout << "\nAfter clearing and adding:\n" << oss.str() << std::endl; // Output: New content.

    return 0;
}

#include <sstream>
#include <iostream>
#include <string>
#include <vector>

int main() {
    std::string data = "Alice 30 95.5"; // 模拟一行数据
    std::string config_line = "window_width = 800";
    std::string csv_data = "10,20,30,40";

    // 1. 解析空格分隔的数据
    std::istringstream iss1(data);
    std::string name;
    int age;
    double score;

    if (iss1 >> name >> age >> score) { // 尝试提取
        std::cout << "Parsed from data: Name=" << name << ", Age=" << age << ", Score=" << score << std::endl;
    } else {
        std::cerr << "Failed to parse data string." << std::endl;
    }

    // 2. 解析配置文件行
    std::istringstream iss2(config_line);
    std::string key, eq;
    int value;
    if (iss2 >> key >> eq >> value && key == "window_width" && eq == "=") {
        std::cout << "Parsed config: Key=" << key << ", Value=" << value << std::endl;
    } else {
         std::cerr << "Failed to parse config line." << std::endl;
    }

    // 3. 解析逗号分隔的数据 (需要手动处理分隔符)
    std::istringstream iss3(csv_data);
    std::vector<int> numbers;
    int num;
    char comma;
    while (iss3 >> num) { // 读取一个数字
        numbers.push_back(num);
        if (iss3 >> comma && comma == ',') { // 读取并检查逗号
            continue; // 如果有逗号，继续循环
        } else {
            break; // 如果没有逗号或读取失败，结束循环
        }
    }
    // 检查流状态，确保是因为到达末尾而不是其他错误
    if (!iss3.eof() && iss3.fail() && !iss3.bad()) {
         // 可能最后一个数字后面没有逗号，这是正常的
    } else if (!iss3.eof()) {
        std::cerr << "Error parsing CSV data." << std::endl;
    }

    std::cout << "Parsed CSV numbers: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;


    return 0;
}

#include <sstream>
#include <iostream>
#include <string>

int main() {
    std::stringstream ss;

    // 1. 写入数据到 stringstream
    int val1 = 10;
    double val2 = 3.14;
    ss << "Data: " << val1 << " " << val2;

    // 2. 从同一个 stringstream 读取数据
    std::string label;
    int read_val1;
    double read_val2;

    // 在读取之前，通常不需要显式重置位置，因为写入指针和读取指针是独立的
    // 但如果写入后立即读取，读取指针仍在开头

    if (ss >> label >> read_val1 >> read_val2) {
        std::cout << "Read from stringstream: Label=" << label
                  << ", Val1=" << read_val1 << ", Val2=" << read_val2 << std::endl;
    } else {
        std::cerr << "Failed to read from stringstream." << std::endl;
    }

    // 3. 清空并重用，先读取后写入
    ss.str("100 Hello"); // 设置新的内容，并重置读写位置
    ss.clear(); // 清除 EOF 或其他状态

    int num;
    std::string word;
    ss >> num >> word; // 读取 100 和 "Hello"

    // 写入新内容 (会覆盖或追加，取决于实现和指针位置，通常是覆盖)
    // 为了安全地追加，最好先获取当前内容，追加后再设置回去，或者使用 ostringstream
    std::string current_content = ss.str(); // 获取 "100 Hello"
    ss.str(""); // 清空
    ss.clear();
    ss << current_content << " World " << num * 2; // 写入旧内容、新内容和计算结果

    std::cout << "Final stringstream content: " << ss.str() << std::endl;
    // Output: 100 Hello World 200

    return 0;
}