Определяемый пользователем класс перечисления С++ 11 Конструктор по умолчанию

Тип, определенный с помощью enum class или enum struct, является не классом, а перечислением с ограниченной областью действия, и для него не может быть определен конструктор по умолчанию. Стандарт C++11 определяет, что ваш оператор PinID pid = PinID(); даст нулевую инициализацию. Где PinID был определен как enum class. Это также позволяет типам перечисления вообще содержать значения, отличные от констант перечислителя.

Чтобы понять, что PinID() дает нулевую инициализацию, необходимо вместе прочитать стандартные разделы 3.9.9, 8.5.5, 8.5.7 и 8.5.10:

8.5.10 - An object whose initializer is an empty set of parentheses, i.e., (), shall be value-initialized

8.5.7 - To value-initialize an object of type T means: ... otherwise, the object is zero-initialized.

8.5.5 - To zero-initialize an object or reference of type T means: — if T is a scalar type (3.9), the object is set to the value 0 (zero), taken as an integral constant expression, converted to T;

3.9.9. Указывает, что перечисляемые типы являются частью набора типов, известных как скалярные типы.

Возможное решение:

Чтобы выполнить ваши пункты с 1 по 5, вы можете написать класс в следующем порядке:

class PinID
{
private:
    PinID(int val)
    : m_value(val)
    {}

    int m_value;

public:
    static const PinID N4;
    static const PinID N17;
    /* ...etc... */ 

    PinID() 
    : m_value(N4.getValue())
    {}

    PinID(const PinID &id)
    : m_value(id.getValue())
    {}

    PinID &operator = (const PinID &rhs)
    {
        m_value = rhs.getValue();
        return *this;
    }

    int getValue() const
    {
        return m_value;
    }

    // Attempts to create from int and throw on failure.
    static PinID createFromInt(int i);

    friend std::istream& operator>>(std::istream &is, PinID &v)
    {
        int candidateVal(0);
        is >> candidateVal;
        v = PinID::createFromInt(candidateVal);
        return is;
    }
};

const PinID PinID::N4 = PinID(4);
/* ...etc... */

Это может дать вам то, что вам придется приложить определенные усилия, чтобы получить недопустимые значения. Конструктор по умолчанию и оператор потока должны позволять ему работать с lexical_cast.

Кажется, это зависит от того, насколько критичны операции с PinID после его создания, стоит ли писать класс или просто обрабатывать недопустимые значения везде, где используется значение.

enum class — это просто строго типизированный enum; это не class. C++11 просто повторно использовал существующее ключевое слово class, чтобы избежать введения нового ключевого слова, которое нарушило бы совместимость с устаревшим кодом C++.

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

int x;
std::cin >> x;
auto p = static_cast<PinID>(x);

Это совершенно законно, и нет никакого способа статически убедиться, что пользователь консоли поступил правильно.

Вместо этого вам нужно будет проверить во время выполнения, что значение допустимо. Чтобы обойти это автоматизированным способом, один из моих коллег создал генератор enum, который создает эти проверки, а также другие полезные подпрограммы, учитывая файл со значениями перечисления. Вам нужно будет найти решение, которое работает для вас.

Я знаю, что этот вопрос устарел и что на него уже есть принятый ответ, но вот метод, который может помочь в такой ситуации с некоторыми из новых функций С++.

Вы можете объявить переменную этого класса либо non static, либо static, это можно сделать несколькими способами, разрешенными при поддержке вашего текущего компилятора.

Нестатические:

#include <iostream>
#include <array>

template<unsigned... IDs>
class PinIDs {
private:
    const std::array<unsigned, sizeof...(IDs)> ids { IDs... };
public:
    PinIDs() = default;
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

Статический: - Есть 3 способа написать это: (Первый - C++11 или 14 или выше) последние 2 (C++17).

Не цитируйте меня в части C++11; Я не совсем уверен, когда впервые появились вариативные шаблоны или пакеты параметров.

template<unsigned... IDs>
class PinIDs{
private:        
    static const std::array<unsigned, sizeof...(IDs)> ids;
public:    
    PinIDs() = default;    
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

template<unsigned... IDs>
const std::array<unsigned, sizeof...(IDs)> PinIDs<IDs...>::ids { IDs... };

template<unsigned... IDs>
class PinIDs{
private:
    static constexpr std::array<unsigned, sizeof...(IDs)> ids { IDs... }; 
public:   
    PinIDs() = default;    
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

template<unsigned... IDs>
class PinIDs{
private:
    static inline const std::array<unsigned, sizeof...(IDs)> ids { IDs... };
public:    
    PinIDs() = default;    
    const unsigned& operator[]( unsigned idx ) const {
        if ( idx < 0 || idx > ids.size() - 1 ) {
            return -1;
        }
        return ids[idx];
    }
};

Все приведенные выше примеры, как нестатические, так и статические, работают с одним и тем же вариантом использования ниже и дают правильные результаты:

int main() {
    PinIDs<4, 17, 19> myId;

    std::cout << myId[0] << " ";
    std::cout << myId[1] << " ";
    std::cout << myId[2] << " ";

    std::cout << "\nPress any key and enter to quit." << std::endl;
    char c;
    std::cin >> c;

    return 0;
}

Вывод

4 17 19
Press any key and enter to quit.

С этим типом шаблона класса, использующего вариативный список параметров, вам не нужно использовать какой-либо конструктор, кроме конструктора по умолчанию. Я добавил в массив проверку границ, чтобы operator[] не превышала границ своего размера; Я мог бы выдать ошибку, но с типом unsigned я просто вернул -1 как недопустимое значение.

С этим типом нет значения по умолчанию, так как вам нужно создать экземпляр объекта такого типа через список параметров шаблона с одним или набором значений. Если кто-то хочет, они могут specialize this class с одним параметром 0 для типа по умолчанию. Когда вы создаете экземпляр этого типа объекта; он окончательный, так как его нельзя изменить из его объявления. Это константный объект, который по-прежнему считается конструируемым по умолчанию.