C++中=delete的巧妙用法

1. 引言

1.1 函数原型与=delete

在C++11中，=delete是一个新的特性，它允许我们显式地禁止编译器自动生成某些函数。这个特性在很多场合都非常有用，比如当我们想要阻止一个类被复制或者赋值时。

1.1.1 函数原型的基本概念

函数原型（Function Prototype）是函数声明的一种形式，它指定了函数的名称、返回类型以及参数类型列表。例如，下面的代码声明了一个名为foo的函数，它接受一个int类型的参数，并返回一个int类型的值：

int foo(int);

在口语交流中，我们通常会这样描述这个函数原型：“There is a function named ‘foo’, which takes an integer as its argument and returns an integer."（有一个名为’foo’的函数，它接受一个整数作为参数，并返回一个整数。）

1.1.2 在函数原型中使用=delete

在C++11中，我们可以在函数原型后面添加=delete来显式地禁止编译器自动生成某些函数。例如，如果我们想要阻止一个类被复制，我们可以这样做：

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

在这个例子中，我们使用=delete禁止了NonCopyable类的复制构造函数和赋值运算符。这样，如果我们试图复制一个NonCopyable对象，编译器就会报错。

在口语交流中，我们通常会这样描述这个代码：“In the ‘NonCopyable’ class, the copy constructor and the assignment operator are explicitly deleted to prevent the objects of this class from being copied."（在’NonCopyable’类中，复制构造函数和赋值运算符被显式地删除，以防止这个类的对象被复制。）

1.1.3 使用=delete的代码示例

下面是一个更复杂的例子，它展示了如何使用=delete来禁止某些类型的参数：

class MyClass {
public:
    void process(int value) {
        // Process an integer...
    }
    void process(double value) = delete;
};

在这个例子中，我们禁止了MyClass::process(double)函数，这样，如果我们试图用一个double类型的值来调用process函数，编译器就会报错。

这是一个使用PlantUML绘制的类图，它展示了MyClass类的结构，包括process(int)函数和被删除的process(double)函数。

2. 函数原型与=delete

2.1 函数原型的基本概念

在C++中，函数原型（Function Prototype）是一种声明函数的方式，它提供了函数的基本信息，包括函数的名称、返回类型以及参数列表。函数原型是编译器在编译时期进行类型检查的重要依据。

例如，我们有一个函数原型如下：

int add(int a, int b);

这个函数原型告诉我们，add函数接受两个int类型的参数，并返回一个int类型的结果。

在口语交流中，我们可以这样描述这个函数原型： “The function add takes two integers as arguments and returns an integer.”（函数add接受两个整数作为参数，并返回一个整数。）

在这个句子中，“takes … as arguments”（作为参数接受…）和 “returns”（返回）是描述函数原型的常用表达方式。

2.2 在函数原型中使用=delete

在C++11及其后续版本中，我们可以在函数原型中使用=delete关键字，这是一种显式地禁止某个函数的使用的方式。这种技术常常用于禁止类的复制操作，或者阻止特定类型的参数。

例如，我们有一个类NonCopyable，我们不希望它被复制，那么我们可以这样定义它的复制构造函数和复制赋值运算符：

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};

在这个例子中，=delete告诉编译器，我们不希望NonCopyable的复制构造函数和复制赋值运算符被使用。如果我们尝试复制一个NonCopyable的实例，编译器会报错。

在口语交流中，我们可以这样描述这个类： “The class NonCopyable explicitly deletes its copy constructor and copy assignment operator, which means it cannot be copied.”（类NonCopyable显式地删除了它的复制构造函数和复制赋值运算符，这意味着它不能被复制。）

在这个句子中，“explicitly deletes”（显式地删除）和 “cannot be copied”（不能被复制）是描述使用=delete的常用表达方式。

此外，=delete还可以用于禁止特定类型的参数。例如，我们有一个函数void foo(int)，但我们不希望它接受double类型的参数，那么我们可以这样定义：

void foo(double) = delete;

