C++11的default和delete关键字

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

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

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

我们可以这样使用：

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

但是这样是不行的：

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

好，我们用default来：

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

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

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式管理：
（避免麻烦那些什么拷贝构造拷贝赋值移动构造什么的就不写了）

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

我们这样使用这个类：

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

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

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

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

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

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

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

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

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

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