c ++中的非静态块

Question

C++中是否存在非静态块？

如果不是,如何优雅地模仿它？

我想替换类似的东西: -

class C{
    public: void ini(){/* some code */}
};
class D{
    std::vector<C*> regis; //will ini(); later
    public: C field1; 
    public: C field2;  
    public: C field3;             //whenever I add a new field, I have to ... #1
    public: D(){
        regis.push_back(&field1);
        regis.push_back(&field2);
        regis.push_back(&field3); //#1 ... also add a line here
    }
    public: void ini(){
        for(auto ele:regis){
            ele->ini();
        }
    }
};

与: -

class D{
    std::vector<C*> regis;                        
    public: C field1;{regis.push_back(&field1);}//less error-prone (because it is on-site)
    public: C field2;{regis.push_back(&field2);}
    public: C field3;{regis.push_back(&field3);}
    public: D(){    }  //<-- empty
    public: void ini(){
        for(auto ele:regis){
            ele->ini();
        }
    }
};

我在C++中发现了许多与static-block相关的问题,但没有发现任何关于非静态块的问题.

为了便于回答,这是一个完整的代码.

它可以使用X-MACRO(wiki链接)完成,但我试图避免它.

编辑

在实际情况中,fieldX可以有任何来自某个类型的类型C.

我认为另一个不好的解决方法: -

class D{
    std::vector<C*> regis;     
    char f(C& c){   regis.push_back(&c); return 42;}                 
    public: C field1; char dummyWaste1=f(field1);
    public: C field2; char dummyWaste2=f(field2);
    public: C field3; char dummyWaste3=f(field3);

Edit2(赏金原因)

skypjack的答案非常有用,但我很想知道更多的选择.
最终目标是模拟具有更多变化的一般非静态块.
换句话说,如果新的解决方案可以解决这个问题会很好: -

class D{
    int field1=5;
    { do something very custom; /* may access field1 which must = 5 */}
    //^ have to be executed after "field1=5;" but before "field2=7"
    int field2=7;
    int field3=8;
    { do something very custom ; /* e.g. "field1=field2+field3" */}
    //^ have to be executed after "field3=8;"
};

不会char为每个块浪费1 (或更多 - 用于对齐).

Answer 1

如何优雅地模仿它？

您可以regis直接初始化:

std::vector<C*> regis = { &field1, &field2, &field3 };

也就是说,将您的类定义为:

class D{
public:
    C field1;
    C field2;
    C field3;

    void ini(){
        for(auto ele:regis){
            ele->ini();
        }
    }

private:
    std::vector<C*> regis = { &field1, &field2, &field3 };
};

否则,如果您可以添加构造函数C,则还原逻辑并将其自身添加到向量:

#include<vector>

struct C {
    C(std::vector<C*> &vec) {
        vec.push_back(this);
        // ...
    }

    void ini() {}
};

class D{
    std::vector<C*> regis{};

public:
    C field1 = regis;
    C field2 = regis;
    C field3 = regis;

    void ini(){
        for(auto ele:regis){
            ele->ini();
        }
    }
};

int main() { D d{}; d.ini(); }

------编辑------

按照评论的要求:

C对我来说是一个神圣的课程.是不是可以破解C？

这是一个可能的替代方案,不需要您修改C:

#include<vector>

struct C {
    void ini() {}
};

struct Wrapper {
    Wrapper(std::vector<C*> &vec) {
        vec.push_back(*this);
        // ...
    }

    operator C *() { return &c; }

private:
    C c;
};

class D{
    std::vector<C*> regis{};

public:
    Wrapper field1{regis};
    Wrapper field2{regis};
    Wrapper field3{regis};

    void ini(){
        for(auto ele:regis){
            ele->ini();
        }
    }
};

int main() { D d{}; d.ini(); }