if x in (1,2,4,6,7):
  print('x is either 1,2,4,6 or 7')
else:
  print('x is something else')

#include <iostream>
using namespace std;

template<typename T>
bool in(T value, T last)
{
    if (value == last)
        return true;
    return false;
}

template<typename T, typename... Args>
bool in(T value, T first, Args... args)
{
    if (value == first)
        return true;
    return in(value, args...);
}

int main()
{
    if (in(5, 1, 2, 4, 6, 7))
        cout << "5 in 1, 2, 4, 6, 7" << endl;
    else
        cout << "5 not in 1, 2, 4, 6, 7" << endl;
    if (in(4, 1, 2, 4, 6, 7))
        cout << "4 in 1, 2, 4, 6, 7" << endl;        
    else
        cout << "4 not in 1, 2, 4, 6, 7" << endl;        
    return 0;
}

MP>if x in (1,2,4,6,7):
MP>  print('x is either 1,2,4,6 or 7')
MP>else:
MP>  print('x is something else')

MP>

template <typename T, typename...U>
bool in(T&& t, U&&...u) {
    return ((t == u) || ...);
}

template<typename T>
bool in_list(T x, T v) {
  return x == v;
}

template<typename T, typename... Args>
bool in_list(T x, T first, Args... args) {
  return x == first || in_list(x, args...);
}

if std::set({1,2,4,6,7}).count(x)
    std::cout << "x is either 1,2,4,6 or 7" << std::endl;

GC>    if (value == last)
GC>        return true;
GC>    return false;
GC>

    return value == last;

template<typename T>
bool in_list( const T& needle, const std::initializer_list<T>& haystack ) {
  return std::find( haystack.begin(), haystack.end(), needle ) != haystack.end();
}

