Блог

Чтобы предотвратить копирование класса, вы можете очень легко объявить частный конструктор копирования / операторы присваивания. Но вы также можете наследовать boost::noncopyable .

Каковы преимущества / недостатки использования boost в этом случае?

Я не вижу никакой пользы от документации:

 #include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
};
  

против:

 struct A
{
     A(const Aamp;) = delete;
     Aamp; operator=(const Aamp;) = delete;
};
  

Когда вы добавляете типы только для перемещения, я даже вижу, что документация вводит в заблуждение. Следующие два примера не копируются, хотя они являются подвижными:

 #include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
    A(Aamp;amp;) = default;
    Aamp; operator=(Aamp;amp;) = default;
};
  

против:

 struct A
{
    A(Aamp;amp;) = default;
    Aamp; operator=(Aamp;amp;) = default;
};
  

При множественном наследовании может быть даже штраф за пробел:

 #include <boost/noncopyable.hpp>

struct A
    : private boost::noncopyable
{
};

struct B
    : public A
{
    B();
    B(const Bamp;);
    Bamp; operator=(const Bamp;);
};

struct C
    : public A
{
};

struct D
    : public B,
      public C,
      private boost::noncopyable
{
};

#include <iostream>

int main()
{
    std::cout << sizeof(D) << 'n';
}
  

Для меня это выводит:

 3
  

Но это, я считаю, имеет превосходную документацию:

 struct A
{
    A(const Aamp;) = delete;
    Aamp; operator=(const Aamp;) = delete;
};

struct B
    : public A
{
    B();
    B(const Bamp;);
    Bamp; operator=(const Bamp;);
};

struct C
    : public A
{
    C(const Camp;) = delete;
    Camp; operator=(const Camp;) = delete;
};

struct D
    : public B,
      public C
{
    D(const Damp;) = delete;
    Damp; operator=(const Damp;) = delete;
};

#include <iostream>

int main()
{
    std::cout << sizeof(D) << 'n';
}
  

Выводит:

 2
  

Мне гораздо проще объявлять свои операции копирования, чем рассуждать о том, извлекаю ли я из boost::non_copyable нескольких раз и будет ли это мне стоить. Особенно, если я не являюсь автором полной иерархии наследования.

Резюмируя то, что сказали другие:

Преимущества boost::noncopyable более частных методов копирования:

1. Он более явный и описательный по замыслу. Использование частных функций копирования — это идиома, для определения которой требуется больше времени, чем noncopyable .
2. Меньше кода / меньше ввода / меньше беспорядка / меньше места для ошибок (проще всего было бы случайно предоставить реализацию).
3. Он встраивает значение прямо в метаданные типа, подобно атрибуту C #. Теперь вы можете написать функцию, которая принимает только объекты, которые не подлежат копированию.
4. Он потенциально улавливает ошибки ранее в процессе сборки. Ошибка будет представлена во время компиляции, а не во время компоновки, в случае, если сам класс или друзья класса выполняют ошибочное копирование.
5. (почти так же, как # 4) Не позволяет самому классу или друзьям класса вызывать методы частного копирования.

Преимущества методов частного копирования по сравнению boost::noncopyable :

1. Нет зависимости от boost

Это делает намерение явным и ясным, в противном случае нужно увидеть определение класса и выполнить поиск объявления, связанного с семантикой копирования, а затем искать спецификатор доступа, в котором он объявлен, чтобы определить, является ли класс не копируемым или нет. Другой способ обнаружить это, написав код, для которого требуется включить семантику копирования, и увидеть ошибку компиляции.

1. Цель boost::noncopyable понятнее.
2. Boost::noncopyable предотвращает случайное использование методами классов конструктора частного копирования.
3. Меньше кода с boost::noncopyable.

Я не могу понять, почему никто больше не упоминает об этом, но:

При noncopyable этом вы пишете имя своего класса только один раз.

Без пятикратного дублирования: один A для «класса A», два для отключения присваивания и два для отключения конструктора копирования.

Цитирование документации:

«Традиционный способ справиться с этим — объявить частный конструктор копирования и присвоение копирования, а затем документировать, почему это делается. Но вывод из noncopyable проще и понятнее и не требует дополнительной документации. «

http://www.boost.org/libs/utility/utility.htm#Class_noncopyable

Одним из конкретных преимуществ (помимо более четкого выражения ваших намерений) является то, что ошибка будет обнаружена раньше, на этапе компиляции, а не на этапе ссылки, если функция-член или друг попытается скопировать объект. Конструктор / назначение базового класса нигде не доступны, что приводит к ошибке компиляции.

Это также предотвращает случайное определение функций (т. Е. Ввод {} вместо ; ), небольшая ошибка, которая вполне может остаться незамеченной, но которая затем позволит участникам и друзьям создавать недопустимые копии объекта.