这样，如果我们尝试用一个double类型的值调用foo，编译器就会报错。

在口语交流中，我们可以这样描述这个函数： “The function foo explicitly deletes its overload that takes a double as an argument, which means it cannot be called with a double.”（函数foo显式地删除了它接受一个双精度浮点数作为参数的重载，这意味着它不能被一个双精度浮点数调用。）

在这个句子中，“explicitly deletes its overload”（显式地删除了它的重载）和 “cannot be called with a double”（不能被一个双精度浮点数调用）是描述使用=delete禁止特定类型参数的常用表达方式。

在口语交流中，我们可以这样描述这个类： “The class NonCopyable explicitly deletes its copy constructor and copy assignment operator, which means it cannot be copied.”（类NonCopyable显式地删除了它的复制构造函数和复制赋值运算符，这意味着它不能被复制。）

在这个句子中，“explicitly deletes”（显式地删除）和 “cannot be copied”（不能被复制）是描述使用=delete的常用表达方式。

这种技术的使用在Bjarne Stroustrup的《The C++ Programming Language》一书中有详细的讨论。在书中，Stroustrup强调了=delete在提高代码安全性和可读性方面的重要性。

下表总结了=delete在函数原型中的常见用法：

在C++的底层实现中，=delete实际上是通过修改函数的访问权限来实现的。当我们将一个函数标记为=delete时，编译器会将该函数的访问权限设置为private，并且不会生成该函数的实现。这就是为什么当我们尝试调用一个被=delete的函数时，编译器会报错的原因。

2.3 展示使用=delete的代码示例

让我们通过一些具体的代码示例来进一步理解=delete的用法。

示例1：禁止复制

class NonCopyable {
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
};
NonCopyable a;
NonCopyable b(a);  // 编译错误：复制构造函数被删除
NonCopyable c;
c = a;  // 编译错误：复制赋值运算符被删除

在这个示例中，我们通过=delete禁止了NonCopyable的复制构造函数和复制赋值运算符，因此尝试复制NonCopyable的实例会导致编译错误。

示例2：禁止特定类型的参数

void foo(int) { }
void foo(double) = delete;
foo(42);  // 正常：调用foo(int)
foo(42.0);  // 编译错误：foo(double)被删除

在这个示例中，我们通过=delete禁止了foo(double)，因此尝试用一个double类型的值调用foo会导致编译错误。

在口语交流中，我们可以这样描述这些示例： “In the first example, the class NonCopyable explicitly deletes its copy constructor and copy assignment operator, so trying to copy an instance of NonCopyable results in a compile error. In the second example, the function foo explicitly deletes its overload that takes a double, so trying to call foo with a double results in a compile error.”（在第一个示例中，类NonCopyable显式地删除了它的复制构造函数和复制赋值运算符，所以尝试复制一个NonCopyable的实例会导致编译错误。在第二个示例中，函数foo显式地删除了它接受一个双精度浮点数作为参数的重载，所以尝试用一个双精度浮点数调用foo会导致编译错误。）

3. =delete的使用场景

3.1 阻止对象的复制

在C++中，我们有时候会希望阻止对象的复制，以防止潜在的错误或者不必要的性能开销。这时候，我们可以使用=delete来达到这个目的。

例如，我们有一个类NonCopyable，我们不希望它的对象被复制。我们可以这样做：

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete; // Copy constructor (复制构造函数)
    NonCopyable& operator=(const NonCopyable&) = delete; // Copy assignment operator (复制赋值运算符)
};

在这个例子中，我们将复制构造函数和复制赋值运算符标记为=delete，这样就阻止了对象的复制。如果我们试图复制NonCopyable的对象，编译器就会报错。

在口语交流中，我们可以这样描述这个特性：“In C++, we can use the delete keyword to prevent object copying. By marking the copy constructor and copy assignment operator as delete, we can ensure that objects of the class cannot be copied. If we try to copy an object, the compiler will throw an error."（在C++中，我们可以使用delete关键字来阻止对象的复制。通过将复制构造函数和复制赋值运算符标记为delete，我们可以确保类的对象不能被复制。如果我们试图复制一个对象，编译器将会抛出错误。）

