= 函数声明后删除的含义

Question

class my_class
{
    ...
    my_class(my_class const &) = delete;
    ...
};

在这种情况下 =delete 是什么意思？

是否还有其他“修饰符”（除了 = 0 和 = delete 之外）？

Answer 1

删除函数是C++11 功能：

现在可以表达“禁止复制”这一常见习语了
直接：

<前><代码>类 X {
// ...
X&运算符=(const X&)=删除； // 禁止复制
X(const X&) = 删除;
};

[...]

“删除”机制可用于任何功能。例如，我们
可以消除不需要的转换，如下所示：

<前><代码>结构Z {
// ...

Z(长长); // 可以用 long long 初始化
Z（长）=删除； // 但不少于
};

Answer 2

1. = 0 表示函数是纯虚函数，您无法从此类实例化对象。你需要从它派生并实现这个方法
2. =delete意味着编译器不会为你生成那些构造函数。 AFAIK 仅允许在复制构造函数和赋值运算符上使用。但我不太擅长即将到来的标准。

Answer 3

摘自《The C++ 编程语言 [第 4 版] - Bjarne Stroustrup》一书的这段摘录讨论了使用 =delete 背后的真正目的：

3.3.4 抑制操作

对层次结构中的类使用默认复制或移动通常是
灾难：只给出一个指向基点的指针，我们根本不知道什么
派生类拥有的成员，所以我们不知道如何复制
他们。。因此，最好的做法通常是删除默认副本
和移动操作，即消除默认定义
这两个操作：

类形状 {
民众：
  形状（常量形状&）=删除； // 没有复制操作
  形状&运算符=(const Shape&)=删除；

  形状(形状&&)=删除; // 没有移动操作
  形状&运算符=(形状&&)=删除;
  形状（）;
    // ...
};

现在，复制 Shape 的尝试将被编译器捕获。

=delete机制是通用的，即可以用来抑制任何操作

Answer 4

是否还有其他“修饰符”（= 0 和 = delete 除外）？

由于似乎没有其他人回答这个问题，我应该提到还有 = default。

https:// learn.microsoft.com/en-us/cpp/cpp/explicitly-defaulted-and-deleted-functions#explicitly-defaulted-functions

Answer 5

我所使用的编码标准对于大多数类声明都有以下​​内容。

//  coding standard: disallow when not used
T(void)                  = delete; // default ctor    (1)
~T(void)                 = delete; // default dtor    (2)
T(const T&)              = delete; // copy ctor       (3)
T(const T&&)             = delete; // move ctor       (4)
T& operator= (const T&)  = delete; // copy assignment (5)
T& operator= (const T&&) = delete; // move assignment (6)

如果您使用这 6 个中的任何一个，只需注释掉相应的行即可。

示例：FizzBu​​s 类仅需要 dtor，因此不使用其他 5 个。

//  coding standard: disallow when not used
FizzBuzz(void)                         = delete; // default ctor (1)
// ~FizzBuzz(void);                              // dtor         (2)
FizzBuzz(const FizzBuzz&)              = delete; // copy ctor    (3)
FizzBuzz& operator= (const FizzBuzz&)  = delete; // copy assig   (4)
FizzBuzz(const FizzBuzz&&)             = delete; // move ctor    (5)
FizzBuzz& operator= (const FizzBuzz&&) = delete; // move assign  (6)

我们在这里仅注释掉 1 个，并将其实现安装在其他位置（可能是编码标准建议的位置）。其他 5 个（共 6 个）不允许删除。

您还可以使用“=删除”来禁止不同大小值的隐式提升...示例

// disallow implicit promotions 
template <class T> operator T(void)              = delete;
template <class T> Vuint64& operator=  (const T) = delete;
template <class T> Vuint64& operator|= (const T) = delete;
template <class T> Vuint64& operator&= (const T) = delete;

Answer 6

删除的函数是隐式内联的

（现有答案的附录）

