C + + Explicit keywords

Translated from: http://www.cnblogs.com/ymy124/p/3632634.html

First, the explicit keyword in C + + can only be used to decorate a class constructor that has only one argument, which is to show that the constructor is displayed, not implicitly, and that another keyword corresponding to it is implicit, meaning hidden, The class constructor is declared by default as implicit (implicit).

So what's the difference between a declared constructor and an implicit declaration? Let's take a look at the following example:

2. Class Cxstring //is not declared with the explicit keyword, which is implicitly declared by default
4. {
6. Public
8. Char *_pstr;
10. int _size;
12. cxstring (int size)
14. {
16. _size = size; //The preset size of string
18. _PSTR = malloc (size + 1); //Allocate a string of memory
20. memset (_pstr, 0, size + 1);
22. }
24. Cxstring (const char *p)
26. {
28. int size = strlen (p);
30. _PSTR = malloc (size + 1); //Allocate a string of memory
32. strcpy (_PSTR, p); //Copy string
34. _size = strlen (_PSTR);
36. }
38. //destructors are not discussed here, omitted ...
40. };
44. //The following is called:
48. Cxstring string1 (24); //This is OK, pre-allocating 24 bytes of memory for cxstring
50. cxstring string2 = 10; //This is OK, pre-allocating 10 bytes of memory for cxstring
52. Cxstring String3; //This is not possible, because there is no default constructor, the error is: "cxstring": there is no appropriate default constructor available
54. Cxstring String4 ("AAAA"); //This is OK.
56. cxstring string5 = "BBB"; //This is also OK, the call is cxstring (const char *p)
58. cxstring String6 = ' C '; //This is OK, in fact, the call is cxstring (int size), and size equals ' C ' ASCII code
60. string1 = 2; //This is OK, pre-allocating 2 bytes of memory for cxstring
62. string2 = 3; //This is OK, pre-allocating 3 bytes of memory for cxstring
64. String3 = string1; //This is OK, at least compile is not a problem, but if the destructor with free to release _pstr memory pointers may be error, the complete code must overload operator "=", and in which to handle memory release

In the above code, "cxstring string2 = 10;" Why is this sentence possible? In C + +, if the constructor has only one parameter, there is a default conversion operation at compile time: Convert the data of that constructor's data type to that class object. That is, "cxstring string2 = 10;" This code, the compiler automatically converts an integral type to a Cxstring class object, which is actually equivalent to the following operation:

1. Cxstring string2 (10);
2. Or
3. Cxstring Temp (10);
4. cxstring string2 = temp;

However, the _size in the above code represents the size of the string memory allocation, then the second sentence of the call "cxstring string2 = 10;" And the sixth sentence "Cxstring string6 = ' C ';" is not a fish and fish, and it is easy to confuse people. Is there any way to stop this usage? The answer is to use the explicit keyword. Let's change the code above, as follows:

2. Class cxstring //Use keyword explicit to display the conversion
4. {
6. Public
8. Char *_pstr;
10. int _size;
12. explicit cxstring (int size)
14. {
16. _size = size;
18. //code ibid., omitted ...
20. }
22. Cxstring (const char *p)
24. {
26. //code ibid., omitted ...
28. }
30. };
34. //The following is called:
38. Cxstring string1 (24); //This is OK.
40. cxstring string2 = 10; //This is not possible because the explicit keyword cancels the implicit conversion
42. Cxstring String3; //This is not possible, because there is no default constructor
44. Cxstring String4 ("AAAA"); //This is OK.
46. cxstring string5 = "BBB"; //This is also OK, the call is cxstring (const char *p)
48. cxstring String6 = ' C '; //This is not possible, in fact, the call is cxstring (int size), and size equals ' C ' ASCII code, but the explicit keyword de-implicit conversion
50. string1 = 2; //This is also not possible, because the implicit conversion is canceled
52. string2 = 3; //This is also not possible, because the implicit conversion is canceled
54. String3 = string1; //This is also not possible, because the implicit conversion is canceled, unless the class implements an overload of the operator "="

The purpose of the explicit keyword is to prevent implicit automatic conversion of class constructors.

As already mentioned, the explicit keyword is valid only for a class constructor with one argument, and if the class constructor parameter is greater than or equal to two, the implicit conversion is not generated, so the explicit keyword is not valid. For example:

2. Class Cxstring //Explicit keyword is invalid if the class constructor parameter is greater than or equal to two
4. {
6. Public
8. Char *_pstr;
10. int _age;
12. int _size;
14. explicit cxstring (int age, int size)
16. {
18. _age = age;
20. _size = size;
22. //code ibid., omitted ...
24. }
26. Cxstring (const char *p)
28. {
30. //code ibid., omitted ...
32. }
34. };
38. //This time there are no explicit keywords are the same

However, there is one exception, when the explicit keyword is still valid when there are default values for parameters other than the first argument, when the constructor is called only one parameter is equivalent to the class constructor with only one argument, as in the following example:

2. Class cxstring //Use keyword Explicit declaration
4. {
6. Public
8. int _age;
10. int _size;
12. explicit cxstring (int age, int size = 0)
14. {
16. _age = age;
18. _size = size;
20. //code ibid., omitted ...
22. }
24. Cxstring (const char *p)
26. {
28. //code ibid., omitted ...
30. }
32. };
36. //The following is called:
40. Cxstring string1 (24); //This is OK.
42. cxstring string2 = 10; //This is not possible because the explicit keyword cancels the implicit conversion
44. Cxstring String3; //This is not possible, because there is no default constructor
46. string1 = 2; //This is also not possible, because the implicit conversion is canceled
48. string2 = 3; //This is also not possible, because the implicit conversion is canceled
50. String3 = string1; //This is also not possible, because the implicit conversion is canceled, unless the class implements an overload of the operator "="

The above is a detailed introduction to the C + + explicit keyword

C + + Explicit keywords