[c++] Conditional explicit

In C++, the explicit keyword is often used to prevent implicit conversions when constructing objects. However, it can also be conditionally applied based on certain conditions to control how the constructor is invoked. This behavior is known as conditional explicit.

When to Use Conditional explicit

Conditional explicit is useful when you want to control implicit conversions based on certain conditions. For example, you might want the constructor to be explicit only when a specific template argument is used, but allow implicit conversions for other types.


Let’s consider a simple example where we have a class MyClass with a constructor that takes a template parameter T. We want the constructor to be explicit only when T is a pointer type, and allow implicit conversion when it’s a non-pointer type.

Here’s how we can achieve this using conditional explicit:

template <typename T>
class MyClass {
    template <typename U = T, typename = std::enable_if_t<std::is_pointer_v<U>>>
    explicit MyClass(U value) {
        // Constructor implementation for pointer types

    template <typename U = T, typename = std::enable_if_t<!std::is_pointer_v<U>>>
    MyClass(U value) {
        // Constructor implementation for non-pointer types

In this example, we use std::enable_if to conditionally apply the explicit keyword based on the type of T. If T is a pointer type, the constructor is explicitly expressed. Otherwise, the constructor allows implicit conversions.

By using conditional explicit, we can tailor the behavior of the constructor to suit the specific requirements of different types, providing flexibility and fine-grained control over implicit conversions.


Conditional explicit allows for more precise control over implicit conversions in C++ by conditionally enforcing the explicit keyword based on certain conditions. It offers a way to customize the behavior of constructors to better align with the intended usage of the class.

By leveraging conditional explicit, developers can design more expressive and intuitive APIs while ensuring type safety and clarity in their code.

For more information, you can refer to the C++ reference.