Default and delete keywords for c++11

C11 's new features are too many, these 2 keywords are a lot less attention, one of the reasons is that the compiler support is too slow (vs to VS2013 support), but these 2 keywords that is extremely useful, let's look at the following.

"Default keyword"
First we have a string class:

[CPP]View PlainCopy 

2. Class CString
4. {
6. char* _str;
10. Public
12. //Constructors
14. CString (const char* pstr): _str (nullptr)
16. {
18. Updatestring (PSTR);
20. }
24. //destructor
26. ~cstring ()
28. {
30. if (_STR)
32. Free (_STR);
34. }
38. Public
40. void updatestring (const char* pstr) throw ()
42. {
44. if (pstr = = nullptr)
46. return;
50. if (_STR)
52. Free (_STR);
56. _str = (char*) malloc (strlen (PSTR) + 1);
58. strcpy (_STR,PSTR);
60. }
64. Public
66. char* getstr () const throw ()
68. {
70. return _str;
72. }
74. };

We can use this:

[CPP]View PlainCopy 

1. Auto str = std::make_unique<cstring> ("123");
2. printf (Str->getstr ());

But this is not possible:

[CPP]View PlainCopy 

1. Auto str = std::make_unique<cstring> (); //failed because there is no parameter constructor

OK, let's use default to:

[CPP]View PlainCopy 

2. Class CString
4. {
6. char* _str = nullptr;
10. Public
12. CString () = default;
16. Public
18. //Constructors
20. CString (const char* pstr): _str (nullptr)
22. {
24. Updatestring (PSTR);
26. }
30. //destructor
32. ~cstring ()
34. {
36. if (_STR)
38. Free (_STR);
40. }
44. Public
46. void updatestring (const char* pstr) throw ()
48. {
50. if (pstr = = nullptr)
52. return;
56. if (_STR)
58. Free (_STR);
62. _str = (char*) malloc (strlen (PSTR) + 1);
64. strcpy (_STR,PSTR);
66. }
70. Public
72. char* getstr () const throw ()
74. {
76. return _str;
78. }
80. };

So we can use it this way:

[CPP]View PlainCopy 

1. Auto Str_def = std::make_unique<cstring> ();
2. Str_def->updatestring ("123");
3. printf (str_def->getstr () = = nullptr?  "None": Str_def->getstr ());

The "delete keyword"
Suppose we have a class that is used to automatically request memory for RAII management:
(Avoid trouble with what copy constructs the copy assignment to move the structure or not to write)

[CPP]View PlainCopy  

2. template<TypeName T>
4. Class Cstackmemoryalloctor
6. {
8. mutable t* _ptr;
12. Public
14. explicit Cstackmemoryalloctor (size_t size) throw (): _ptr (nullptr)
16. {
18. _ptr = (t*) malloc (size);
20. }
24. ~cstackmemoryalloctor ()
26. {
28. if (_ptr)
30. Free (_PTR);
32. }
36. Public
38. Operator t* () const throw ()
40. {
42. t* tmp = _PTR;
44. _ptr = nullptr;
46. return tmp;
48. }
52. Public
54. t* getptr () const throw ()
56. {
58. return _ptr;
60. }
62. };

We use this class in this way:

[CPP]View PlainCopy 

1. cstackmemoryalloctor<wchar_t> str (128);
2. wchar_t* pstr = str. GetPtr ();
3. wcscpy (pstr,l"123\n");
4. wprintf (PSTR);

But others can also use this:

[CPP]View PlainCopy 

1. Auto p = std::make_unique<cstackmemoryalloctor<wchar_t>> (128);

Because this class can still do the default new, we don't want to let people do new things, the old-fashioned way:

[CPP]View PlainCopy 

1. Private
2. void* operator New (std::size_t)
3. {
4. return nullptr;
5. }

It's OK to set new to private, but then if someone tries new, the error you see is simply horrible ...
So C11 's delete is more humane:

[CPP]View PlainCopy 

1. Public
2. void* operator New (std::size_t) = Delete;

When trying new, the prompt is very friendly and the method has been removed.
This delete can be used to delete anything you're not comfortable with, such as copy construction, and assign a copy of what the chicken hair is.

Translated from: http://blog.csdn.net/a1875566250/article/details/40406883

The original author is a1875566250. Please respect the copyright of the original author

Default and delete keywords for c++11