C++C++11 之 delete 和 default

1  特殊成员函数

  一个看似,只发多少成员时

class DataOnly {
private:
    int  data_;
};

  C++98
编译器会隐式的发出四只函数:缺省构造函数,析构函数拷贝构造函数
拷贝赋值算子,它叫特殊成员函数 (special member function)

  以 C++11 中,“特殊成员函数” 还有一定量单:动构造函数
动赋值算子

class DataOnly {
public:
    DataOnly ()                  // default constructor
    ~DataOnly ()                 // destructor

    DataOnly (const DataOnly & rhs)              // copy constructor
    DataOnly & operator=(const DataOnly & rhs)    // copy assignment operator

    DataOnly (const DataOnly && rhs)         // C++11, move constructor
    DataOnly & operator=(DataOnly && rhs)    // C++11, move assignment operator
};

 

2  禁止编译器合成函数

 
作为开发方,如果非思量吃用户以有成员函数,不声明即可;但对于特别成员函数,则是其余一样栽情景。例如,设计一个栽培叶类:

class LeafOfTree{ ... };

  莱布尼茨说罢,“世上没少切片完全相同的树叶” (Es gibt
keine zwei Blätter, die gleich
bleiben),因此,对于一片独一无二的叶子,下面的操作是左的:

LeafOfTree  leaf1;
LeafOfTree  leaf2;
LeafOfTree  leaf3(leaf1);     // attempt to copy Leaf1 — should not compile!
Leaf1 = Leaf2;              // attempt to copy Leaf2 — should not compile!

  因此,此时待避免使用 “拷贝构造函数” 和 “拷贝赋值算子”

2.1  私有+不实现

  C++98
中,可声明这些非常成员函数为私有型
(private),且未兑现该函数,具体如下:

class LeafOfTree{
private:
    LeafOfTree( const LeafOfTree& );           // not defined
    LeafOfTree & operator=( const LeafOfTree& );    // not defined
};

  程序中设调用了
LeafOfTree 类的正片构造函数
(或拷贝赋值操作符),则于编译时,会冒出链接错误 (link-time error)

  为了用报错提前交编译时 (compile
time),可加了一个基类 Uncopyable,并将拷贝构造函数和拷贝赋值算子声明也私有型,具体而参见
<Effective C++_3rd> item 6

  以谷歌 C++
编码规范被,使用了一个宏定义来简化,如下所示:

// A macro to disallow the copy constructor and operator= functions 
// This should be used in the priavte:declarations for a class
#define    DISALLOW_COPY_AND_ASSIGN(TypeName) \
    TypeName(const TypeName&);                \
    TypeName& operator=(const TypeName&)

2.2  delete 关键字

  C++11 中,可在怀念如果 “禁止采取” 的与众不同成员函数声明后加 “=
delete
”,而用保留的加 “= default” 或者无下操作

class LeafOfTree{
public:
  LeafOfTree() = default;
  ~LeafOfTree() = default;

  LeafOfTree(const LeafOfTree&) = delete;  // mark copy ctor or copy assignment operator as deleted functions
  LeafOfTree & operator=(const LeafOfTree&) = delete; 
};

 

3  delete 的扩展

  C++11 中,delete 关键字可是用来其它函数,不仅仅局限为类成员函数

3.1  函数重载

  于函数重载中,可用 delete 来滤掉一部分函数的显得参类型,如下:

bool IsLucky(int number);        // original function
bool IsLucky(char) = delete;     // reject chars
bool IsLucky(bool) = delete;     // reject bools
bool IsLucky(double) = delete;   // reject doubles and floats

  这样在调用 IsLucky 函数时,如果参数类型不对,则会起谬误提示

if (IsLucky('a')) …     // error !    call to deleted function
if (IsLucky(true)) …    // error !
if (IsLucky(3.5)) …     // error !

3.2  模板特化

  于模板特例化中,也得就此 delete 来过滤一些特定的示参类型。

  例如,Widget
类中声明了一个模板函数,当进行模板特化时,要求禁止参数为 void*
的函数调用。

  如果依 C++98 的 “私有不落实“
思路,应该是将特例化的函数声明也私有型,如下所示:

class Widget {
public:
    template<typename T>
    void ProcessPointer(T* ptr) { … }
private:
    template<>             
    void ProcessPointer<void>(void*);    // error!
};

  问题是,模板特化应该被写以命名空间域 (namespace scope),而未是类域
(class scope),因此,该方法会报错。

  而于 C++11 中,因为来了 delete
关键字,则可一直当类域外,将特例化的模版函数声明也 delete, 如下所示:

class Widget {
public:
    template<typename T>
    void ProcessPointer(T* ptr) { … }
};

template<> 
void Widget::ProcessPointer<void>(void*) = delete; // still public, but deleted

  这样,当程序代码中,有调用 void* 作形参的 ProcessPointer
函数时,则编译时便会报错。

 

小结:

1)  Prefer deleted functions to private undefined ones

2)  Any function may be deleted, including non-member functions and
template instantiations

 

参考资料:

  <C++ Primer_5th> chapter 13  Copy Control

  <Effective C++_3rd> item 5 , item 6

  <Effective Modern C++> item 11 , item 17