c++ 11 中显式默认设置的函数和已删除的函数 总结

今天在一个类中看到如下代码不是很懂,原来是c++11 新特性

RateTimer(const RateTimer&) = delete; //不可拷贝/不可赋值
  RateTimer& operator=(const RateTimer&) = delete;

在 C++11 中,默认函数和已删除函数使你可以显式控制是否自动生成特殊成员函数。 已删除的函数还可为您提供简单语言,以防止所有类型的函数(特殊成员函数和普通成员函数以及非成员函数)的参数中出现有问题的类型提升,这会导致意外的函数调用。

显式默认设置的函数和已删除函数的好处

在 C++ 中,如果某个类型未声明它本身,则编译器将自动为该类型生成默认构造函数、复制构造函数、复制赋值运算符和析构函数。 这些函数称为特殊成员函数,它们使 C++ 中的简单用户定义类型的行为如同 C 中的结构。 也就是说,可以创建、复制和销毁它们而无需任何额外编码工作。 C++11 会将移动语义引入语言中,并将移动构造函数和移动赋值运算符添加到编译器可自动生成的特殊成员函数的列表中。

这对于简单类型非常方便,但是复杂类型通常自己定义一个或多个特殊成员函数,这可以阻止自动生成其他特殊成员函数。 实践操作:

  • 如果显式声明了任何构造函数,则不会自动生成默认构造函数。
  • 如果显式声明了虚拟析构函数,则不会自动生成默认析构函数。
  • 如果显式声明了移动构造函数或移动赋值运算符,则:
    • 不自动生成复制构造函数。
    • 不自动生成复制赋值运算符。
  • 如果显式声明了复制构造函数、复制赋值运算符、移动构造函数、移动赋值运算符或析构函数,则:
    • 不自动生成移动构造函数。
    • 不自动生成移动赋值运算符。

 说明

此外,C++11 标准指定将以下附加规则:

如果显式声明了复制构造函数或析构函数,则弃用复制赋值运算符的自动生成。

如果显式声明了复制赋值运算符或析构函数,则弃用复制构造函数的自动生成。

在这两种情况下,Visual Studio 将继续隐式自动生成所需的函数且不发出警告。

这些规则的结果也可能泄漏到对象层次结构中。 例如,如果基类因某种原因无法拥有可从派生类调用的默认构造函数 - 也就是说,一个不采用任何参数的 public 或 protected 构造函数 - 那么从基类派生的类将无法自动生成它自己的默认构造函数。

这些规则可能会使本应直接的内容、用户定义类型和常见 C++ 惯例的实现变得复杂 — 例如,通过以私有方式复制构造函数和复制赋值运算符,而不定义它们,使用户定义类型不可复制。

struct noncopyable { 
noncopyable() {}; 
private: noncopyable(const noncopyable&); 
noncopyable& operator=(const noncopyable&); 
};

在 C++11 之前,此代码段是不可复制的类型的惯例形式。 但是,它具有几个问题:

  • 复制构造函数必须以私有方式进行声明以隐藏它,但因为它进行了完全声明,所以会阻止自动生成默认构造函数。 如果你需要默认构造函数,则必须显式定义一个(即使它不执行任何操作)。
  • 即使显式定义的默认构造函数不执行任何操作,编译器也会将它视为重要内容。 其效率低于自动生成的默认构造函数,并且会阻止 noncopyable 成为真正的 POD 类型。
  • 尽管复制构造函数和复制赋值运算符在外部代码中是隐藏的,但成员函数和 noncopyable 的友元仍可以看见并调用它们。 如果它们进行了声明但是未定义,则调用它们会导致链接器错误。
  • 虽然这是广为接受的惯例,但是除非你了解用于自动生成特殊成员函数的所有规则,否则意图不明确。

在 C++11 中,不可复制的习语可通过更直接的方法实现。

struct noncopyable { 
noncopyable() =default; 
noncopyable(const noncopyable&) =delete; 
noncopyable& operator=(const noncopyable&) =delete; };

请注意如何解决与 C++11 之前的惯例有关的问题:

  • 仍可通过声明复制构造函数来阻止生成默认构造函数,但可通过将其显式设置为默认值进行恢复。
  • 显式设置的默认特殊成员函数仍被视为不重要的,因此性能不会下降,并且不会阻止 noncopyable 成为真正的 POD 类型。
  • 复制构造函数和复制赋值运算符是公共的,但是已删除。 定义或调用已删除函数是编译时错误。
  • 对于了解 =default 和 =delete 的人来说,意图是非常清楚的。 你不必了解用于自动生成特殊成员函数的规则。