在C++的名著《Effective C++》中，作者Scott Meyers也强调了这个技巧的重要性，他指出：“Making a class noncopyable helps prevent many subtle bugs that can be hard to track down. It’s a powerful technique that requires minimal code and yields significant benefits.”（使一个类不可复制可以帮助防止许多难以追踪的微妙错误。这是一种强大的技术，只需要最少的代码就能产生显著的效益。）

下表总结了阻止对象复制的方法：

这种技术可以帮助我们编写更安全、更高效的代码，是C++中的一个重要技巧。

3.2 禁止某些类型的参数

在C++中，我们有时候希望某个函数只能接受特定类型的参数，而对于其他类型的参数，我们希望禁止其传入。这时候，我们可以利用=delete来实现这个目标。

例如，我们有一个函数void process(Data d)，它只能接受Data类型的参数。如果我们希望禁止其他类型的参数，我们可以这样做：

void process(int) = delete;
void process(double) = delete;
void process(std::string) = delete;
// ... and so on for other types

在这个例子中，我们将process函数对于int、double和std::string类型的版本标记为=delete，这样就阻止了这些类型的参数传入。如果我们试图用这些类型的参数调用process函数，编译器就会报错。

在口语交流中，我们可以这样描述这个特性：“In C++, we can use the delete keyword to prevent a function from accepting certain types of parameters. By marking the function as delete for these types, we can ensure that these types of parameters cannot be passed to the function. If we try to call the function with these types of parameters, the compiler will throw an error."（在C++中，我们可以使用delete关键字来阻止函数接受某些类型的参数。通过将这些类型的函数版本标记为delete，我们可以确保这些类型的参数不能传递给函数。如果我们试图用这些类型的参数调用函数，编译器将会抛出错误。）

在C++的名著《C++ Primer》中，作者也强调了这个技巧的重要性，他指出：“By using delete, we can make our intentions clear and prevent the compiler from generating code that we do not want.”（通过使用delete，我们可以明确我们的意图，防止编译器生成我们不希望的代码。）

下表总结了禁止某些类型参数的方法：

这种技术可以帮助我们编写更安全、更高效的代码，是C++中的一个重要技巧。

3.3 禁止某些特殊的成员函数

在C++中，编译器会为每个类自动生成一些特殊的成员函数，例如默认构造函数、复制构造函数、移动构造函数、复制赋值运算符和移动赋值运算符。然而，有时我们可能不希望编译器为我们的类生成这些函数，这时我们可以使用=delete来禁止它们。

例如，我们有一个类NonMovable，我们不希望它的对象被移动。我们可以这样做：

class NonMovable {
public:
    NonMovable(NonMovable&&) = delete; // Move constructor (移动构造函数)
    NonMovable& operator=(NonMovable&&) = delete; // Move assignment operator (移动赋值运算符)
};

在这个例子中，我们将移动构造函数和移动赋值运算符标记为=delete，这样就阻止了对象的移动。如果我们试图移动NonMovable的对象，编译器就会报错。

在口语交流中，我们可以这样描述这个特性：“In C++, we can use the delete keyword to prevent object moving. By marking the move constructor and move assignment operator as delete, we can ensure that objects of the class cannot be moved. If we try to move an object, the compiler will throw an error."（在C++中，我们可以使用delete关键字来阻止对象的移动。通过将移动构造函数和移动赋值运算符标记为delete，我们可以确保类的对象不能被移动。如果我们试图移动一个对象，编译器将会抛出错误。）

在C++的名著《Effective Modern C++》中，作者Scott Meyers也强调了这个技巧的重要性，他指出：“By declaring a special member function =delete, you make it clear that this function is not to be used. This can prevent a lot of headaches caused by the inadvertent use of inappropriate functions.”（通过声明一个特殊的成员函数为delete，你明确表示这个函数不应被使用。这可以防止因不经意使用不适当的函数而引起的许多问题。）

