型特性
(src/base/traits.hpp)

• View this file on GitHub
• Last update: 2026-10-12 19:23:31+09:00
• Include: #include "src/base/traits.hpp"

ライブラリ内のテンプレートで使う型特性とマクロです。コンテナに対する関数 や repr が、コンテナのメンバ関数の有無で呼び分けるのに使っています。

static_assert(is_range_v<std::vector<int>>);
static_assert(has_sum_v<Range>);
template <class T, ENABLE_IF_T(std::is_integral_v<T>)>
T twice(T x) { return x * 2; }

型特性

名前	意味
is_range_v<T>	begin、end で走査できるか
is_sorted_container_v<T>	std::set / std::multiset か
has_repr_v<T>、has_type_str_v<T>、has_initializer_str_v<T>	同名のメンバ関数 (引数なし) を持つか
has_max_v<T>、has_min_v<T>、has_sum_v<T>、has_product_v<T>、has_product_xor_v<T>	同上
has_reversed_v<T>、has_sorted_v<T>	同上
has_count_v<T, U>、has_find_v<T, U>、has_lower_bound_v<T, U>、has_upper_bound_v<T, U>	U を引数に取る同名のメンバ関数を持つか
mem_value_type<C> / mem_difference_type<C>	C::value_type / C::difference_type

マクロ

マクロ	説明
ENABLE_IF_T(cond)	テンプレート引数に書く SFINAE。std::enable_if_t<cond, std::nullptr_t> = nullptr になる
HAS_METHOD(f)	引数なしのメンバ関数 f を持つかを調べる has_f / has_f_v を定義する
HAS_METHOD_ARG(f)	引数を 1 つ取るメンバ関数 f を持つかを調べる has_f / has_f_v を定義する

Required by

• コンテナに対する関数 (sorted, max, sum など) (src/base/container_func.hpp)
• 汎用関数 (chmin, chmax, 二分探索など) (src/base/functions.hpp)
• 出力をそのままコンストラクタに使える文字列化 (repr) (src/base/repr.hpp)
• vector に対する演算子と関数 (src/base/vector_func.hpp)
• ローリングハッシュ (src/string/rolling-hash.hpp)

Verified with

• test/aoj/0022.test.cpp
• test/aoj/1160.test.cpp
• test/aoj/alds1-1-b.test.cpp
• test/aoj/alds1-14-b.test.cpp
• test/aoj/alds1-4-b.test.cpp
• test/aoj/alds1-4-d.test.cpp
• test/aoj/dsl-4-a.test.cpp
• test/aoj/dsl-5-a.test.cpp
• test/aoj/itp1-10-c.test.cpp
• test/aoj/itp1-2-c.test.cpp
• test/aoj/itp1-4-d.test.cpp
• test/aoj/itp1-6-a.test.cpp
• test/aoj/itp2-3-c.test.cpp
• test/aoj/itp2-5-a.1.test.cpp
• test/aoj/itp2-5-a.2.test.cpp
• test/aoj/itp2-5-b.test.cpp
• test/aoj/ntl-1-e.test.cpp
• test/unittest/container-func-member.test.cpp
• test/unittest/container-func.test.cpp
• test/unittest/functions.test.cpp
• test/unittest/repr.test.cpp
• test/unittest/rolling-hash.test.cpp
• test/unittest/vector-func.test.cpp
• test/yosupo/enumerate-palindromes.test.cpp
• test/yosupo/sort-points-by-argument.2.test.cpp
• test/yosupo/static-range-sum.test.cpp

Code

#pragma once

/**
 * @file traits.hpp
 * @brief 型特性
 */

#include <cstddef>
#include <iterator>
#include <set>
#include <type_traits>
#include <utility>

namespace detail {
using std::begin, std::end;

template <class T, class = void>
struct is_range_impl : std::false_type {};
template <class T>
struct is_range_impl<T, std::void_t<decltype(begin(std::declval<T&>()), end(std::declval<T&>()))>> : std::true_type {};
}  // namespace detail

template <class T>
struct is_range : detail::is_range_impl<T>::type {};
template <class T>
inline constexpr bool is_range_v = is_range<T>::value;

#define HAS_METHOD(func_name)                                                              \
    namespace detail {                                                                     \
    template <class T, class = void>                                                       \
    struct has_##func_name##_impl : std::false_type {};                                    \
    template <class T>                                                                     \
    struct has_##func_name##_impl<T, std::void_t<decltype(std::declval<T>().func_name())>> \
        : std::true_type {};                                                               \
    }                                                                                      \
    template <class T>                                                                     \
    struct has_##func_name : detail::has_##func_name##_impl<T>::type {};                   \
    template <class T>                                                                     \
    inline constexpr bool has_##func_name##_v = has_##func_name<T>::value;

