Znaczenie = delete po deklaracji funkcji

1. = 0 oznacza, że funkcja jest czysta wirtualnie i nie można utworzyć instancji obiektu z tej klasy. Musisz z niego wyprowadzić i zaimplementować tę metodę
2. = delete oznacza, że kompilator nie wygeneruje tych konstruktorów dla Ciebie. AFAIK jest to dozwolone tylko w konstruktorze kopiującym i operatorze przypisania. Ale nie jestem zbyt dobry w nadchodzącym standardzie.

Ten fragment języka programowania C++ [4th Edition] - Bjarne Stroustrup książka mówi o prawdziwy cel za pomocą =delete:

Używanie domyślnej kopii lub move dla klasy w hierarchii jest zazwyczaj a disaster : biorąc tylko wskaźnik do bazy, po prostu nie wiemy, co członkowie, których klasa pochodna ma (§3.2.2), więc nie możemy wiedzieć, jak skopiować them . Tak więc najlepiej jest zazwyczaj usunąć domyślną kopię and move operacje, czyli wyeliminowanie domyślnych definicji te dwie operacje:

class Shape {
public:
  Shape(const Shape&) =delete; // no copy operations
  Shape& operator=(const Shape&) =delete;

  Shape(Shape&&) =delete; // no move operations
  Shape& operator=(Shape&&) =delete;
  ˜Shape();
    // ...
};

Teraz próba skopiowania kształtu zostanie przechwycona przez kompilator.

Mechanizm =delete jest ogólny, to znaczy może być użyty do stłumienia dowolnej operacji

Czy są jakieś inne "modyfikatory" (inne niż = 0 i = delete)?

Ponieważ wydaje się, że nikt inny nie odpowiedział na to pytanie, powinienem wspomnieć, że istnieje również =default.

Https://docs.microsoft.com/en-us/cpp/cpp/explicitly-defaulted-and-deleted-functions#explicitly-defaulted-functions

= delete jest funkcją wprowadzoną w C++11. Zgodnie z =delete nie będzie możliwe wywołanie tej funkcji.

Załóżmy, że w klasie.

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

  }
};

Podczas wywoływania tej funkcji do przypisania obj nie będzie dozwolone. Oznacza, że operator przypisania ograniczy kopiowanie z jednego obiektu do drugiego.

Nowy standard C++0x. Zob. sekcja 8.4.3 w projekcie roboczym N3242

Standardy kodowania, z którymi pracowałem, były następujące dla większości deklaracji klas.

  //  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)

Jeśli użyjesz którejś z tych 6, po prostu skomentujesz odpowiednią linię.

Przykład: Klasa FizzBus wymaga tylko dtor, a więc nie używa pozostałych 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)

Komentujemy tylko 1 tutaj, i instalujemy jego implementację gdzie indziej (prawdopodobnie tam, gdzie sugeruje standard kodowania). Pozostałe 5 (z 6) jest wyłączone z delete.

Możesz również użyć '=delete', aby uniemożliwić Ukryte promocje o różnych rozmiarach ... przykład

 // disallow implicit promotion's 
  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;

Jest to nowość w standardach C++ 0x, gdzie można usunąć dziedziczoną funkcję.