void adns__querysend_tcp(adns_query qu, struct timeval now) {
  ...
  if (!(errno == EAGAIN || EWOULDBLOCK || 
        errno == EINTR || errno == ENOSPC ||
        errno == ENOBUFS || errno == ENOMEM)) {
  ...
}

if (!(   errno == EAGAIN
      || EWOULDBLOCK
      || errno == EINTR
      || errno == ENOSPC
      || errno == ENOBUFS
      || errno == ENOMEM)) {

if (!(errno is in (
                       EAGAIN,
                       EWOULDBLOCK,
                       EINTR,
                       ENOSPC,
                       ENOBUFS,
                       ENOMEM
                   ))
{
...
}

A>if (!(   errno == EAGAIN
A>      || EWOULDBLOCK
A>      || errno == EINTR
A>      || errno == ENOSPC
A>      || errno == ENOBUFS
A>      || errno == ENOMEM)) {
A>

A>if (!(errno is in (
A>                       EAGAIN,
A>                       EWOULDBLOCK,
A>                       EINTR,
A>                       ENOSPC,
A>                       ENOBUFS,
A>                       ENOMEM
A>                   ))
A>{
A>...
A>}
A>

#include <errno.h>

template <auto... set>
bool isin(auto val)
{
    return (false || ... || (set == val));
}

int main() 
{
    // 
    if(isin<EAGAIN,
            EWOULDBLOCK,
            EINTR,
            ENOSPC,
            ENOBUFS,
            ENOMEM>(errno))
    {
        return 0;
    }

    return 1;
}

return ( ... || (set == val));

A>>void adns__querysend_tcp(adns_query qu, struct timeval now) {
A>>  ...
A>>  if (!(errno == EAGAIN || EWOULDBLOCK || 
A>>        errno == EINTR || errno == ENOSPC ||
A>>        errno == ENOBUFS || errno == ENOMEM)) {
A>>  ...
A>>}
A>>

void adns__querysend_tcp(adns_query qu, struct timeval now) {
  auto is_err = false;
  switch(errno) {
    case EAGAIN:
    case EWOULDBLOCK:
    case EINTR:
    case ENOSPC:
    case ENOBUFS:
    case ENOMEM:
      is_err =  true;
  }
  if (!is_err) {

switch(errno)
    case EAGAIN:
    case EWOULDBLOCK:
    case EINTR:
    case ENOSPC:
    case ENOBUFS:
    case ENOMEM:
    {...}

У нас чего только может не быть. У нас всего может не быть. У нас чего только не захочешь, того может и не быть.

template<class T>
class The
{
    public:
        constexpr explicit The(const T& x) noexcept
          : _x(x)
        {
        }

        template <class... TArgs>
        bool one_of(TArgs&&... args) const
        {
            return ((_x == args) || ...);
        }

        template <auto... VArgs>
        bool one_of() const
        {
            return ((_x == VArgs) || ...);
        }

    public:
        const T& _x;
};

int main() 
{
    // 
    if ( The(errno).one_of<
                           EAGAIN,
                           EWOULDBLOCK,
                           EINTR,
                           ENOSPC,
                           ENOBUFS,
                           ENOMEM
                         >()
       )
    {
        return 0;
    }

    return 1;
}

    if ( The(m_phase).one_of<EPhase::eIdle, EPhase::ePauseBetweenSeries>() )

    return ! (std::isalnum(ch) || The(ch).one_of<'.', '-'>());

    int a = 3;
    int b = 4;
    int c = 5;
    int d = 5;

    std::cout << The(true).one_of(a == b, b == c, c == a) << std::endl;
    std::cout << The(true).one_of(a == b, b == c, c == d) << std::endl;

template<Mode... modeArgs>
inline bool MyClass::IsMode() const noexcept
{
    return ((m_mode == modeArgs) || ...);
}

  if ( IsMode<Mode::A>() )
    ...
  if ( IsMode<Mode::A, Mode::B>() )
    ...

A>void adns__querysend_tcp(adns_query qu, struct timeval now) {
A>  ...
A>  if (!(errno == EAGAIN || EWOULDBLOCK || 
A>        errno == EINTR || errno == ENOSPC ||
A>        errno == ENOBUFS || errno == ENOMEM)) {
A>  ...
A>}
A>

    if (errno == EAGAIN) {
        errno = EWOULDBLOCK;
    }

    switch (errno) {
    case EWOULDBLOCK:
    case EINTR:
    case ENOSPC:
    case ENOBUFS:
    case ENOMEM:
        . . . .
    }

switch(fileType) {
  case 0: ... break;
  case 1: ... break;
  case 2: ... break;
  case 3: ... break;
  case 4: ... break;
}

enum { C0,C1,C2,C3, C_MAX };

enum { B0=1,B1=2,B2=4,B3=8,B4=16,B5=32,B6=64,B7=128 };

_>>Не нравятся функции вынесите в макрос

struct E {
  enum { C0,C1,C2, C_MAX };
  static const char* to_chars(int id) {
    switch(id) {
    case C0: return "C0";
    case C1: return "C1";
    case C2: return "C2";
    }
    return 0;
  }
  static int count() { return C_MAX; }
  static int min() { return C0; }
  static int max() { return C_MAX-1; }
};

struct B {
  enum { B1=1,B2=2,B3=4, B_MASK=B1|B2|B3 };
  static void fmt(int v, void (*write)(void* ctx,const char* text), void *ctx) {
    if (v&B1) write(ctx,"B1");
    if (v&B2) write(ctx,"B2");
    if (v&B3) write(ctx,"B3");
  }
  static int mask() { return B_MASK; };
};

namespace Machine
{
enum Mode
{
  eAuto, eManual
};
}
typedef Machine::Mode MachineMode;

int fn(int i) {
  const int c1=1;
  enum { c2=2 };
  switch(i) {
  //case c1: return c1; // error: label does not reduce to an integer constant
  case c2: return c2;
  }
  return 0;
}

_>>Ваш const не совсем const, поэтому и используют другие способы

_>>int fn(int i) {
_>>  const int c1=1;
_>>  enum { c2=2 };
_>>  switch(i) {
_>>  //case c1: return c1; // error: label does not reduce to an integer constant
_>>  case c2: return c2;
_>>  }
_>>  return 0;
_>>}
_>>

extern const int a;
const int b=1;

const int a=0;

BFE>>И для этого они лежат в namespace.

ЕМ>>>Почему в обсуждаемом примере все идентификаторы начинаются на E?

BFE>>Предполагаю, что это сокращение от слова ERROR.

ЕМ>Изначально, напомню, инкапсуляции не было и для полей структур. Ее тоже зря сделали?

ЕМ>Я бы сказал, что уместнее использовать [static] const, а при невозможности — #define. Но это для разрозненных констант, от которых не ожидается какой-либо регулярности. Если же константы хотя бы в основе завязаны на перечисление, то вполне логично определять их в перечислении.

#include <iostream>
#include <stdexcept>

 constexpr int next(int n) { return 1 + n; }

 constexpr int asdf = 1;
 constexpr int asdg = next(asdf);
 
int main()
{
   std::cout << '\n';
   std::cout << "asdf = " << asdf;    
   std::cout << '\n';
   std::cout << "asdg = " << asdg;    
   
   
   constexpr int arr[asdg] = {asdf, asdg};
   
   int x = 2;
   switch(x)
   {
      case arr[0]:
          std::cout << '\n' << "arr[0] ";    
      break;
      
      case arr[1]:
          std::cout << '\n' << "arr[1]";    
      break;
   }
   
}

#include <iostream>
enum AB
 {
    a = 1,  
    b = 0xF0000000
};

enum CD
 {
    cd_c = 1,  
    cd_d = 0xF00000000
};
 
 
int main()
{
  if ( sizeof(a) == sizeof(cd_c) )
     std::cout << "yes";
  else     
     std::cout << "no";
}

BFE>#include <iostream>
BFE>enum AB
BFE> {
BFE>    a = 1,  
BFE>    b = 0xF0000000
BFE>};

BFE>enum CD
BFE> {
BFE>    cd_c = 1,  
BFE>    cd_d = 0xF00000000
BFE>};
 
 
BFE>int main()
BFE>{
BFE>  if ( sizeof(a) == sizeof(cd_c) )
BFE>     std::cout << "yes";
BFE>  else     
BFE>     std::cout << "no";
BFE>}    
BFE>

enum E1 { e1_c1=1 };
enum E2 { e2_c1=1 };

void fn(enum E1 e) { std::cout<<"fn.E1\n"; }
void fn(enum E2 e) { std::cout<<"fn.E2\n"; }
void fn(char e) { std::cout<<"fn.char\n"; }
void fn(signed char e) { std::cout<<"fn.schar\n"; }
void fn(unsigned char e) { std::cout<<"fn.uchar\n"; }
void fn(short e) { std::cout<<"fn.short\n"; }
void fn(int e) { std::cout<<"fn.int\n"; }
void fn(unsigned e) { std::cout<<"fn.uint\n"; }
void fn(long long e) { std::cout<<"fn.llong\n"; }

void test() {
    fn(e1_c1);
    fn(e2_c1);
    fn('\x01');
    fn(+'\x01');
    fn(1);
    fn((char)1);
    fn((unsigned char)1);
    fn((signed char)1);
    fn((short)1);
    fn(1u);
    fn(1LL);
    fn(+e1_c1);
    fn(+e2_c1);
}

fn.E1
fn.E2
fn.char
fn.int
fn.int
fn.char
fn.uchar
fn.schar
fn.short
fn.uint
fn.llong
fn.int
fn.int

_>extern const int a;
_>

template<class T>
struct some_metafunc {
  enum { value = 1 };
};

template<class T>
struct some_metafunc {
  static const bool value = true;
};

Image::register_plugin(jpg);
Image::register_plugin(png);
Image::register_plugin(gif);
Image::register_plugin(webm);

...

auto image=Image::load(filename);

    A oA{ .m_str = "55"};
    std::vector<char> vData;
    vData.push_back('5');
    vData.push_back('5');

    std::cout << oA.one_of("asdf", 5, 555, 5., vData) << std::endl;

#include <iostream>
#include <vector>
#include <optional>
#include <variant>


class A
{
  public:
    std::string m_str;    

    bool one_of(auto... args) const
    {
        return ((*this == args) || ...);
    }

};

inline bool operator == (const A& a, const char* strC)
{
    return a.m_str == std::string(strC);
}


inline bool operator == (const A& a, int n)
{
    return a.m_str == std::to_string(n);
}


inline bool operator == (const A& a, float f)
{
    return a.m_str == std::to_string(f);
}


inline bool operator == (const A& a, double f)
{
    return a.m_str == std::to_string(f);
}


inline bool operator == (const A& a, const std::vector<char>& v)
{
    return a.m_str == std::string(v.begin(), v.end());
}


int main()
{
    A oA{ .m_str = "55"};

    std::vector<char> vData;
    vData.push_back('5');
    vData.push_back('5');

    std::cout << oA.one_of("asdf", 5, 555, 5., vData) << std::endl;

    return 0;
}

constexpr int next(int n) { return 1 + n; }

constexpr int a = 1;
constexpr int b = next(a);
constexpr int c = next(b);
constexpr int d = c + 123;
constexpr int e = next(d);

Перечисляемый тип (сокращённо перечисле́ние, англ. enumeration, enumerated type) — в программировании тип данных, чьё множество значений представляет собой ограниченный список идентификаторов.

BFE>>    cd_d = 0xF00000000
BFE>>

ЕМ>Как раз тот случай, когда максимальный уровень предупреждений чертовски полезен.

ЕМ>Что, прям всей?

S>В общем, оно не работает. А я опять вляпался в известную субстанцию в попытках объяснить персонажам вроде вас очевидные вещи

#include <iostream>
using namespace std;

enum E {
    name1,
    name2,
    name3
};

template <template<enum E> class M>
static auto E_get_value(enum E e) {
    switch(e) {
        case name1: return M<name1>::value();
        case name2: return M<name2>::value();
        case name3: return M<name3>::value();
    }
    throw;
}

template <template<enum E> class... M>
static auto E_forall(auto fn) {
    fn(M<name1>::value()...);
    fn(M<name2>::value()...);
    fn(M<name3>::value()...);
}

template<enum E e>const char* Es();
template<>const char* Es<name1>() { return "name1"; }
template<>const char* Es<name2>() { return "name2"; }
template<>const char* Es<name3>() { return "name3"; }

template<enum E e>double Ed();
template<>double Ed<name1>() { return 1; }
template<>double Ed<name2>() { return 0.5; }
template<>double Ed<name3>() { return 3.14; }

template<enum E e>struct Ed_values;
template<>struct Ed_values<name1> { static double value() { return Ed<name1>(); }};
template<>struct Ed_values<name2> { static double value() { return Ed<name2>(); }};
template<>struct Ed_values<name3> { static double value() { return Ed<name3>(); }};

template<enum E e>struct Es_values;
template<>struct Es_values<name1> { static const char* value() { return Es<name1>(); }};
template<>struct Es_values<name2> { static const char* value() { return Es<name2>(); }};
template<>struct Es_values<name3> { static const char* value() { return Es<name3>(); }};

template<enum E e>struct Eb;
template<>struct Eb<name1> {
    template<class T>
    static void run(T t) { t(); }
};
template<>struct Eb<name2> {
    template<class T>
    static void run(T t) { try { t(); } catch(...) {} }
};
template<>struct Eb<name3> {
    template<class T>
    static void run(T t) { try { t(); } catch(...) { cerr<<"catch\n"; } }
};

int main(int argc, char const *argv[]) {
    // не целые константы
    cout<<(Es<name3>())<<"="<<(Ed<name3>())<<endl;
    // получение значение
    enum E e=name2; cout<<E_get_value<Ed_values>(e)<<endl;
    // перебираем все значения
    E_forall<Es_values,Ed_values>([](const char* name,double value){
        cout<<name<<"="<<value<<endl;
    });
    // выбираем алгоритм по имени
    Eb<name3>::run([]{ throw 0; });
    return 0;
}

name3=3.14
0.5
name1=1
name2=0.5
name3=3.14
catch