下表总结了禁止某些特殊成员函数的方法：

这种技术可以帮助我们编写更安全、更高效的代码，是C++中的一个重要技巧。

4. 注意事项

4.1 =delete与=default的区别

在C++11中，=delete和=default是两个用于控制特殊成员函数行为的新关键字。它们的主要区别在于，=delete用于禁止编译器自动生成特定的函数，而=default则是要求编译器生成默认的函数实现。

4.1.1 =delete的使用

当我们不希望编译器为类自动生成某个函数时，可以使用=delete关键字。例如，如果我们不希望类的对象被复制，我们可以这样做：

class NonCopyable {
public:
    NonCopyable(const NonCopyable&) = delete; // 删除复制构造函数(Copy Constructor)
    NonCopyable& operator=(const NonCopyable&) = delete; // 删除赋值运算符(Assignment Operator)
};

在这个例子中，我们删除了复制构造函数和赋值运算符，这样就无法创建NonCopyable类的副本了。

4.1.2 =default的使用

=default关键字用于要求编译器生成默认的函数实现。例如，如果我们希望类的默认构造函数和析构函数具有默认的行为，我们可以这样做：

class Defaulted {
public:
    Defaulted() = default; // 默认构造函数(Default Constructor)
    ~Defaulted() = default; // 析构函数(Destructor)
};

在这个例子中，我们使用=default关键字让编译器为我们生成默认的构造函数和析构函数。

在口语交流中，我们可以这样描述=delete和=default的区别：“=delete is used when you want to disable the compiler’s automatic generation of a certain function, while =default is used when you want the compiler to generate a default implementation of a function.”（“=delete用于你想禁止编译器自动生成某个函数，而=default用于你希望编译器生成函数的默认实现。”）

在这个句子中，“is used when”（“用于”）是一个常见的英语句型，用于描述某个事物的用途或功能。“you want to”（“你希望”）则表示期望或目标，这是一个常见的表达愿望或目标的句型。

下表总结了=delete和=default的主要区别：

=default | 要求编译器生成默认的函数实现 | Defaulted() = default; |

在C++ Primer这本经典的C++教程中，也有对=delete和=default的详细讨论。书中指出，=delete和=default是C++11引入的两个新特性，它们提供了更精细的控制特殊成员函数的机制，使得程序员可以更好地控制类的行为。

在实际的编程实践中，我们经常需要深入到底层源码中去理解这些关键字的工作原理。例如，当我们查看C++标准库的源码时，我们会发现=delete和=default被广泛地用于控制各种容器和算法的行为。这些源码为我们提供了学习和理解这些关键字的最佳实践。

总的来说，=delete和=default是C++中两个非常强大的工具，它们可以帮助我们编写出更安全、更清晰、更高效的代码。

4.2 =delete的限制

虽然=delete是一个非常强大的工具，但是在使用它的时候，我们也需要注意一些限制和规则。

4.2.1 只能用于类的成员函数

首先，=delete只能用于类的成员函数，不能用于全局函数或者非成员函数。例如，下面的代码是错误的：

void globalFunction() = delete; // 错误：只能用于类的成员函数

4.2.2 不能删除重载的函数

其次，我们不能删除重载的函数。如果我们试图删除一个重载的函数，编译器会报错。例如，下面的代码是错误的：

class MyClass {
public:
    void func(int) {}
    void func(double) = delete; // 错误：不能删除重载的函数
};

4.2.3 不能删除虚函数

最后，我们不能删除虚函数。如果我们试图删除一个虚函数，编译器会报错。例如，下面的代码是错误的：

class Base {
public:
    virtual void func() = 0;
};
class Derived : public Base {
public:
    void func() = delete; // 错误：不能删除虚函数
};

在口语交流中，我们可以这样描述=delete的限制：“=delete can only be used for member functions of a class, not for global or non-member functions. Also, you can’t delete an overloaded function or a virtual function.”（“=delete只能用于类的成员函数，不能用于全局函数或非成员函数。而且，你不能删除重载的函数或虚函数。”）