...并且删除的函数应是函数的第一个声明（删除函数模板的显式特化除外 - 删除应在第一个）专业化的声明），这意味着您不能声明一个函数，然后在其翻译单元本地的定义处删除它。

引用 [dcl.fct.def.delete]/4< /a>:

删除的函数是隐式内联的。 ( 注意： 单一定义
规则
([basic.def.odr])
适用于已删除的定义。 — 尾注 ] 已删除的定义
函数的第一个声明应为该函数的第一个声明，或者，对于
函数模板的显式特化，第一个
该专业的声明。 [示例：

struct sometype {
  某种类型（）；
};
某种类型::某种类型() = 删除; // 格式错误；不是第一次声明

—结束示例）

删除了定义的主要功能模板可以进行专门化

，尽管一般的经验法则是为了避免专门化函数模板，因为专门化不参与重载决策的第一步，因此在某些情况下它可能很有用。例如，当使用没有定义的非重载主函数模板来匹配所有不希望隐式转换为其他匹配转换重载的类型时；即，通过仅在未定义、非重载的主函数模板的显式特化中实现精确类型匹配来隐式删除许多隐式转换匹配。

在 C++11 删除函数概念之前，人们可以通过简单地省略主函数模板的定义来做到这一点，但这会产生模糊的未定义引用错误，可以说没有给出作者的任何语义意图主要功能模板（故意省略？）。如果我们显式删除主函数模板，则在找不到合适的显式专业化的情况下的错误消息会变得更好，并且还表明主函数模板定义的省略/删除是故意的。

#include <iostream>
#include <string>

template< typename T >
void use_only_explicit_specializations(T t);

template<>
void use_only_explicit_specializations<int>(int t) {
    std::cout << "int: " << t;
}

int main()
{
    const int num = 42;
    const std::string str = "foo";
    use_only_explicit_specializations(num);  // int: 42
    //use_only_explicit_specializations(str); // undefined reference to `void use_only_explicit_specializations< ...
}

但是，可以删除主模板定义，而不是简单地省略上面主函数模板的定义，从而在没有显式专业化匹配时产生模糊的未定义引用错误：

#include <iostream>
#include <string>

template< typename T >
void use_only_explicit_specializations(T t) = delete;

template<>
void use_only_explicit_specializations<int>(int t) {
    std::cout << "int: " << t;
}

int main()
{
    const int num = 42;
    const std::string str = "foo";
    use_only_explicit_specializations(num);  // int: 42
    use_only_explicit_specializations(str);
    /* error: call to deleted function 'use_only_explicit_specializations' 
       note: candidate function [with T = std::__1::basic_string<char>] has 
       been explicitly deleted
       void use_only_explicit_specializations(T t) = delete; */
}

产生更易读的错误消息，其中删除意图也很明确可见（其中未定义的引用错误可能会导致开发人员认为这是一个不经深思熟虑的错误）。

回到我们为什么要使用这种技术？同样，显式专业化对于隐式删除隐式转换可能很有用。

#include <cstdint>
#include <iostream>

void warning_at_best(int8_t num) { 
    std::cout << "I better use -Werror and -pedantic... " << +num << "\n";
}

template< typename T >
void only_for_signed(T t) = delete;

template<>
void only_for_signed<int8_t>(int8_t t) {
    std::cout << "UB safe! 1 byte, " << +t << "\n";
}

template<>
void only_for_signed<int16_t>(int16_t t) {
    std::cout << "UB safe! 2 bytes, " << +t << "\n";
}

int main()
{
    const int8_t a = 42;
    const uint8_t b = 255U;
    const int16_t c = 255;
    const float d = 200.F;

    warning_at_best(a); // 42
    warning_at_best(b); // implementation-defined behaviour, no diagnostic required
    warning_at_best(c); // narrowing, -Wconstant-conversion warning
    warning_at_best(d); // undefined behaviour!

    only_for_signed(a);
    only_for_signed(c);

    //only_for_signed(b);  
    /* error: call to deleted function 'only_for_signed' 
       note: candidate function [with T = unsigned char] 
             has been explicitly deleted
       void only_for_signed(T t) = delete; */

    //only_for_signed(d);
    /* error: call to deleted function 'only_for_signed' 
       note: candidate function [with T = float] 
             has been explicitly deleted
       void only_for_signed(T t) = delete; */
}

Answer 7

=delete 是 C++11 中引入的功能。根据 =delete 不允许调用该函数。

详细。

假设在一个班级里。

Class ABC{
 Int d;
 Public:
  ABC& operator= (const ABC& obj) =delete
  {

  }
};

当调用此函数进行 obj 赋值时，这是不允许的。意味着赋值运算符将限制从一个对象复制到另一个对象。

Answer 8

一个总结一些常见用法的小例子：

class MyClass
{
public:
    // Delete copy constructor:
    // delete the copy constructor so you cannot copy-construct an object
    // of this class from a different object of this class
    MyClass(const MyClass&) = delete;

    // Delete assignment operator:
    // delete the `=` operator (`operator=()` class method) to disable copying
    // an object of this class
    MyClass& operator=(const MyClass&) = delete;

    // Delete constructor with certain types you'd like to
    // disallow:
    // (Arbitrary example) don't allow constructing from an `int` type. Expect
    // `uint64_t` instead.
    MyClass(uint64_t);
    MyClass(int) = delete;

    // "Pure virtual" function:
    // `= 0` makes this is a "pure virtual" method which *must* be overridden 
    // by a child class
    virtual uint32_t getVal() = 0;
};

TODO：

1. 我仍然需要制作一个更彻底的示例，并运行它以显示一些用法和输出以及相应的错误消息。

另请参阅

1. https://www.stroustrup.com/C++11FAQ.html# default - “默认值控制：default 和 delete”部分

Answer 9

这是 C++ 0x 标准中的新事物，您可以在其中删除继承的函数。

Answer 10

• 是的，函数还有其他限定符，其中之一是右值引用限定符：：

事实上

struct S
{
    void contextDetector() && {}
};

int main()
{
    S{}.contextDetector();  // ok

    S s;
    s.contextDetector();  // error: passing 'S' as 'this' argument discards qualifiers
}

，您可以通过使用左值引用限定符来反转此行为：

struct S
{
    void contextDetector() & {}
};

int main()
{
    S{}.contextDetector();  // error
}

• 当然，您已经了解 const 限定符，它同样将“this”限制在 const 上下文中。

• 易失性将执行相同的上下文限制。
  您知道有 noexcept 。 除了（类型..）也是如此

• constexpr ，必须写在左侧。

• consteval 自 C++20 起用于严格的构建时间限制上下文。

• static（左侧），这将限制链接，或使其成为类范围而不是方法。

• extern 我认为如果没有立即定义它通常是隐含的。

• inline（左侧）同样会改变链接规则。

• 您还可以添加属性，虽然它们不是限定符，但从语法上讲，我们应该能够将它们写在左侧和右侧，但我没有找到让我们写在右侧的编译器：

:

[[nodiscard]] int f();

尾随返回类型：

auto f() -> void

请注意，如您所知，资格应出现在 ->

• virtual 之前。
• 如果您希望确保虚函数遵循其基本原型，则覆盖。
• final 如果这是类型层次结构中最低的虚拟函数。
• 用于转换构造函数的显式。
• friend 在左侧。
• 尝试一个非常奇怪的。函数尝试块： https://en.cppreference.com/w/cpp/ language/try#Function_try_block

：

struct X
{
    int mem;

    X() try : mem(mayThrowFuncCall()) {}
    catch (...)
    {
    }
};

• 成员初始化列表，在构造函数的情况下，您知道 S() : mem(0) {}
• a requires模板概念子句
• 请注意，在 C++26 中，您将能够在删除子句中设置错误消息

：：

int f() = delete("cant use me");