std::is_convertible, std::is_nothrow_convertible

定義於標頭檔案 `<type_traits>`
template< class From, class To > struct is_convertible;	(1)	(C++11 起)
template< class From, class To > struct is_nothrow_convertible;	(2)	(C++20 起)

1) 如果虛構函式定義 To test() { return std::declval<From>(); } 格式良好（即，std::declval<From>() 可以使用隱式轉換轉換為 To，或者 From 和 To 都是可能經過 cv 限定的 void），則提供成員常量 value 等於 true。否則 value 為 false。為了此檢查的目的，返回語句中 std::declval 的使用不被視為 ODR 使用。

如果 To 是引用型別，並且在將 std::declval<From>() 繫結到 To 時會建立一個臨時物件，則虛構函式中的 return 語句被認為是格式良好的，即使這種繫結在實際函式中是格式錯誤的。

(C++26 起)

訪問檢查的執行方式如同來自與兩種型別均無關的上下文。只考慮返回語句中表達式的直接上下文的有效性（包括對返回型別的轉換）。

2) 同 (1)，但轉換也是 noexcept 的。

如果 From 或 To 不是完整型別，(可能經過 cv 限定的) void，或未知邊界的陣列，則行為未定義。

如果上述模板的例項化直接或間接依賴於不完整型別，並且該例項化在該型別假設完成時可能產生不同的結果，則行為未定義。

如果程式為此頁上描述的任何模板新增特化，則行為未定義。

繼承自 std::integral_constant

成員常量

value

[靜態]

true 如果 From 可以轉換為 To，否則為 false
(public static 成員常量)

成員函式

operator bool	將物件轉換為 bool，返回 value (公開成員函式)
operator() (C++14)	返回 value (公開成員函式)

成員型別

型別	定義
`value_type`	bool
`型別`	std::integral_constant<bool, value>

[編輯] 可能實現

is_convertible (1)

namespace detail
{
    template<class T>
    auto test_returnable(int) -> decltype(
        void(static_cast<T(*)()>(nullptr)), std::true_type{}
    );
    template<class>
    auto test_returnable(...) -> std::false_type;
 
    template<class From, class To>
    auto test_implicitly_convertible(int) -> decltype(
        void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
    );
    template<class, class>
    auto test_implicitly_convertible(...) -> std::false_type;
} // namespace detail
 
template<class From, class To>
struct is_convertible : std::integral_constant<bool,
    (decltype(detail::test_returnable<To>(0))::value &&
     decltype(detail::test_implicitly_convertible<From, To>(0))::value) ||
    (std::is_void<From>::value && std::is_void<To>::value)
> {};

is_nothrow_convertible (2)

template<class From, class To>
struct is_nothrow_convertible : std::conjunction<std::is_void<From>, std::is_void<To>> {};
 
template<class From, class To>
    requires
        requires
        {
            static_cast<To(*)()>(nullptr);
            { std::declval<void(&)(To) noexcept>()(std::declval<From>()) } noexcept;
        }
struct is_nothrow_convertible<From, To> : std::true_type {};

[編輯] 註解

對於引用型別、void 型別、陣列型別和函式型別給出明確定義的結果。

目前標準尚未明確轉換產生的物件的析構（無論是結果物件還是繫結到引用的臨時物件）是否被視為轉換的一部分。這是一個 LWG issue 3400。

所有已知實現都將析構視為轉換的一部分，正如 P0758R1 中所提議的那樣。

特性測試宏	值	標準	特性
`__cpp_lib_is_nothrow_convertible`	`201806L`	(C++20)	`std::is_nothrow_convertible`

[編輯] 示例

執行此程式碼

#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
#include <type_traits>
 
class E { public: template<class T> E(T&&) {} };
 
int main()
{
    class A {};
    class B : public A {};
    class C {};
    class D { public: operator C() { return c; } C c; };
 
    static_assert(std::is_convertible_v<B*, A*>);
    static_assert(!std::is_convertible_v<A*, B*>);
    static_assert(std::is_convertible_v<D, C>);
    static_assert(!std::is_convertible_v<B*, C*>);
    // Note that the Perfect Forwarding constructor makes the class E be
    // "convertible" from everything. So, A is replaceable by B, C, D..:
    static_assert(std::is_convertible_v<A, E>);
 
    static_assert(!std::is_convertible_v<std::string_view, std::string>);
    static_assert(std::is_convertible_v<std::string, std::string_view>);
 
    auto stringify = []<typename T>(T x)
    {
        if constexpr (std::is_convertible_v<T, std::string> or
                      std::is_convertible_v<T, std::string_view>)
            return x;
        else
            return std::to_string(x);
    };
 
    using std::operator "" s, std::operator "" sv;
    const char* three = "three";
 
    std::cout << std::quoted(stringify("one"s)) << ' '
              << std::quoted(stringify("two"sv)) << ' '
              << std::quoted(stringify(three)) << ' '
              << std::quoted(stringify(42)) << ' '
              << std::quoted(stringify(42.0)) << '\n';
}

輸出

"one" "two" "three" "42" "42.000000"

[編輯] 參閱

is_base_of (C++11)	檢查一個型別是否為另一個型別的基類 (類模板) [編輯]
is_pointer_interconvertible_base_of (C++20)	檢查一個型別是否為另一個型別的指標可互轉（初始）基類 (類模板) [編輯]
is_pointer_interconvertible_with_class (C++20)	檢查一個型別的物件是否與該型別的指定子物件指標可互轉 (函式模板) [編輯]
convertible_to (C++20)	指定型別可隱式轉換為另一型別 (概念) [編輯]

編譯器支援
自由（freestanding）與宿主（hosted）
語言
標準庫
標準庫標頭檔案
具名要求
特性測試宏 (C++20)
語言支援庫
概念庫 (C++20)
診斷庫
記憶體管理庫
超程式設計庫 (C++11)
通用工具庫
容器庫
迭代器庫
範圍庫 (C++20)
演算法庫
字串庫
文字處理庫
數值庫
日期和時間庫
輸入/輸出庫
檔案系統庫 (C++17)
併發支援庫 (C++11)
執行控制庫 (C++26)
技術規範
符號索引
外部庫

template< class From, class To > constexpr bool is_convertible_v = is_convertible<From, To>::value;		(C++17 起)
template< class From, class To > constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;		(C++20 起)

cppreference.com

名稱空間

變體

檢視

操作