C ++中的默认与隐式构造函数

问题描述

这是非常微不足道的，但捷克语（我的本地）不区分隐含和默认，所以我感到困惑的一些捷克翻译隐含和默认构造函数或构造函数调用之间的区别。

  c 测试并复制 t3 。这将使用 Test（int）构造函数进行转换，然后使用隐式定义的（和构造函数。注意：编译器可以优化拷贝，但必须验证拷贝构造函数是否可用（访问说明符）并可以定义。
  Test t4（4）; 
  
使用 Test（int）构造函数， 
 测试t5 =测试（5） ; 
  
等效于 Test t3 = 3  ，唯一的区别是在这种情况下从 5 到 Test 的转换是显式的。在这个例子中它没有关系，但如果构造函数被标记为 explicit ，这行将编译而 t3  
 
 
在代码中未明确请求从 3 到 Test 的转换。与 t5 进行比较，其中转换由程序员明确请求： Test（5）。
 
This is very trivial, but Czech language (my native) doesn't distinguish between implicit and default, so I am confused by some Czech translations what is the difference between implicit and default constructor or constructor call.
struct Test {
  Test(int n=0) { }
};
Can you describe in these terms what is:
Test t1;
Test t2();
Test t3 = 3;
Test t4(4);
Test t5 = Test(5);
?
 解决方案 
The terms default and implicit, when talking about a constructor have the following meaning:
default constructor is a constructor that can be called with no arguments. It either takes no arguments or has default values for each of the arguments taken.
implicit constructor is a term commonly used to talk about two different concepts in the language, the
implicitly declared constructor which is a default or copy constructor that will be declared for all user classes if no user defined constructor is provided (default) or no copy constructor is provided (copy). That is, a class with no constructors declared by the user has one default constructor implicitly declared.
implicitly defined constructor is a implicitly declared constructor that is used (odr-used in the language and for which the compiler will provide a definition.
struct test
{
    test(int i = 0) { }
    // test(test const&) implicitly declared here
};

struct test2 { };      // implicitly declared: test2(), test2(test2 const&)

int main()
{
    test t;

    test copy(t);      // causes *definition* of the implicitly
                       // declared copy constructor

    test2 t2;          // causes *definition* of test2::test2()

    test2 copy2(t2);   // causes *definition* of test2::test2(test2 const&)
}
In simple terms, a constructor is default if it can be called with no arguments. A constructor is implicit(ly declared/defined) if it is not provided by the user but declared/defined.
As of the specific cases:
Test t1;
Uses the default constructor, Test(int = 0), which is not implicit.
Test t2();
This is a strange quirk of the language, it declares a function that takes no arguments and returns a Test object.
Test t3 = 3;
This is called copy-initialization and is equivalent to the composition of an implicit conversion from 3 to Test and copy construction of t3 from the result of the conversion. This will use the Test(int) constructor for the conversion, and then the implicitly defined (and declared) copy constructor. Note: the compiler can optimize away the copy, but it must verify that the copy constructor is available (access specifiers) and can be defined.
Test t4(4);
Uses the Test(int) constructor, which in this case is not acting as a default constructor.
Test t5 = Test(5);
Equivalent to the Test t3 = 3 case, with the only difference that the conversion from 5 to Test is explicit in this case. In this example it won't matter, but if the constructor had been marked as explicit this line would compile while the t3 case would fail.
*) Yet another use of implicit, in this case referring to the fact that the conversion from 3 to Test is not explicitly requested in the code. Compare this with t5 where the conversion is explicitly requested by the programmer: Test(5).
                        
这篇关于C ++中的默认与隐式构造函数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！