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

Co = deleteznaczy w tym kontekście?

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

Usunięcie funkcji jest funkcją C ++ 11 :

Wspólny idiom „zakazu kopiowania” można teraz wyrazić bezpośrednio:

class X {
    // ...
    X& operator=(const X&) = delete;  // Disallow copying
    X(const X&) = delete;
};

[...]

Mechanizm „usuń” można zastosować do dowolnej funkcji. Na przykład możemy wyeliminować niepożądaną konwersję, taką jak ta:

struct Z {
    // ...

    Z(long long);     // can initialize with an long long         
    Z(long) = delete; // but not anything less
};

1. = 0oznacza, że ​​funkcja jest czysto wirtualna i nie można utworzyć instancji obiektu z tej klasy. Musisz z niego skorzystać i wdrożyć tę metodę
2. = deleteoznacza, że ​​kompilator nie wygeneruje tych konstruktorów. AFAIK jest to dozwolone tylko w przypadku konstruktora kopiowania i operatora przypisania. Ale nie jestem zbyt dobry w nadchodzącym standardzie.

Ten fragment książki The C ++ Programming Language [4th Edition] - Bjarne Stroustrup mówi o prawdziwym celu wykorzystania =delete:

3.3.4 Tłumienie operacji

Użycie domyślnej kopii lub przeniesienia dla klasy w hierarchii jest zwykle katastrofą : biorąc pod uwagę tylko wskaźnik do bazy, po prostu nie wiemy, którzy członkowie mają klasę pochodną, ​​więc nie możemy wiedzieć, jak je skopiować . Dlatego najlepiej jest usunąć domyślne operacje kopiowania i przenoszenia, czyli wyeliminować domyślne definicje tych dwóch operacji:

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 kompilator przechwytuje próbę skopiowania kształtu.

=deleteMechanizm jest ogólnie, to znaczy, może on być stosowany w celu powstrzymania każdą operację

Czy są jakieś inne „modyfikatory” (inne niż = 0i = 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

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

//  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óregoś z tych 6, po prostu skomentuj odpowiedni wiersz.

Przykład: klasa FizzBus wymaga tylko dtor, a zatem 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 tutaj tylko 1 i instalujemy implementację w innym miejscu (prawdopodobnie tam, gdzie sugeruje to standard kodowania). Pozostałe 5 (z 6) jest niedozwolone przy usuwaniu.

Możesz także użyć „= usuń”, aby zabronić niejawnych promocji wartości o różnych rozmiarach ... przykład

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

= deleteto funkcja wprowadzona w C ++ 11. Zgodnie z =deletetym nie będzie można wywoływać tej funkcji.

Szczegółowo.

Załóżmy w klasie.

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

  }
};

Wywoływanie tej funkcji w celu przypisania obiektów nie jest dozwolone. Oznacza, że ​​operator przypisania ograniczy kopiowanie z jednego obiektu do drugiego.

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

Usunięta funkcja jest domyślnie wbudowana

(Dodatek do istniejących odpowiedzi)

... A usunięta funkcja będzie pierwszą deklaracją funkcji (z wyjątkiem usuwania wyraźnych specjalizacji szablonów funkcji - usunięcie powinno nastąpić przy pierwszej deklaracji specjalizacji), co oznacza, że ​​nie można zadeklarować funkcji, a następnie usunąć, powiedzmy, w swojej definicji lokalnej dla jednostki tłumaczeniowej.

Powołując się na [dcl.fct.def.delete] / 4 :

Usunięta funkcja jest domyślnie wbudowana. ( Uwaga: Reguła z jedną definicją ( [basic.def.odr] ) ma zastosowanie do usuniętych definicji. - uwaga końcowa] Usunięta definicja funkcji powinna być pierwszą deklaracją funkcji lub, w przypadku wyraźnej specjalizacji szablonu funkcji , pierwsza deklaracja tej specjalizacji. [Przykład:

struct sometype {
  sometype();
};
sometype::sometype() = delete;      // ill-formed; not first declaration

- koniec przykładu )

Szablon funkcji podstawowej z usuniętą definicją może być wyspecjalizowany

Chociaż ogólną zasadą jest unikanie specjalizacji szablonów funkcyjnych, ponieważ specjalizacje nie biorą udziału w pierwszym etapie rozwiązywania problemu przeciążenia, istnieją pewne konteksty, w których może to być przydatne. Np. Przy użyciu nie przeciążonego szablonu funkcji podstawowej bez definicji, aby dopasować wszystkie typy, których nie chciałoby się pośrednio konwertować na przeciążenie polegające na dopasowaniu przez konwersję; tj. w celu niejawnego usunięcia szeregu niejawnych dopasowań konwersji poprzez implementację tylko dopasowań dokładnych typów w wyraźnej specjalizacji niezdefiniowanego, nie przeciążonego szablonu funkcji podstawowej.

Przed koncepcją usuniętej funkcji w C ++ 11 można to zrobić, po prostu pomijając definicję szablonu funkcji podstawowej, ale dawało to niejasne, nieokreślone błędy referencyjne, które prawdopodobnie nie dawały żadnej intencji semantycznej autorowi szablonu funkcji podstawowej (celowo pominięto ?). Jeśli zamiast tego jawnie usuniemy szablon funkcji podstawowej, komunikaty o błędach w przypadku, gdy nie zostanie znaleziona odpowiednia wyraźna specjalizacja, staną się znacznie przyjemniejsze, a także pokażą, że pominięcie / usunięcie definicji szablonu funkcji podstawowej było celowe.

#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< ...
}

Jednak zamiast po prostu pominąć definicję powyższego szablonu funkcji podstawowej, powodując niejasny, niezdefiniowany błąd odniesienia, gdy żadna wyraźna specjalizacja nie pasuje, podstawową definicję szablonu można usunąć:

#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; */
}

Daje bardziej czytelny komunikat o błędzie, w którym zamiar usunięcia jest również wyraźnie widoczny (gdzie nieokreślony błąd odniesienia może prowadzić do tego, że programista uzna to za nierozważny błąd).

Wracając do tego, dlaczego mielibyśmy chcieć korzystać z tej techniki? Ponownie, wyraźne specjalizacje mogą być przydatne do niejawnego usuwania niejawnych konwersji.

#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; */
}

Jest to nowa rzecz w standardach C ++ 0x, w której można usunąć odziedziczoną funkcję.