C++中如何实现结构体部分成员仅类内可修改的代码规范

1. 友元类（Friend Class） #

直接将Renderer声明为Triangle的友元，让Triangle保持完整结构体的同时，仅开放buffer成员给Renderer访问。这是最直接的方案，代码改动小且可读性高。

#include <vector>

// 假设已定义vec2、mat2、Material类型
struct vec2 {};
struct mat2 {};
struct Material {};

struct Triangle {
    // 所有作用域可修改的公开成员
    vec2 A, B, C, position;
    mat2 transform;
    Material material;

private:
    int buffer; // 仅Renderer可修改
    friend class Renderer; // 授予Renderer访问权限
};

class Renderer {
private:
    std::vector<Triangle> triangles;
    std::vector<GLuint> buffers;

public:
    // 示例：为指定Triangle设置buffer索引
    void assignTriangleBuffer(size_t triIdx, size_t bufIdx) {
        triangles[triIdx].buffer = static_cast<int>(bufIdx);
    }
};

2. 标签式访问控制（Tag-based Access） #

通过私有构造的标签类限制buffer的修改权限，无需将Renderer设为友元，更符合接口隔离原则。外部代码无法创建标签，只有Renderer能调用带标签的修改接口。

#include <vector>

struct vec2 {};
struct mat2 {};
struct Material {};

namespace detail {
    // 仅Renderer能实例化的标签类
    struct RendererTag {
    private:
        RendererTag() = default;
        friend class Renderer;
    };
}

struct Triangle {
    vec2 A, B, C, position;
    mat2 transform;
    Material material;

    // 仅持有RendererTag的调用者可修改buffer
    void setBuffer(int bufIndex, detail::RendererTag) {
        buffer = bufIndex;
    }

    // 若需内部读取，可添加带标签的getter
    int getBuffer(detail::RendererTag) const {
        return buffer;
    }

private:
    int buffer;
};

class Renderer {
private:
    std::vector<Triangle> triangles;
    std::vector<GLuint> buffers;

public:
    void assignTriangleBuffer(size_t triIdx, size_t bufIdx) {
        triangles[triIdx].setBuffer(static_cast<int>(bufIdx), detail::RendererTag{});
    }
};

3. 内部嵌套结构体（Nested Struct） #

将公开数据与内部管理数据拆分，Renderer内部使用包含buffer的完整结构体，对外暴露仅含公开成员的数据结构体。适合需要完全隐藏buffer存在的场景。

#include <vector>

struct vec2 {};
struct mat2 {};
struct Material {};

// 对外公开的Triangle数据结构体，所有作用域可修改
struct TriangleData {
    vec2 A, B, C, position;
    mat2 transform;
    Material material;
};

class Renderer {
private:
    // 内部使用的完整Triangle，包含公开数据和buffer
    struct Triangle {
        TriangleData data;
        int buffer;
    };

    std::vector<Triangle> triangles;
    std::vector<GLuint> buffers;

public:
    // 对外提供访问公开数据的接口
    TriangleData& getTriangleData(size_t triIdx) {
        return triangles[triIdx].data;
    }

    void assignTriangleBuffer(size_t triIdx, size_t bufIdx) {
        triangles[triIdx].buffer = static_cast<int>(bufIdx);
    }
};

结合你“一个缓冲区对应多个三角形”的需求，友元类方案是最优选择：

• 无需拆分Triangle结构体，保持数据聚合性，代码可读性不受影响；
• 实现成本极低，仅需添加friend class Renderer声明；
• Renderer可以高效地批量为多个三角形设置同一buffer索引，符合你的业务逻辑。

如果希望避免友元带来的耦合，标签式访问控制是更优雅的替代方案，它通过接口而非类间友元关系实现权限控制，扩展性更好。

内容的提问来源于stack exchange，提问作者gdor11