C11的新特性实在是太多了，这2个关键字关注的人倒是少了很多，其中有一个原因便是编译器支持得太慢了（VS到VS2013才支持上），不过这2个关键字那真是极为有用的，下面我们来看看。

【default关键字】
首先我们有一个字符串类：

[cpp] view plain copy

 

 

1. class CString  
2. {  
3.     char* _str;  
4.   
5. public:  
6.     //构造函数  
7.     CString(const char* pstr) : _str(nullptr)  
8.     {  
9.         UpdateString(pstr);  
10.     }  
11.   
12.     //析构函数  
13.     ~CString()  
14.     {  
15.         if (_str)  
16.             free(_str);  
17.     }  
18.   
19. public:  
20.     void UpdateString(const char* pstr) throw()  
21.     {  
22.         if (pstr == nullptr)  
23.             return;  
24.   
25.         if (_str)  
26.             free(_str);  
27.   
28.         _str = (char*)malloc(strlen(pstr) + 1);  
29.         strcpy(_str,pstr);  
30.     }  
31.   
32. public:  
33.     char* GetStr() const throw()  
34.     {  
35.         return _str;  
36.     }  
37. };  

我们可以这样使用：

[cpp] view plain copy

 

 

1. auto str = std::make_unique<CString>("123");  
2. printf(str->GetStr());  

但是这样是不行的：

[cpp] view plain copy

 

 

1. auto str = std::make_unique<CString>(); //失败，因为没有一个无参构造函数  

好，我们用default来：

[cpp] view plain copy

 

 

1. class CString  
2. {  
3.     char* _str = nullptr;  
4.       
5. public:  
6.     CString() = default;  
7.   
8. public:  
9.     //构造函数  
10.     CString(const char* pstr) : _str(nullptr)  
11.     {  
12.         UpdateString(pstr);  
13.     }  
14.   
15.     //析构函数  
16.     ~CString()  
17.     {  
18.         if (_str)  
19.             free(_str);  
20.     }  
21.   
22. public:  
23.     void UpdateString(const char* pstr) throw()  
24.     {  
25.         if (pstr == nullptr)  
26.             return;  
27.   
28.         if (_str)  
29.             free(_str);  
30.   
31.         _str = (char*)malloc(strlen(pstr) + 1);  
32.         strcpy(_str,pstr);  
33.     }  
34.   
35. public:  
36.     char* GetStr() const throw()  
37.     {  
38.         return _str;  
39.     }  
40. };  

于是我们可以这样使用了：

[cpp] view plain copy

 

 

1. auto str_def = std::make_unique<CString>();  
2. str_def->UpdateString(“123”);  
3. printf(str_def->GetStr() == nullptr ? "None":str_def->GetStr());  

【delete关键字】
假设我们有这样一个类，这个类是用于自动申请内存，进行RAII式管理：
（避免麻烦那些什么拷贝构造拷贝赋值移动构造什么的就不写了）

[cpp] view plain copy

 

 

1. template<typename T>  
2. class CStackMemoryAlloctor  
3. {  
4.     mutable T* _ptr;  
5.   
6. public:  
7.     explicit CStackMemoryAlloctor(size_t size) throw() : _ptr(nullptr)  
8.     {  
9.         _ptr = (T*)malloc(size);  
10.     }  
11.   
12.     ~CStackMemoryAlloctor()  
13.     {  
14.         if (_ptr)  
15.             free(_ptr);  
16.     }  
17.   
18. public:  
19.     operator T*() const throw()  
20.     {  
21.         T* tmp = _ptr;  
22.         _ptr = nullptr;  
23.         return tmp;  
24.     }  
25.   
26. public:  
27.     T* GetPtr() const throw()  
28.     {  
29.         return _ptr;  
30.     }  
31. };  

我们这样使用这个类：

[cpp] view plain copy

 

 

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

但是别人也可以这样使用：

[cpp] view plain copy

 

 

1. auto p = std::make_unique<CStackMemoryAlloctor<wchar_t>>(128);  

因为这个类依然可以进行默认new，我们不想让人家进行new怎么办，老办法就是这样：

[cpp] view plain copy

 

 

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

把new设置为private了，就行了，但是这样如果别人尝试new，那看到的错误提示简直惨不忍睹。。。
于是C11的delete人性化多了：

[cpp] view plain copy

 

 

1. public:  
2.     void* operator new(std::size_t) = delete;  

当尝试new的时候，提示十分友好，这个方法已被删除。
这个delete可以用来删任何你不爽的东西，比如拷贝构造，赋值拷贝什么鸡巴毛的东西。

原文转自：http://blog.csdn.net/a1875566250/article/details/40406883

原作者为 a1875566250. 请尊重原作者版权

C++11的default和delete关键字