Есть у меня маленький класс Handle, реализующий RAII для виндового типа HANDLE (общий тип для объектов ядра). Сам тип HANDLE определен в винде, как void *. В моем классе, как положено, есть конструктор с параметром типа HANDLE, и метод operator HANDLE.

Все было прекрасно, пока я однажды не написал:

HANDLE Sync = (Timer != 0)? Timer : Event;

где Timer — объект класса Handle, а Event — обычная переменная типа HANDLE.

Я ожидал, что компилятор преобразует Timer к HANDLE, а он, наоборот, преобразует Event к объекту класса Handle, создавая временный объект, и тут же уничтожая его, что приводит к вызову деструктора и закрытию хэндла.

Такая же хрень происходит, если вместо HANDLE использовать int или другой интегральный тип.

Можно ли как-то указать в классе, чтобы в подобных случаях объект преобразовывался к простому типу через соответствующий метод, а не наоборот?

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>HANDLE Sync = (Timer != 0)? Timer : Event;

ЕМ>где Timer — объект класса Handle, а Event — обычная переменная типа HANDLE.

ЕМ>Я ожидал, что компилятор преобразует Timer к HANDLE, а он, наоборот, преобразует Event к объекту класса Handle, создавая временный объект,

Если объявить конструктор вашего класса Handle как explicit, то автоматических преобразований не будет

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Можно ли как-то указать в классе, чтобы в подобных случаях объект преобразовывался к простому типу через соответствующий метод, а не наоборот?

Как уже подсказали, у тебя проблема в дизайне обертки и архитектуры класса в целом. Класс обертка Handle (вызывающий закрытие хендла в деструкторе) — владеющий, а просто объект HANDLE — нет. Очень опасно делать класс обертку с конструктором который неявно может принимать HANDLE. Сделай дизайн похожим на unique_ptr, если хендл у тебя не шарится вовсе, типа такого:

    class Handle
    {
    public:

        ////////////////////////////////////////////////////////////////////////////////////////////
        // Construction/Destruction

        explicit Handle(HANDLE = nullptr);
        Handle(Handle&& that) noexcept = default;
       
        ////////////////////////////////////////////////////////////////////////////////////////////
        // Public methods

        void swap(Handle& that) noexcept;
        Handle& operator=(Handle&& that) noexcept = default;

        operator HANDLE() const noexcept;
        HANDLE Detach();
        void Close();

    private:

        ////////////////////////////////////////////////////////////////////////////////////////////
        // Data members

        std::unique_ptr<void, void(*)(HANDLE)> m_handle; // Native handle wrapper
    };



    ////////////////////////////////////////////////////////////////////////////////////////////////
    // Construction/Destruction

    inline Handle::Handle(HANDLE handle)
    :   m_handle(handle, &sys::CloseHandle)
    {
    }



    ////////////////////////////////////////////////////////////////////////////////////////////////
    // Public methods

    inline void Handle::swap(Handle& that) noexcept
    {
        swap(m_handle, that.m_handle);
    }



    ////////////////////////////////////////////////////////////////////////////////////////////////
    inline Handle::operator HANDLE() const noexcept
    {
        return m_handle.get();
    }



    ////////////////////////////////////////////////////////////////////////////////////////////////
    inline HANDLE Handle::Detach() noexcept
    {
        return m_handle.release();
    }



    ////////////////////////////////////////////////////////////////////////////////////////////////
    inline void Handle::Close()
    {
        m_handle.reset();
    }

Или можно без explicit в конструкторе, но тогда уже с ::DuplicateHandle в конструкторе копирования и подсчетом ссылок.

Во дела!

ЕМ>Можно ли как-то указать в классе, чтобы в подобных случаях объект преобразовывался к простому типу через соответствующий метод, а не наоборот?

Мне кажется нет

Только:
HANDLE Sync = (Timer != 0) ? (HANDLE) Timer : Event;

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Я ожидал, что компилятор преобразует Timer к HANDLE, а он, наоборот, преобразует Event к объекту класса Handle, создавая временный объект, и тут же уничтожая его, что приводит к вызову деструктора и закрытию хэндла.

ЕМ>Такая же хрень происходит, если вместо HANDLE использовать int или другой интегральный тип.

ЕМ>Можно ли как-то указать в классе, чтобы в подобных случаях объект преобразовывался к простому типу через соответствующий метод, а не наоборот?

Конструктор Handle надо бы сделать explicit

Здравствуйте, Евгений Музыченко, Вы писали:

По существу уже подсказали.
Впрочем explicit конструкторы по умолчанию это хороший принцип.

Может возьмёте готовое решение чем писать который раз тот же код ?
https://github.com/microsoft/wil