#define HAS_METHOD_ARG(func_name)                                                                              \
    namespace detail {                                                                                         \
    template <class T, typename U, class = void>                                                               \
    struct has_##func_name##_impl : std::false_type {};                                                        \
    template <class T, typename U>                                                                             \
    struct has_##func_name##_impl<T, U, std::void_t<decltype(std::declval<T>().func_name(std::declval<U>()))>> \
        : std::true_type {};                                                                                   \
    }                                                                                                          \
    template <class T, typename U>                                                                             \
    struct has_##func_name : detail::has_##func_name##_impl<T, U>::type {};                                    \
    template <class T, typename U>                                                                             \
    inline constexpr bool has_##func_name##_v = has_##func_name<T, U>::value;

HAS_METHOD(repr)
HAS_METHOD(type_str)
HAS_METHOD(initializer_str)
HAS_METHOD(max)
HAS_METHOD(min)
HAS_METHOD(reversed)
HAS_METHOD(sorted)
HAS_METHOD(sum)
HAS_METHOD(product)
HAS_METHOD(product_xor)
HAS_METHOD_ARG(count)
HAS_METHOD_ARG(find)
HAS_METHOD_ARG(lower_bound)
HAS_METHOD_ARG(upper_bound)

#define ENABLE_IF_T_IMPL(expr) std::enable_if_t<expr, std::nullptr_t> = nullptr
#define ENABLE_IF_T(...) ENABLE_IF_T_IMPL((__VA_ARGS__))

template <class C>
using mem_value_type = typename C::value_type;
template <class C>
using mem_difference_type = typename C::difference_type;

namespace detail {
template <class T, class = void>
struct is_sorted_container_impl : std::false_type {};
template <class T>
struct is_sorted_container_impl<std::set<T>> : std::true_type {};
template <class T>
struct is_sorted_container_impl<std::multiset<T>> : std::true_type {};
}  // namespace detail
template <class T>
struct is_sorted_container : detail::is_sorted_container_impl<T>::type {};
template <class T>
inline constexpr bool is_sorted_container_v = is_sorted_container<T>::value;

#line 2 "src/base/traits.hpp"

/**
 * @file traits.hpp
 * @brief 型特性
 */

#include <cstddef>
#include <iterator>
#include <set>
#include <type_traits>
#include <utility>

namespace detail {
using std::begin, std::end;

template <class T, class = void>
struct is_range_impl : std::false_type {};
template <class T>
struct is_range_impl<T, std::void_t<decltype(begin(std::declval<T&>()), end(std::declval<T&>()))>> : std::true_type {};
}  // namespace detail

template <class T>
struct is_range : detail::is_range_impl<T>::type {};
template <class T>
inline constexpr bool is_range_v = is_range<T>::value;

#define HAS_METHOD(func_name)                                                              \
    namespace detail {                                                                     \
    template <class T, class = void>                                                       \
    struct has_##func_name##_impl : std::false_type {};                                    \
    template <class T>                                                                     \
    struct has_##func_name##_impl<T, std::void_t<decltype(std::declval<T>().func_name())>> \
        : std::true_type {};                                                               \
    }                                                                                      \
    template <class T>                                                                     \
    struct has_##func_name : detail::has_##func_name##_impl<T>::type {};                   \
    template <class T>                                                                     \
    inline constexpr bool has_##func_name##_v = has_##func_name<T>::value;

#define HAS_METHOD_ARG(func_name)                                                                              \
    namespace detail {                                                                                         \
    template <class T, typename U, class = void>                                                               \
    struct has_##func_name##_impl : std::false_type {};                                                        \
    template <class T, typename U>                                                                             \
    struct has_##func_name##_impl<T, U, std::void_t<decltype(std::declval<T>().func_name(std::declval<U>()))>> \
        : std::true_type {};                                                                                   \
    }                                                                                                          \
    template <class T, typename U>                                                                             \
    struct has_##func_name : detail::has_##func_name##_impl<T, U>::type {};                                    \
    template <class T, typename U>                                                                             \
    inline constexpr bool has_##func_name##_v = has_##func_name<T, U>::value;

HAS_METHOD(repr)
HAS_METHOD(type_str)
HAS_METHOD(initializer_str)
HAS_METHOD(max)
HAS_METHOD(min)
HAS_METHOD(reversed)
HAS_METHOD(sorted)
HAS_METHOD(sum)
HAS_METHOD(product)
HAS_METHOD(product_xor)
HAS_METHOD_ARG(count)
HAS_METHOD_ARG(find)
HAS_METHOD_ARG(lower_bound)
HAS_METHOD_ARG(upper_bound)

#define ENABLE_IF_T_IMPL(expr) std::enable_if_t<expr, std::nullptr_t> = nullptr
#define ENABLE_IF_T(...) ENABLE_IF_T_IMPL((__VA_ARGS__))

template <class C>
using mem_value_type = typename C::value_type;
template <class C>
using mem_difference_type = typename C::difference_type;

namespace detail {
template <class T, class = void>
struct is_sorted_container_impl : std::false_type {};
template <class T>
struct is_sorted_container_impl<std::set<T>> : std::true_type {};
template <class T>
struct is_sorted_container_impl<std::multiset<T>> : std::true_type {};
}  // namespace detail
template <class T>
struct is_sorted_container : detail::is_sorted_container_impl<T>::type {};
template <class T>
inline constexpr bool is_sorted_container_v = is_sorted_container<T>::value;

Back to top page