对于创建不可移动、只能动态分配或无法动态分配的用户定义类型,存在类似惯例。 所有这些惯例都具有 C++11 之前的实现,这些实现会遭受类似问题,并且可在 C++11 中通过按照默认和已删除特殊成员函数实现它们,以类似方式进行解决。

显式默认设置的函数

可以默认设置任何特殊成员函数 — 以显式声明特殊成员函数使用默认实现、定义具有非公共访问限定符的特殊成员函数或恢复其他情况下被阻止其自动生成的特殊成员函数。

可通过如此示例所示进行声明来默认设置特殊成员函数:

struct widget { 
widget()=default; 
inline widget& operator=(const widget&); }; 
inline widget& widget::operator=(const widget&) =default;

请注意,只要特殊成员函数可内联,便可以在类主体外部默认设置它。

由于普通特殊成员函数的性能优势,因此我们建议你在需要默认行为时首选自动生成的特殊成员函数而不是空函数体。 你可以通过显式默认设置特殊成员函数,或通过不声明它(也不声明其他会阻止它自动生成的特殊成员函数),来实现此目的。

 说明

Visual Studio 不支持默认的移动构造函数或移动赋值运算符作为 C++11 标准授权。 有关详细信息,请参阅 支持 C++11/14/17 功能中的“默认函数和已删除的函数”一节。

 

已删除的函数

可以删除特殊成员函数以及普通成员函数和非成员函数,以阻止定义或调用它们。 通过删除特殊成员函数,可以更简洁地阻止编译器生成不需要的特殊成员函数。 必须在声明函数时将其删除;不能在这之后通过声明一个函数然后不再使用的方式来将其删除。

struct widget { // deleted operator new prevents widget from being dynamically allocated. 
void* operator new(std::size_t) = delete; 
};

删除普通成员函数或非成员函数可阻止有问题的类型提升导致调用意外函数。 这可发挥作用的原因是,已删除的函数仍参与重载决策,并提供比提升类型之后可能调用的函数更好的匹配。 函数调用将解析为更具体的但可删除的函数,并会导致编译器错误。

// deleted overload prevents call through type promotion of float to double from succeeding.
void call_with_true_double_only(float) =delete; 
void call_with_true_double_only(double param) { return; }

请注意,在前面的示例中,使用 call_with_true_double_only 参数调用 float 将导致编译器错误,但使用 call_with_true_double_only 参数调用 int 不会导致编译器错误;在 int 示例中,此参数将从 int 提升到 double,并成功调用函数的 double 版本,即使这可能并不是预期目的。 若要确保使用非双精度参数对此函数进行的任何调用均会导致编译器错误,您可以声明已删除的函数的模板版本。

template < typename T >  
void call_with_true_double_only(T) =delete; //prevent call through type promotion of any T to double from succeeding.  
void call_with_true_double_only(double param) { return; } // also define for const double, double&, etc. as needed. 

转自 https://msdn.microsoft.com/zh-cn/library/dn457344.aspx

 