Здравствуйте, Zhendos, Вы писали:

Z>Если объявить конструктор вашего класса Handle как explicit, то автоматических преобразований не будет

Спасибо, помогло. Теперь вспомнил, что в разное время несколько раз читал про explicit, но пользоваться не приходилось, и в нужный момент не вспомнилось.

Здравствуйте, _NN_, Вы писали:

_NN>Может возьмёте готовое решение чем писать который раз тот же код ?

Не люблю добавлять зависимости без крайней нужды. Если б какой сложный алгоритм, то имело бы смысл подключить библиотеку, а так я и этот Handle сделал исключительно для вящей красоты.

Z>>Если объявить конструктор вашего класса Handle как explicit, то автоматических преобразований не будет

ЕМ>Спасибо, помогло. Теперь вспомнил, что в разное время несколько раз читал про explicit, но пользоваться не приходилось, и в нужный момент не вспомнилось.

Да проще его тогда вообще не объявлять

А присвоения через void operator = (HANDLE q); сделать

Здравствуйте, TailWind, Вы писали:

TW>Да проще его тогда вообще не объявлять
TW>А присвоения через void operator = (HANDLE q); сделать

Тогда нельзя будет определить константный объект.

Здравствуйте, Евгений Музыченко, Вы писали:

ЕМ>Есть у меня маленький класс Handle, реализующий RAII для виндового типа HANDLE (общий тип для объектов ядра).

А я для этой цели пользуюсь напрямую std::unique_ptr без оберток:

typedef std::unique_ptr<std::remove_pointer<HANDLE>, decltype(&::CloseHandle)> handle_holder_t;

Здравствуйте, qaz77, Вы писали:


Q>А я для этой цели пользуюсь напрямую std::unique_ptr без оберток:

Q>

typedef std::unique_ptr<std::remove_pointer<HANDLE>, decltype(&::CloseHandle)> handle_holder_t;

C++20 путь:

using handle_holder_t = std::unique_ptr<std::remove_pointer<HANDLE>, decltype([](HANDLE h) { ::CloseHandle(h); })>;

Лябмды без состояния конструируемы по умолчанию.
Преимущества:
* не присваивать постоянно указатель на CloseHandle.
* размер: подлежит оптимизации пустого функтора через базу или [no_unique_address]], если unique_ptr её реализует

Здравствуйте, Alexander G, Вы писали:

AG>не присваивать постоянно указатель на CloseHandle.

Что значит "не присваивать постоянно"?

Здравствуйте, Alexander G, Вы писали:

AG>Лябмды без состояния конструируемы по умолчанию.
AG>Преимущества:
AG>* не присваивать постоянно указатель на CloseHandle.
AG>* размер: подлежит оптимизации пустого функтора через базу или [no_unique_address]], если unique_ptr её реализует

Все классно, только не понятно зачем тут С++20, кроме как для краткости ?!

#include <iostream>
#include <memory>

// Just workaround

using HANDLE = void*;
void CloseHandle(HANDLE handle)
{
    // ...
}

// Handle wrappper

struct HanleDeleter {
        void operator()(HANDLE handle) noexcept { CloseHandle(handle); };
};

using handle_holder_t = std::unique_ptr<std::remove_pointer<HANDLE>, HanleDeleter>;

int main() 
{
    handle_holder_t handle;
    return 0;
}

Здравствуйте, Videoman, Вы писали:


V>Все классно, только не понятно зачем тут С++20, кроме как для краткости ?![ccode]

Да, для краткости, чтобы в одну строчку лямбу написать, а не во внешней структуре.

Здравствуйте, Евгений Музыченко, Вы писали:


ЕМ>Что значит "не присваивать постоянно"?

Тип

typedef std::unique_ptr<std::remove_pointer<HANDLE>, decltype(&::CloseHandle)> handle_holder_t;

означает, что в unique_ptr будет использован в качестве удалителя функция с такой же сигнатурой, как ::CloseHandle.

Сам указатель на CloseHandle надо ещё передавать отдельно при конструировании/присвоении.

Это, ну, не очень удобно.

Здравствуйте, Alexander G, Вы писали:

AG>Сам указатель на CloseHandle надо ещё передавать отдельно при конструировании/присвоении.

А, понятно. Я никогда не пользовался unique_ptr и подобными шаблонами из std — не люблю этого многокаскадного шаманства. Но вместо него можно сделать простенький универсальный шаблонный класс с параметрами типа значения и указателя на функцию, которая вызывается с этим значением. Оптимизатор VC++ даже достаточно умен, чтобы вызывать ее статически, если указатель передан непосредственно.