我可以在 C++ 中的对象声明中自动调用 class 的方法吗?

Can I automatically call a method of a class on object declaration in C++?

假设我有一个 class 具有私人设置功能。有没有办法在我声明这个 class 的对象时自动调用该函数?

bus.h:

class BUS
{
  private:
    void setup();
  public:
    void someOtherFunction(); 
};

main.cpp:

BUS bus; //automatically call setup() here
bus.someOtherFunction();

这就是构造函数的用途。如果在创建对象时应始终调用 setup(),那么我们将使用构造函数调用 setup(),这样它就可以在没有任何用户干预的情况下完成。

class BUS
{
  private:
    void setup();
  public:
    Bus() { setup(); }
    void someOtherFunction(); 
};

现在 BUS bus; 将调用 setup()

你只需要一个构造函数:

class BUS
{
private:
void setup(){cout<<"Setup"<<endl;};
public:
BUS() // constructor
{
setup();  
}
void someOtherFunction(){cout<<"Something"<<endl;};
};

您可以通过以下方式验证:

BUS bus; // will print Setup

只需将您的设置方法放在默认构造函数中,如果您需要在任何其他构造函数中调用它;使用构造函数初始化列表:

class myclass{
    public:
        myclass(){ std::cout << "setup part" << std::endl; }
        myclass(int x): myclass(){ /* calls myclass() first */ }
};

int main(int argc, char *argv[]){
    myclass c0; // prints "setup part"
    myclass c1{5}; // also prints "setup part"
}

这是最惯用的方法。


如果需要延迟初始化;我喜欢使用带标记的构造函数和初始化方法:

struct no_init_tag{};
no_init_tag no_init;

class myclass{
    public:
        myclass(int x){ init(x); }
        myclass(no_init_tag){}

        void init(int arg){ std::cout << "init with " << arg << std::endl; }
};

int main(int argc, char *argv[]){
    myclass c0{5}; // prints "init with 5"

    myclass c1{no_init}; // doesn't print
    int n = 0;
    // set 'n' somehow
    c1.init(n); // prints "init with " then 'n'
}

这使得不需要使用动态内存进行延迟初始化,但仍然可以做到。

Google C++ style guide也很有用,你读起来可能会感兴趣。来自 doing work in constructors section:

In general, constructors should merely set member variables to their initial values. Any complex initialization should go in an explicit Init() method. Doing work in constructors will have problems in some particular case, so if your object requires non-trivial initialization, consider having an explicit Init() method. In particular, constructors should not call virtual functions, attempt to raise errors, access potentially uninitialized global variables, etc.