在这个句子中，“can only be used for”（“只能用于”）是一个常见的英语句型，用于描述某个事物的使用范围。“you can’t”（“你不能”）则表示禁止或限制，这是一个常见的表达禁止或限制的句型。

下表总结了=delete的主要限制：

在C++ Primer这本经典的C++教程中，也有对=delete的限制进行了详细的讨论。书中指出，虽然=delete是一个非常强大的工具，但是在使用它的时候，我们必须遵

守一些规则和限制，否则可能会导致编译错误。

在实际的编程实践中，我们也需要深入到底层源码中去理解这些限制的原因。例如，当我们查看C++标准库的源码时，我们会发现，虽然=delete被广泛地用于控制各种容器和算法的行为，但是它们都严格遵守了上述的规则和限制。

总的来说，虽然=delete有一些限制，但是只要我们正确地使用它，它仍然是一个非常强大的工具，可以帮助我们编写出更安全、更清晰、更高效的代码。

4.3 =delete与虚函数

虽然在上一节我们提到不能删除虚函数，但是在某些情况下，我们可能会希望禁止派生类覆盖基类的某个虚函数。这时，我们可以使用=delete来达到这个目的。

4.3.1 删除虚函数的正确方式

在C++中，我们可以通过在基类中将虚函数声明为=delete来阻止派生类覆盖它。例如：

class Base {
public:
    virtual void func() = delete; // 删除虚函数
};
class Derived : public Base {
public:
    void func() override; // 错误：不能覆盖已删除的虚函数
};

在这个例子中，我们在基类Base中将虚函数func声明为=delete，这样在派生类Derived中就不能覆盖这个函数了。

4.3.2 注意事项

需要注意的是，虽然我们可以删除虚函数，但是这并不意味着我们可以在派生类中删除基类的虚函数。如果我们试图在派生类中删除基类的虚函数，编译器会报错。例如，下面的代码是错误的：

class Base {
public:
    virtual void func();
};
class Derived : public Base {
public:
    void func() override = delete; // 错误：不能在派生类中删除基类的虚函数
};

在口语交流中，我们可以这样描述=delete与虚函数的关系：“=delete can be used in the base class to prevent derived classes from overriding a virtual function. However, you can’t delete a base class’s virtual function in a derived class.”（“=delete可以在基类中用于防止派生类覆盖虚函数。然而，你不能在派生类中删除基类的虚函数。”）

在这个句子中，“can be used in”（“可以在…中使用”）是一个常见的英语句型，用于描述某个事物的使用范围。“you can’t”（“你不能”）则表示禁止或限制，这是一个常见的表达禁止或限制的句型。

总的来说，虽然=delete在处理虚函数时有一些限制，但是只要我们正确地使用它，它仍然是一个非常强大的工具，可以帮助我们更好地控制类的行为。

5. 为什么使用=delete

5.1 提高代码的安全性

在C++编程中，我们经常会遇到一些情况，其中某些操作可能会导致程序的不正确行为。例如，对于某些类，复制或赋值可能没有意义，或者可能导致错误。在这种情况下，我们可以使用=delete来显式地禁止这些操作。

考虑以下示例：

class NonCopyable
{
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete; // 禁止复制
    NonCopyable& operator=(const NonCopyable&) = delete; // 禁止赋值
};

在这个例子中，我们创建了一个名为NonCopyable的类，该类禁止复制和赋值。这样，如果我们试图复制或赋值NonCopyable的实例，编译器将报错，从而防止可能的错误。

在口语交流中，我们可以这样描述这个特性：“In C++, we can use the delete keyword to explicitly disable certain operations, such as copy and assignment, for a class. This can help to improve the safety of our code by preventing potential errors.”（在C++中，我们可以使用delete关键字来显式禁用某个类的某些操作，如复制和赋值。这可以通过防止潜在的错误来提高我们代码的安全性。）

