例如,如果构造函数需要迭代int i,那么在构造函数完成后是否会销毁此变量,或者它是否为程序的全局变量？

这是代码中的样子：

if (my_boolean){
    MyClass my_object(arg1); //calling a first constructor
}
else {
    MyClass my_object(arg1,arg2); //calling another constructor
}
//more code using my_object

到目前为止,我尝试使用static关键字但没有成功.是否存在有条件地使用不同构造函数而不必重新定义构造函数的常用方法？

MyClass my_object = my_boolean ? MyClass(arg1) : MyClass(arg1,arg2);

考虑到即使该类没有默认构造函数,此代码也能正常工作.

这是一个示范性的例子

#include <iostream> 
#include <cstdlib>
#include <ctime>

int main () 
{
    struct Point
    {
        Point( int x ) : x( x ) {}
        Point( int x,int y ) : x( x ),y( y ) {}
        int x = 0;
        int y = 0;
    };

    std::srand( ( unsigned )std::time( 0 ) );

    Point p = std::rand() % 2 ? Point( 1 ) : Point( 1,2 );

    std::cout << "p.x = " << p.x << ",p.y = " << p.y << std::endl;  

    return 0; 
}

我得到了以下输出

p.x = 1,p.y = 2

你得到了什么输出？

#include <iostream>

using namespace std;

struct Test
{
    test() {cout << "Test::test()" << "\n";}
    void dummy(){}
};

template<typename T>
struct Message
{
    Message()
    {
        test.dummy(); // this call have to be here in order to initialize Test,but why?
    }

    static Test test;
};

template<typename T>
Test Message<T>::test;

struct A : public Message<A>
{
    //A(){} // uncomment this (and comment the default one) to call the Test constructor
    A() = default;
};

int main()
{
}

这就是发生的事情：

>程序本身是空的,即没有创建实例.
> A类有一个CRTP,这似乎对这个例子至关重要.
> A的基数有一个静态声明,我期待它的构造函数被调用.
>对函数进行虚拟调用,什么都不做,但也很关键.

问题是如果我不提供自定义构造函数,那么静态构造函数永远不会被调用.我无法理解为什么需要这个？与默认或编译器生成的有什么区别？为什么我需要调用虚函数？

我相信这是有规则的.我用不同版本的gcc和clang检查了它 – 行为是一样的.我非常感谢标准/文档的链接.

12.1 Constructors [class.ctor]

7
A default constructor that is defaulted and not defined as deleted is implicitly defined when it is odr-used (3.2) to create an object of its class type (1.8) or when it is explicitly defaulted after its first declaration.

struct A : public Message<A>
{
    A() = default; // no constructor is emitted unless A is instantiated

    A(); // declaration
};

A::A() = default; // explicit default deFinition

int
main()
{
    A a; // instantiation
    A::test; // just explicitly access test so it is initialized regardless of A constructor
}