已标记关键词 清除标记
## //程序片段意图:判断程序目录下是否存在input.txt文件,若不存在,则提示输入文件路径 ## //错误:函数调用出错input _ error(input) “input”被划出,提示调用函数是已删除函数 == ``` int input_error(fstream i){ if (!i){ cerr << endl << "Fail to open the file!" << endl << endl; return -1; } else return 0; } int main(){ int n; fstream input("input.txt"); if (input_error(input) == -1){ fstream input; string filename; cout << "Please input the absolute path of the file:"; getline(cin, filename, '\n'); input.open(filename); if (input_error(input) == -1)return -1; }; ``` 以下为源代码,希望能够得到各位大神的解决,谢谢! ``` #include<iostream> #include <iomanip> #include<fstream> #include<string> using namespace std; long long Fibo[90] = { 0 }; unsigned long long fibo(long n){ if (n <= 1) return Fibo[n] = n; else if (Fibo[n] != 0) return Fibo[n]; else return Fibo[n] = fibo(n - 1) + fibo(n - 2); } int input_error(fstream i){ if (!i){ cerr << endl << "Fail to open the file!" << endl << endl; return -1; } else return 0; } int main(){ int n; fstream input("input.txt"); if (input_error(input) == -1){ fstream input; string filename; cout << "Please input the absolute path of the file:"; getline(cin, filename, '\n'); input.open(filename); if (input_error(input) == -1)return -1; }; input >> n; input.close(); if (n<0 || n>90){ cout << endl << "The integer is illegal!" << endl << endl; return -1; } else cout << endl << "n: " << n << endl; cout << endl << "Result: " << fibo(n) << endl; cout << endl << "—————Process—————" << endl; for (int i = 0; i <= n; i++){ cout << setw(2) << setfill('0') << i << "....."; cout << setw(19) << setfill('.') << Fibo[i] << endl; } cout << endl; return 0; } ``` 再次感谢! //:~
#pragma once #include<string> #include<iostream> using namespace std; static int number = 0; class Student { protected: int m_ID; string m_Name; string m_Sex; string m_Tel; int m_English; public: Student(int ID = 0, string Name = "δ֪", string Sex = "δ֪", string Tel = "δ֪", int English = 0) { m_ID = ID; m_Name = Name; m_Sex = Sex; m_Tel = Tel; m_English = English; number++; } Student(const Student &s) { m_ID = s.m_ID; m_Name = s.m_Name; m_Sex = s.m_Sex; m_Tel = s.m_Tel; m_English = s.m_English; number++; } ~Student() { number--; } friend istream operator>>(istream &in, Student &s) { in >> s.m_ID >> s.m_Name >> s.m_Sex >> s.m_Tel >> s.m_English; return in; } friend ostream operator<<(ostream &out, const Student &s) { out << s.m_ID << s.m_Name << s.m_Sex << s.m_Tel << s.m_English; return out; } };#pragma once #include"student.h" class Graduate :public Student { protected: string m_Majorfield; string m_Papers; public: Graduate(int ID = 0, string Name = "δ֪", string Sex = "δ֪", string Tel = "δ֪", int English = 0, string Majorfield="δ֪", string Papers="δ֪") :Student(ID,Name,Sex,Tel,English) { m_Majorfield = Majorfield; m_Papers = Papers; number++; } Graduate(const Graduate&s) { m_ID = s.m_ID; m_Name = s.m_Name; m_Sex = s.m_Sex; m_Tel = s.m_Tel; m_English = s.m_English; m_Majorfield = s.m_Majorfield; m_Papers = s.m_Papers; number++; } ~Graduate() { number--; } /*friend istream operator>>(istream &in, Graduate &s) { in >> s.m_ID >> s.m_Name >> s.m_Sex >> s.m_Tel >> s.m_English >> s.m_Majorfield >> s.m_Papers; return in; } friend ostream operator<<(ostream &out, Graduate &s) { out<< s.m_ID <<endl <<s.m_Name <<endl <<s.m_Sex <<endl <<s.m_Tel <<endl <<s.m_English <<endl <<s.m_Majorfield <<endl <<s.m_Papers<<endl; return out; }*/ };#pragma once #include"student.h" class Undergraduate :public Student { protected: int m_Math; int m_Cpp; public: Undergraduate(int ID = 0, string Name = "δ֪", string Sex = "δ֪", string Tel = "δ֪", int English = 0, int Math = 0, int Cpp = 0) :Student(ID, Name, Sex, Tel, English) { m_Math = Math; m_Cpp = Cpp; number++; } Undergraduate(const Undergraduate &s) { m_ID = s.m_ID; m_Name = s.m_Name; m_Sex = s.m_Sex; m_Tel = s.m_Tel; m_English = s.m_English; m_Math = s.m_Math; m_Cpp = s.m_Cpp; number++; } ~Undergraduate() { number--; } /*friend istream operator>>(istream &in, Undergraduate &s) { in>> s.m_ID >> s.m_Name >> s.m_Sex >> s.m_Tel >> s.m_English >> s.m_Math >> s.m_Cpp; return in; } friend ostream operator<<(ostream &out, Undergraduate &s) { out<<s.m_ID <<endl <<s.m_Name <<endl <<s.m_Sex <<endl <<s.m_Tel <<endl <<s.m_English <<endl <<s.m_Math <<endl <<s.m_Cpp<<endl; return out; }*/ }; #pragma once #include"student.h" template<typename T> class LinkList; template<typename T> class Node { private: T *data; Node *next; public: Node(T t) { data = &t; next = NULL; } Node() { next =NULL } ~Node() { next = NULL; } T SetData(T &t) { data = &t; } void ShowData() { cout << data<<endl; } friend LinkList; }; template<typename T> class LinkList { protected: Node *m_head; public: LinkList() { this->m_head = NULL; } void InsertAtHead(const Node &t) { Node *p; p = new Node(t); p->next = m_head; m_head = p; } void show() { Node *p; p = m_head; while (p != NULL) { p->ShowData(); p = p->next; } cout << endl; } }; #include"链表.h" #include"graduate.h" #include"undergraduate.h" template<typename T> void main() { LinkList<Student> list1; list1.InsertAtHead(Student(5,"xiaosan","man","12132132132",98)); list1.show(); }
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页