在美式英语中，这个句子的语法结构是完全正确的。主语"We"（我们）后面跟的是可以使用delete关键字的动作，然后是目的状语从句，解释了我们为什么要这么做。

这种使用=delete的方法在Bjarne Stroustrup的《The C++ Programming Language》一书中也有详细的讨论。Stroustrup强调，通过禁止不安全或无意义的操作，我们可以使我们的代码更加健壮和安全。

下表总结了使用=delete与不使用=delete在代码安全性方面的对比：

通过这种方式，我们可以看到，使用=delete可以显著提高我们代码的安全性。

5.2 提高代码的可读性

除了提高代码的安全性外，=delete还可以提高代码的可读性。当我们在代码中看到一个函数被标记为=delete时，我们可以立即知道这个函数是不可用的，而不需要去查看函数的实现或者文档。

考虑以下示例：

class MyClass
{
public:
    void someFunction() = delete;
};

在这个例子中，someFunction被标记为=delete，这意味着这个函数是不可用的。这对于阅读代码的人来说是非常清晰的，他们不需要去查看someFunction的实现或者文档，就可以知道这个函数是不可用的。

在口语交流中，我们可以这样描述这个特性：“In C++, marking a function as delete can improve the readability of the code. When we see a function marked as delete, we know immediately that this function is not available, without having to look at the implementation or documentation of the function.”（在C++中，将一个函数标记为delete可以提高代码的可读性。当我们看到一个函数被标记为delete时，我们立即就知道这个函数是不可用的，无需查看函数的实现或文档。）

在美式英语中，这个句子的语法结构是完全正确的。主语"We"（我们）后面跟的是看到一个函数被标记为delete的动作，然后是结果状语从句，解释了我们看到这个标记后的反应。

这种使用=delete的方法在Scott Meyers的《Effective Modern C++》一书中也有详细的讨论。Meyers强调，通过明确地标记不可用的函数，我们可以使我们的代码更加易读和易理解。

下表总结了使用=delete与不使用=delete在代码可读性方面的对比：

通过这种方式，我们可以看到，使用=delete可以显著提高我们代码的可读性。

5.3 控制类的设计

=delete不仅可以提高代码的安全性和可读性，还可以帮助我们更好地控制类的设计。我们可以通过=delete来禁止那些我们不希望在类中出现的操作，从而使我们的类的设计更加清晰和一致。

考虑以下示例：

class Singleton
{
public:
    static Singleton& getInstance()
    {
        static Singleton instance;
        return instance;
    }
    Singleton(const Singleton&) = delete; // 禁止复制
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值
private:
    Singleton() = default;
};

在这个例子中，我们创建了一个名为Singleton的类，该类禁止复制和赋值。这样，我们就可以确保Singleton类的实例只有一个，从而实现了单例模式。

在口语交流中，我们可以这样描述这个特性：“In C++, we can use the delete keyword to control the design of our classes. By marking certain operations as delete, we can prevent these operations from being used in our classes, making our class design clearer and more consistent.”（在C++中，我们可以使用delete关键字来控制我们类的设计。通过将某些操作标记为delete，我们可以防止这些操作在我们的类中被使用，使我们的类设计更加清晰和一致。）

在美式英语中，这个句子的语法结构是完全正确的。主语"We"（我们）后面跟的是可以使用delete关键字的动作，然后是结果状语从句，解释了我们为什么要这么做。

这种使用=delete的方法在Andrei Alexandrescu的《Modern C++ Design》一书中也有详细的讨论。Alexandrescu强调，通过禁止不需要的操作，我们可以使我们的类的设计更加清晰和一致。

下表总结了使用=delete与不使用=delete在控制类设计方面的对比：

通过这种方式，我们可以看到，使用=delete可以显著帮助我们控制类的设计。

6. 在Qt中的=delete表现形式

6.1 Qt中的=delete使用示例

在Qt中，我们经常会看到=delete的使用，它在Qt中的表现形式主要体现在禁止某些操作，比如禁止复制构造函数和赋值操作。这是因为在Qt的一些类中，复制构造函数和赋值操作可能会导致一些不可预见的问题，比如深浅拷贝问题，资源管理问题等。因此，Qt在设计时就禁止了这些操作。

