你可以通过把你的配置放在同一个类中其他变量之前并从它初始化来解决这个问题。构造之后你可以“重置”它以释放内存。下面是一个概念性的例子：

#include <iostream>
#include <memory>

class A {
    struct Config {
        Config(int a, int b) : a(a), b(b) {}
        int a;
        int b;
    };
    std::unique_ptr<Config> tmp;
public:
    const int x = tmp->a;
    const int y = tmp->b;
    A(const std::string& path) : tmp(read_config(path)) {
        tmp.reset();
    }

    std::unique_ptr<Config> read_config(const std::string& path) {
        return std::make_unique<Config>(1, 2);
    }
};

int main()
{
    A a("");
    std::cout << a.x << " , " << a.y << std::endl;
}

考虑使用Builder design pattern：

class Builder{
public:
    //the parameters
    int _a, _b;

    Builder(string filename){
        // read _a and _b from config file
    }
    YourClass getObject(){
        return YourClass(_a, _b)
    }
}

class YourClass{
public:
    YourClass(int _a, int _b):a(_a), b(_b){}
private:
    const int _a;
    const int _b;
}

然后你可以在一行中示例化你的类对象：

YourClass c = Builder(filename).getObject();

你可以从类成员和基类的初始化顺序规则中获益。也就是说，基类部分按照它们在继承列表中的顺序初始化，然后成员按照它们声明的顺序初始化。
因此，第一种选择是：

class vec {
public:
    vec() { /* read and process config*/ }
    int x, y;
};

class A {
    vec c;
public:
    const int x;
    const int y;

public:
    A() : x(c.x), y(c.y) {}
};

这将在config和你的类型之间给予必要的分离。
或使用基类：

struct vec {
    int x, y;
};

class Config {
protected:
    vec c;
public:
    Config() { /* read and process config */ }
};

class A : Config {
public:
    const int x;
    const int y;

    A() : x(c.x), y(c.y) {}
};

这给出了更好的类别分离。