C++ explicit constructor应用：C++11新手咨询其适用场景

Hey there! Great question—explicit constructors are one of those C++ features that seem small at first, but they save you from a ton of subtle bugs once you get the hang of when to use them. Let’s break down the key scenarios where you should mark a constructor as explicit:

1. Your constructor can be called with a single argument (including default parameters) #

This is the most common use case. By default, C++ allows implicit conversion from the argument type to your class type if the constructor takes one parameter (or has default values for all parameters after the first). Sometimes this is convenient, but more often than not, it leads to unexpected behavior you didn’t intend.

Example without explicit (problematic):

class Distance {
public:
    // Takes one int (meters) — allows implicit conversion
    Distance(int meters) : m_meters(meters) {}
    int getMeters() const { return m_meters; }

private:
    int m_meters;
};

// Accidental implicit conversion: 5 gets turned into a Distance object
bool isLongerThan5(Distance d) {
    return d.getMeters() > 5;
}

// This compiles, but is this what you meant?
isLongerThan5(10); // Implicitly converts 10 to Distance(10)

Fix with explicit:

class Distance {
public:
    explicit Distance(int meters) : m_meters(meters) {}
    // ... rest same as before
};

// Now this won’t compile — forces you to be explicit
// isLongerThan5(10); // ERROR: no implicit conversion

// You have to write it intentionally:
isLongerThan5(Distance(10));
isLongerThan5({10}); // Also works with uniform initialization

This also applies to constructors with multiple parameters where all but the first have default values:

// Without explicit, this can be called with just one int
class Vector {
public:
    explicit Vector(int size, int init_val = 0) { /* ... */ }
};

// Vector v = 5; // ERROR with explicit; would work without it

2. To prevent accidental semantic errors #

Implicit conversions can create logical bugs that are hard to spot. For example, if you have a UserID class that wraps an integer, allowing implicit conversion from int might let you pass a random integer where a UserID is expected—something that should only be created intentionally.

class UserID {
public:
    explicit UserID(int id) : m_id(id) {}
    // ...
};

void deleteUser(UserID id) { /* ... */ }

// deleteUser(1234); // ERROR: can’t implicitly convert int to UserID
deleteUser(UserID(1234)); // Intentional, clear what’s happening

3. For classes that manage resources (like smart pointers) #

Classes that handle ownership of resources (e.g., std::unique_ptr, std::shared_ptr) have explicit constructors for a reason: you don’t want a raw pointer to be implicitly converted into a smart pointer, which would transfer ownership unexpectedly.

// std::unique_ptr’s constructor is explicit, so this won’t work:
// std::unique_ptr<int> ptr = new int(5); // ERROR

// You have to explicitly construct it:
std::unique_ptr<int> ptr(new int(5));
// Or better, use std::make_unique
auto ptr = std::make_unique<int>(5);

4. In template/generic code #

When writing templates, implicit conversions can lead to unexpected template instantiations or ambiguous overload resolutions. Marking constructors as explicit keeps the compiler from making assumptions you didn’t plan for, making your generic code more predictable.

As a general rule: mark every constructor that can be called with a single argument as explicit unless you specifically want implicit conversion (like how std::string allows implicit conversion from const char* because it’s widely expected and convenient).

内容的提问来源于stack exchange，提问作者aliceangel