例如，我们在Qt的QObject类中就可以看到这样的设计：

Q_DISABLE_COPY(QObject)

Q_DISABLE_COPY(Class)是一个宏，它的定义如下：

#define Q_DISABLE_COPY(Class) \
    Class(const Class &) = delete;\
    Class &operator=(const Class &) = delete;

这个宏的作用就是将复制构造函数和赋值操作符声明为=delete，从而禁止复制和赋值操作。

在口语交流中，我们可以这样描述这个特性：“In Qt, the Q_DISABLE_COPY macro is used to delete the copy constructor and assignment operator of a class. This prevents the copying and assignment operations, which can help avoid some potential issues such as shallow and deep copy problems, and resource management issues."（在Qt中，Q_DISABLE_COPY宏用于删除类的复制构造函数和赋值操作符。这可以防止复制和赋值操作，从而帮助避免一些潜在的问题，如浅拷贝和深拷贝问题，以及资源管理问题。）

在这个句子中，“delete the copy constructor and assignment operator of a class”（删除类的复制构造函数和赋值操作符）是一个动宾结构，其中"delete"是动词，表示删除的动作，"the copy constructor and assignment operator of a class"是宾语，表示被删除的对象。“prevent the copying and assignment operations”（防止复制和赋值操作）也是一个动宾结构，其中"prevent"是动词，表示防止的动作，"the copying and assignment operations"是宾语，表示被防止的操作。

在C++的名著《Effective C++》中，Scott Meyers也强调了禁止复制的重要性，他认为如果一个类没有明确地声明它需要进行复制操作，那么就应该禁止复制。

下表总结了=delete在C++和Qt中的一些常见用法：

