C++结构体与类方法结合使用策略

Point

x

y

x

y

getX()

getY()

// 传统的类方式，可能显得有点重
class PointClass {
private:
    double x_;
    double y_;
public:
    PointClass(double x = 0.0, double y = 0.0) : x_(x), y_(y) {}
    double getX() const { return x_; }
    double getY() const { return y_; }
    void move(double dx, double dy) { x_ += dx; y_ += dy; }
    double distanceTo(const PointClass& other) const; // 声明，实现略
};

// 结构体与方法结合的方式，更简洁直观
struct PointStruct {
    double x;
    double y;

    // 构造函数，赋予初始化能力
    PointStruct(double x_val = 0.0, double y_val = 0.0) : x(x_val), y(y_val) {}

    // 成员函数，直接操作数据
    void move(double dx, double dy) {
        x += dx;
        y += dy;
    }

    // 常量成员函数，不修改数据
    double distanceTo(const PointStruct& other) const {
        double dx = x - other.x;
        double dy = y - other.y;
        return std::sqrt(dx*dx + dy*dy);
    }

    // 甚至可以有操作符重载
    PointStruct operator+(const PointStruct& other) const {
        return PointStruct(x + other.x, y + other.y);
    }
};

// 使用示例
// PointClass p1(1.0, 2.0);
// p1.move(0.5, -0.5);
// std::cout << p1.getX() << ", " << p1.getY() << std::endl;

// PointStruct p2(1.0, 2.0);
// p2.move(0.5, -0.5);
// std::cout << p2.x << ", " << p2.y << std::endl; // 直接访问，清晰明了
// PointStruct p3 = p2 + PointStruct(0.1, 0.1);

PointStruct

x

y

move

distanceTo

struct

class

struct

public

class

private

struct

class

class

private

struct

class

#include <iostream>
#include <cmath> // For std::sqrt

struct EmptyStruct {
    // 没有任何数据成员
    void doNothing() {}
};

struct PointWithMethod {
    double x;
    double y;

    void move(double dx, double dy) {
        x += dx;
        y += dy;
    }

    double distanceToOrigin() const {
        return std::sqrt(x*x + y*y);
    }
};

struct PointWithVirtualMethod {
    double x;
    double y;

    virtual void virtualMove(double dx, double dy) { // 虚函数
        x += dx;
        y += dy;
    }
    virtual ~PointWithVirtualMethod() = default; // 虚析构函数也需要vptr
};

int main() {
    std::cout << "sizeof(EmptyStruct): " << sizeof(EmptyStruct) << std::endl;
    std::cout << "sizeof(PointWithMethod): " << sizeof(PointWithMethod) << std::endl;
    std::cout << "sizeof(PointWithVirtualMethod): " << sizeof(PointWithVirtualMethod) << std::endl;
    return 0;
}

sizeof(EmptyStruct): 1

sizeof(PointWithMethod): 16

double

sizeof(PointWithVirtualMethod): 24

double

vptr

vptr

this

vptr

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept> // For std::runtime_error

// 一个简单的文件写入器结构体
struct FileWriter {
    std::ofstream file_stream; // 成员变量，用于管理文件资源
    std::string filename;

    // 构造函数：获取资源（打开文件）
    FileWriter(const std::string& fname) : filename(fname) {
        file_stream.open(filename, std::ios_base::out | std::ios_base::app); // 以追加模式打开
        if (!file_stream.is_open()) {
            throw std::runtime_error("Failed to open file: " + filename);
        }
        std::cout << "File '" << filename << "' opened successfully." << std::endl;
    }

    // 析构函数：释放资源（关闭文件），即使发生异常也会调用
    ~FileWriter() {
        if (file_stream.is_open()) {
            file_stream.close();
            std::cout << "File '" << filename << "' closed successfully." << std::endl;
        }
    }

    // 禁用拷贝构造和拷贝赋值，因为文件句柄通常不适合简单拷贝
    // 除非你实现深拷贝逻辑，但对于文件流，通常是移动语义
    FileWriter(const FileWriter&) = delete;
    FileWriter& operator=(const FileWriter&) = delete;

    // 启用移动构造和移动赋值
    FileWriter(FileWriter&& other) noexcept
        : file_stream(std::move(other.file_stream)), filename(std::move(other.filename)) {
        std::cout << "FileWriter moved from '" << other.filename << "' to '" << filename << "'" << std::endl;
    }

    FileWriter& operator=(FileWriter&& other) noexcept {
        if (this != &other) {
            if (file_stream.is_open()) {
                file_stream.close();
            }
            file_stream = std::move(other.file_stream);
            filename = std::move(other.filename);
        }
        return *this;
    }


    // 成员函数：操作资源（写入数据）
    void writeLine(const std::string& line) {
        if (file_stream.is_open()) {
            file_stream << line << std::endl;
            if (file_stream.fail()) {
                throw std::runtime_error("Failed to write to file: " + filename);
            }
        } else {
            throw std::runtime_error("File '" + filename + "' is not open for writing.");
        }
    }

    // 其他辅助方法，比如刷新缓冲区
    void flush() {
        if (file_stream.is_open()) {
            file_stream.flush();
        }
    }
};

void processData(const std::string& output_file) {
    try {
        FileWriter writer(output_file); // 资源获取：文件打开
        writer.writeLine("First line of data.");
        writer.writeLine("Second line with some numbers: " + std::to_string(123));
        // writer.flush(); // 可以手动刷新
    } catch (const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    // writer对象超出作用域时，析构函数自动调用，文件关闭
}

int main() {
    processData("log.txt");
    std::cout << "\n--- Another attempt (will fail to open) ---\n";
    // 尝试打开一个不存在且无法创建的文件路径，或权限不足
    // processData("/nonexistent/path/invalid.txt"); // 假设这个路径无法创建
    return 0;
}

FileWriter

processData

writer.writeLine

FileWriter