Должен ли я использовать указатель на объект или объект, когда объект представляет собой компонент оборудования?

Question

У меня есть класс под названием Camera, который открывает в конструкторе камеру с v4l2_open и т. Д. Деструктор выполняет некоторую очистку и закрывает дескриптор файла с помощью v4l2_close.

Когда происходит сбой камеры, что я делаю, чтобы удалить объект, а затем создать новый:

Camera *camera = new Camera(); 
(...) 
if (crash) { 
    delete camera; 
    camera = new Camera(); 
} 

Это один из правильного использования новых/удаления в C++?

Answer 1

Нет, использование new и delete здесь не является обязательным. Если ваша камера «плохая», и вы хотите избавиться от нее в пользу новой, просто назначьте новую.

const std::string device {"/dev/cameras/front"}; // whatever 
Camera camera {device}; 
// do something... 
if (camera.bad()) 
    camera = Camera {device}; // replace by a new one 

Вы, вероятно, хотите overload the assignment operator вашего Camera класса для этой работы. Поскольку класс Camera является ресурсоемким, его нельзя копировать, а перемещать. Я не знаю, как вы разговариваете с аппаратными средствами, поэтому я сделал следующий пример немного, но он должен дать вам правильную идею о том, как реализовать свой тип.

extern "C" 
{ 
    // I have made these up... 
    int camera_open(const char *); 
    int camera_close(int); 
} 

class Camera 
{ 

private: 

    // Initially set to arbitrary nonsensical values. 
    std::string device_ {}; 
    int fd_ {-1}; 

public: 

    Camera() noexcept 
    { 
    } 

    Camera(const std::string& device) : device_ {device} 
    { 
    this->open(); 
    } 

    ~Camera() noexcept 
    { 
    try 
     { 
     this->close(); 
     } 
    catch (const std::exception& e) 
     { 
     // Cannot throw from a destructor... 
     std::cerr << e.what() << std::endl; 
     } 
    } 

    Camera(const Camera&) = delete; // not copy-constructible 

    Camera(Camera&& other) : Camera {} 
    { 
    swap(*this, other); 
    } 

    Camera& operator=(const Camera&) = delete; // not copy-assignable 

    Camera& 
    operator=(Camera&& other) noexcept 
    { 
    Camera tmp {}; 
    swap(*this, tmp); 
    swap(*this, other); 
    return *this; 
    } 

    friend void 
    swap(Camera& first, Camera& second) noexcept 
    { 
    using std::swap; 
    swap(first.device_, second.device_); 
    swap(first.fd_, second.fd_); 
    } 

    void 
    reopen() 
    { 
    this->close(); 
    this->open(); 
    } 

    void 
    open(const std::string& device = "") 
    { 
    if (this->fd_ >= 0) 
     throw std::runtime_error {"camera already open"}; 
    if (!device.empty()) 
     this->device_ = device; 
    if (this->device_.empty()) 
     throw std::runtime_error {"no associated device"}; 
    this->fd_ = camera_open(this->device_.c_str()); 
    if (this->fd_ < 0) 
     throw std::runtime_error {"cannot open camera"}; 
    } 

    void 
    close() 
    { 
    if (this->fd_ >= 0) 
     { 
     if (camera_close(this->fd_) != 0) 
      throw std::runtime_error {"cannot close camera"}; 
     this->fd_ = -1; 
     } 
    } 
}; 

Но вы уверены, что это действительно хорошее дизайнерское решение в первую очередь? Может быть, камера может просто «перезагрузить» себя, когда это необходимо, и вообще не беспокоить пользователя этой деталью реализации?