if ( in_list( k, {3,6,some_var,foo()} ) {
  // ...
} else {
  // ...
}

MP>Независимо от вас написал

MP>template<typename T>
MP>bool in_list(T x, T v) {
MP>  return x == v;
MP>}

MP>template<typename T, typename... Args>
MP>bool in_list(T x, T first, Args... args) {
MP>  return x == first || in_list(x, args...);
MP>}
MP>

template<typename T>
bool in_list(T&&) {
  return false;
}

template<typename T, typename... Args>
bool in_list(T&& x, T&& first, Args&&... args) {
  return x == first || in_list(x, args...);
}

MP>if x in (1,2,4,6,7):
MP>  print('x is either 1,2,4,6 or 7')
MP>else:
MP>  print('x is something else')

MP>

#include <algorithm>
#include <vector>
#include <array>
#include <iostream>

const struct in_op final
{
    template<typename T>
    struct impl
    {
        T const& x;

        template<typename Container>
        bool operator>(Container const& c) const
        {
            return std::find(std::begin(c), std::end(c), x) != std::end(c);
        }
    };

    template<typename T>
    friend auto operator<(T const &x, in_op)
    {
        return impl<T>{x};
    }
} in;

int main()
{
    const std::array<int, 3>         a{ 1, 2, 3 };
    const std::vector<int>           b{ 1, 2, 3 };
    const std::initializer_list<int> c{ 5, 6, 7 };
    
    std::cout << "5 in { 1, 2, 3 } = " << std::boolalpha << (5 <in> a) << '\n';
    std::cout << "2 in { 1, 2, 3 } = " << std::boolalpha << (2 <in> b) << '\n';
    std::cout << "7 in { 5, 6, 7 } = " << std::boolalpha << (7 <in> c) << '\n';
    return 0;
}

5 in { 1, 2, 3 } = false
2 in { 1, 2, 3 } = true
7 in { 5, 6, 7 } = true

MP>if x in (1,2,4,6,7):
MP>  print('x is either 1,2,4,6 or 7')
MP>else:
MP>  print('x is something else')

MP>

#include <iostream>
#include <initializer_list>
#include <algorithm>

int main() {
    
    int x = 7;
    
    if (const auto a = {1,2,4,6,7}; a.end() != std::find(a.begin(), a.end(), x) )
      std::cout << "x is either 1,2,4,6 or 7" << std::endl;
    else
      std::cout << "x is something else" << std::endl;
    
    // your code goes here
    return 0;
}

for(auto n : {1,2,4,6,7})
  if ( x == n )
  {
    std::cout << "x is either 1,2,4,6 or 7" << std::endl;
    break;
  }

J>>if std::set({1,2,4,6,7}).count(x)
J>>    std::cout << "x is either 1,2,4,6 or 7" << std::endl;

J>>

if (boost::algorithm::any_of_equal(std::initializer_list<int>{1,2,4,6,7}, x))
    std::cout << "x is either 1,2,4,6 or 7" << std::endl;

#include <iostream>
#include <vector>
#include <array>
#include <ranges>
#include <algorithm>
#include <string>
#include <concepts>

using namespace std::literals::string_literals;

// concepts-style
template<typename T, std::ranges::range Container>
     requires requires (const T& value,  const Container& cnt) { value==*std::begin(cnt); }  // Можно как-то по проще написать?
bool in_range( const T& value,  const Container& cnt )
{
    return std::ranges::find( cnt, value ) != std::ranges::end( cnt );
}



// old-style
template<typename T, typename Container>
auto in_any_container( const T& value,  const Container& cnt )
    -> decltype( value== *std::begin(cnt) ) // hand-make constrait!
{
    for( auto& v : cnt )
        if(v==value)
            return true;
    return false;
}


int main()
{
// Success cases:
    std::vector<int> vect{1,2,3};
    std::cout<< in_range(1, vect ) <<std::endl;
    std::cout<< in_any_container(1, vect ) <<std::endl;
    std::cout<< std::ranges::count( vect, 1 ) <<std::endl;
    
    
    int c_array[]={1,2,3};
    std::cout<< in_range(1, c_array ) <<std::endl;
    std::cout<< in_any_container(1, c_array ) <<std::endl;
    std::cout<< std::ranges::count( c_array, 1 ) <<std::endl;
    
    
    std::cout<< in_range(1, std::initializer_list{1,2,3} ) <<std::endl;
    std::cout<< in_any_container(1, std::initializer_list{1,2,3} ) <<std::endl;
    std::cout<< std::ranges::count( std::initializer_list{1,2,3}, 1 ) <<std::endl;
    
    std::cout<< in_range(1,         std::array{1,2,3} ) <<std::endl;
    std::cout<< in_any_container(1, std::array{1,2,3} ) <<std::endl;
    std::cout<< std::ranges::count( std::array{1,2,3}, 1 ) <<std::endl;
    
// Error cases:

    std::cout<< in_range("1"s,         vect       ) <<std::endl;
/*
prog.cc: In function 'int main()':
prog.cc:58:51: error: no matching function for call to 'in_range(std::__cxx11::basic_string<char>, std::vector<int>&)'
   58 |     std::cout<< in_range("1"s,         vect       ) <<std::endl;
      |                                                   ^
prog.cc:14:6: note: candidate: 'bool in_range(const T&, const Container&) [with T = std::__cxx11::basic_string<char>; Container = std::vector<int>]'
   14 | bool in_range( const T& value,  const Container& cnt )
      |      ^~~~~~~~    
...
*/

    std::cout<< in_any_container("1"s, vect       ) <<std::endl;
/*
prog.cc: In function 'int main()':
prog.cc:59:51: error: no matching function for call to 'in_any_container(std::__cxx11::basic_string<char>, std::vector<int>&)'
   59 |     std::cout<< in_any_container("1"s, vect       ) <<std::endl;
      |                                                   ^
prog.cc:23:6: note: candidate: 'template<class T, class Container> decltype ((value == (* std::begin(cnt)))) in_any_container(const T&, const Container&)'
   23 | auto in_any_container( const T& value,  const Container& cnt )
      |      ^~~~~~~~~~~~~~~~
...
*/
    std::cout<< std::ranges::count(    vect, "1"s ) <<std::endl;
/*
prog.cc: In function 'int main()':
prog.cc:60:51: error: no match for call to '(const std::ranges::__count_fn) (std::vector<int>&, std::__cxx11::basic_string<char>)'
   60 |     std::cout<< std::ranges::count(    vect, "1"s ) <<std::endl;
      |                                                   ^
In file included from /opt/wandbox/gcc-head/include/c++/10.0.1/algorithm:64,
                 from prog.cc:5:
/opt/wandbox/gcc-head/include/c++/10.0.1/bits/ranges_algo.h:369:7: note: candidate: 'template<class _Iter, class _Sent, class _Tp, class _Proj>  requires (input_iterator<_Iter>) && (sentinel_for<_Sent, _Iter>) && (indirect_binary_predicate<std::ranges::equal_to, std::projected<_I1, _P1>, const _Tp*>) constexpr std::iter_difference_t<_Iter> std::ranges::__count_fn::operator()(_Iter, _Sent, const _Tp&, _Proj) const'
  369 |       operator()(_Iter __first, _Sent __last,
      |       ^~~~~~~~
*/

    return 0;
}

if ( {1,2,4,6,7} | std::ranges::count(x) )
  ....

if ( ({1,2,4,6,7} | std::views::filter([x](int i){ return x == i; })).size() )
  ....

#include <iostream>
using namespace std;

template<typename T, typename... Args>
bool in(T value, Args... args)
{
    return ((value == args) || ...);
}

int main()
{
    if (in(5, 1, 2, 4, 6, 7))
        cout << "5 in 1, 2, 4, 6, 7" << endl;
    else
        cout << "5 not in 1, 2, 4, 6, 7" << endl;
    if (in(4, 1, 2, 4, 6, 7))
        cout << "4 in 1, 2, 4, 6, 7" << endl;        
    else
        cout << "4 not in 1, 2, 4, 6, 7" << endl;        
    return 0;
}

#include "range/v3/algorithm/contains.hpp"
#include <array>

int main() {
  if( ranges::contains(std::array{1,2,3,4,5,6}, 42) ) {
      return 0;
  }
  return 1;
}

int main() {
    int x {};
    std::cin >> x;
    if( ranges::contains(std::array{1,2,3,4,5,6}, x) ) {
        return 0;
    }
    return 1;
}

template <typename T, typename...U>
bool in_list(T&& t, U&&...u) {
    return ((t == u) || ...);
}

int main() {
    int x {};
    std::cin >> x;
    if( in_list(x,1,2,3,4,5,6) ) {
        return 0;
    }
    return 1;
}