C++中有非静态 block 吗？

如果不是，如何优雅地模拟？

我想替换像这样的东西:-

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 相关的问题，但没有找到任何关于 non-static-block 的问题。

为了方便回答，这里是a full code .

可以使用 X-MACRO (wiki link) 来完成，但我试图避免它。

编辑

在实际情况下，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 的回答非常有用，但我很想找到更多替代方案。
最终目标是模拟具有更多多样性的通用非静态 block 。
换句话说，如果新的解决方案可以解决这个问题就好了:-

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;"
};

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

最佳答案

how to emulate it elegantly?

可以直接初始化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 添加构造函数，则还原逻辑并将其自身添加到 vector 中:

#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 is a holy class for me. Is it possible to not hack 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(); }

关于c++ - 我可以在类定义中放置 "non-static blocks"代码吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43649375/