_COPY(Class)| | 禁止某种类型的参数 |void func(int) = delete;| - | | 禁止特殊的成员函数 |void* operator new(size_t) = delete;` | - |

这些用法在实际编程中非常实用，可以帮助我们更好地控制类的设计，提高代码的安全性和可读性。

6.2 Qt中的=delete与信号槽机制

在Qt中，=delete的另一个重要应用是与信号槽机制（Signal-Slot Mechanism）的配合使用。信号槽机制是Qt的一个核心特性，它使得不同对象之间的通信变得简单而直观。

在信号槽机制中，我们经常需要保证槽函数（Slot Function）的唯一性，即一个信号（Signal）只能连接到一个特定的槽函数。这时，我们就可以使用=delete来禁止复制构造函数和赋值操作，从而保证槽函数的唯一性。

例如，我们可以定义一个槽函数类（Slot Class）如下：

class SlotClass
{
public:
    SlotClass() = default;
    SlotClass(const SlotClass&) = delete;
    SlotClass& operator=(const SlotClass&) = delete;
    void slotFunction()
    {
        // Do something
    }
};

在这个类中，我们使用=delete禁止了复制构造函数和赋值操作，从而保证了slotFunction的唯一性。这样，我们就可以确保一个信号只能连接到一个特定的slotFunction。

在口语交流中，我们可以这样描述这个特性：“In Qt, the =delete keyword can be used in conjunction with the signal-slot mechanism to ensure the uniqueness of slot functions. By deleting the copy constructor and assignment operator of the slot class, we can ensure that a signal can only be connected to a specific slot function."（在Qt中，=delete关键字可以与信号槽机制结合使用，以确保槽函数的唯一性。通过删除槽类的复制构造函数和赋值操作符，我们可以确保一个信号只能连接到一个特定的槽函数。）

在这个句子中，“ensure the uniqueness of slot functions”（确保槽函数的唯一性）是一个动宾结构，其中"ensure"是动词，表示确保的动作，"the uniqueness of slot functions"是宾语，表示被确保的对象。“deleting the copy constructor and assignment operator of the slot class”（删除槽类的复制构造函数和赋值操作符）也是一个动宾结构，其中"deleting"是动词，表示删除的动作，"the copy constructor and assignment operator of the slot class"是宾语，表示被删除的对象。

在C++的名著《C++ Primer》中，也有类似的观点，作者强调了禁止复制的重要性，并认为这是保证对象唯一性的一种有效方式。

7. 在泛型编程中的=delete运用

7.1. 使用=delete禁止某些模板实例化

在C++11及其以后的版本中，我们可以使用=delete（删除函数）来显式地阻止编译器为类生成特定的成员函数，或者阻止某些模板实例化。具体来说，template 和 =delete 结合使用，可以让我们在编译时期对模板参数施加条件，从而在模板实例化时进行约束。这是一个强大的工具，用于更深入地控制模板。

当我们声明一个函数为=delete时，编译器不会生成这个函数的实现，而且试图使用此函数将导致编译错误。此外，我们也可以将一个模板函数指定为=delete，以防止某些类型的模板实例化。下面的代码展示了一个示例：

template<typename T>
void foo(T t) = delete;
template<>
void foo<int>(int i) {
    std::cout << "Specialized for int: " << i << std::endl;
}

在上述代码中，我们使用=delete禁止了foo函数模板的所有实例化，然后我们为int类型提供了特化版本。因此，下面的代码将导致编译错误：

foo("hello");  // error: use of deleted function 'void foo(T) [with T = const char*]'

而下面的代码将正常编译和运行：

foo(10);  // outputs: Specialized for int: 10

这种技术是非常有用的，因为它使我们能够根据需要对模板进行更精确的控制。

请注意，在口语交流中，我们可以用以下的方式描述上述情况：“我在foo函数模板中使用=delete禁止了所有的模板实例化，但是我为int类型提供了一个特化版本。”（我禁止了foo函数模板的所有实例化，但对int类型提供了一个专门的版本。）

当我们想要更详细地探索这个主题时，我们可以参考 Bjarne Stroustrup 的《C++ Programming Language》中的相关章节。在那里，他详细地解释了模板特化和=delete的用法，并提供了更多的示例和讨论。

在使用=delete时，你会发现它是一个强大的工具，它可以帮助你实现你想要的精确控制。这就是为什么在编写复杂的C++代码时，=delete是不可或缺的一部分。

7.2. 使用=delete控制模板特化

在C++泛型编程中，template 允许我们编写可以处理多种数据类型的代码，而模板特化允许我们为某种特定类型提供特殊的实现。这为我们提供了巨大的灵活性，但有时我们可能希望阻止某些类型的特化。这就是=delete发挥作用的地方。

首先，我们需要理解一种常见的误解，那就是=delete不能直接用于类模板的特化。换句话说，我们不能这样写：

template<>
class MyTemplate<char> = delete; // Error: deletion of specialization of 'MyTemplate<char>'

这样的语法是不允许的。然而，我们可以通过删除类模板特化中的特定函数来达到类似的效果。例如：

template<typename T>
class MyTemplate {
public:
    void func() {
        // common implementation
    }
};
template<>
class MyTemplate<char> {
public:
    void func() = delete; // Prevent usage with char
};

在这个例子中，我们为char类型的MyTemplate特化提供了一个定义，但是我们使用=delete删除了func函数。因此，尝试使用char类型的MyTemplate的func函数会导致编译错误。

在口语交流中，我们可以这样描述上述情况：“我特化了一个MyTemplate，并使用=delete禁止了func函数的使用。”（我创建了一个MyTemplate的特化版本，并禁止使用func函数。）

这样，我们便可以在模板特化中利用=delete进行更精细的控制。对于更深入的理解，我们可以参考《C++ Templates: The Complete Guide》一书，该书提供了模板特化以及=delete在模板特化中的使用的深入讨论。

此外，你可能想知道如何在markdown表格中总结这些信息。以下是一个简单的例子：

总的来说，=delete在C++泛型编程中的作用不仅限于阻止模板的实例化，也可以被用来阻止模板特化中的特定函数，从而让我们更精细地控制代码的行为。