类内部结构体的修改：当前写法是否合规？是否需用指针？

首先给你吃个定心丸：你通过成员函数func()修改类内部结构体的方式完全恰当，而且根本不需要借助指针——直接访问类的成员变量就是最直接高效的方式，指针在这里纯属多余。

关于修改内部结构体的合理性 #

你的代码里，Mystruct是类的public成员，func()作为成员函数直接修改它的字段是完全符合C++语法和面向对象逻辑的。成员函数本来就是用来操作类内部状态的，这种写法没有问题。

但如果追求更规范的封装性，我建议你调整一下结构：把Mystruct放到private区域，然后提供公共的getter方法（比如返回const引用，或者单独返回a、b的值）。这样外部代码只能读取结构体的数据，不能直接修改它，避免了外部意外破坏类的内部状态。比如可以改成这样：

#include <iostream>

class Someclass {
private:
    int Integer;
    struct Somestruct {
        int a, b;
    };
    Somestruct Mystruct; // 私有化，外部不能直接访问

public:
    Someclass(int i): Integer(i) {
        update_struct(); // 构造时直接初始化结构体，不需要单独调用func()
    }

    // 提供getter方法，返回不可修改的引用
    const Somestruct& get_struct() const {
        return Mystruct;
    }

    // 如果需要单独获取字段
    int get_a() const { return Mystruct.a; }
    int get_b() const { return Mystruct.b; }

private:
    // 内部更新结构体的方法，私有化避免外部随意调用
    void update_struct() {
        Mystruct.a = Integer / 2;
        Mystruct.b = Integer * 2;
    }
};

int main() {
    Someclass A(10);
    // 通过getter访问
    const auto& my_struct = A.get_struct();
    std::cout << my_struct.a << " " << my_struct.b << std::endl;
}

关于文件解析场景的适用性 #

你的核心需求是解析文件，从包含‘Integer’的行提取数据，填充到结构体并对外提供，这个思路是可行的，但当前的代码只是简化版，实际落地时需要注意几个点：

1. 类的定义位置：你把Someclass定义在了main()函数内部，虽然C++允许局部类，但这种类只能在当前函数内部使用，无法复用。建议把类定义移到全局作用域或者命名空间下，方便其他代码调用。
2. 解析逻辑的封装：应该把文件读取、解析的逻辑写到类的成员函数里（比如parse_file(const std::string& filename)），而不是通过构造函数传值。比如在parse_file里打开文件，逐行读取，找到包含"Integer"的行，提取数值赋值给Integer，然后调用更新结构体的方法。
3. 错误处理：文件解析过程中可能出现各种错误（比如文件打不开、格式错误），类应该提供错误反馈机制（比如返回布尔值表示是否解析成功，或者抛出异常）。

举个简化的解析版本示例：

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

class FileParser {
private:
    int integer_value = 0;
    struct ParsedData {
        int a, b;
    };
    ParsedData parsed_data;
    bool parse_success = false;

    void update_parsed_data() {
        parsed_data.a = integer_value / 2;
        parsed_data.b = integer_value * 2;
    }

public:
    // 解析文件的方法
    bool parse_file(const std::string& filename) {
        std::ifstream file(filename);
        if (!file.is_open()) {
            std::cerr << "Failed to open file: " << filename << std::endl;
            return false;
        }

        std::string line;
        while (std::getline(file, line)) {
            if (line.find("Integer") != std::string::npos) {
                // 假设行格式是 "Integer: 10" 这样的，提取数值
                std::istringstream iss(line);
                std::string key;
                int value;
                if (iss >> key >> value) {
                    integer_value = value;
                    update_parsed_data();
                    parse_success = true;
                    return true; // 找到目标行就退出，按需调整逻辑
                } else {
                    std::cerr << "Invalid format in line: " << line << std::endl;
                    return false;
                }
            }
        }

        std::cerr << "No line containing 'Integer' found in file" << std::endl;
        return false;
    }

    // 获取解析结果的前置判断
    bool is_parse_successful() const { return parse_success; }
    const ParsedData& get_parsed_data() const { return parsed_data; }
};

int main() {
    FileParser parser;
    if (parser.parse_file("data.txt")) {
        const auto& data = parser.get_parsed_data();
        std::cout << "Parsed a: " << data.a << ", b: " << data.b << std::endl;
    } else {
        std::cerr << "Parsing failed" << std::endl;
    }
    return 0;
}

总结 #

• 你最初的修改方式是正确的，不需要指针；
• 追求规范的话，优先考虑封装，把内部结构体私有化，通过getter暴露数据；
• 针对文件解析场景，把解析逻辑封装到类里，处理好错误情况，类的定义不要放在函数内部。

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