为何不对所有C++构造函数应用[[nodiscard]]属性？

Great question! Since C++20 extended the [[nodiscard]] attribute to support constructors, it’s become a powerful tool to catch accidental bugs—like discarding a temporary std::vector (which serves no purpose) or a std::lock_guard that fails to protect a critical code block. But there are clear scenarios where applying [[nodiscard]] to a constructor is unnecessary or even counterproductive. Let’s break down those cases:

Scenarios Where [[nodiscard]] Is a Bad Fit #

1. Default Constructors That Don’t Acquire Resources or Have Critical Side Effects #

Take the my_unique() default constructor from the example: it creates an empty object with no resource ownership. Discarding a temporary instance (e.g., my_unique();) is pointless, but it doesn’t lead to bugs, resource leaks, or unsafe behavior. Marking this constructor [[nodiscard]] would generate unnecessary warnings that clutter build output without providing real value. If the default constructor doesn’t set up anything that requires the object to be retained, skip the attribute.

2. Constructors Designed for One-Time Side Effects (No Need to Hold the Object) #

Some classes exist solely to trigger a one-time action when constructed, with no need to keep the object around. For example:

struct GlobalLoggerInitializer {
    GlobalLoggerInitializer() {
        // Configure global logging once on construction
        init_global_logger();
    }
};

// Intentional: run initialization and discard the temporary
GlobalLoggerInitializer();

Here, the constructor’s sole job is to execute the setup logic. Adding [[nodiscard]] would incorrectly flag this valid usage as a mistake.

3. Constructors for Implicit Conversion or Transient Expression Usage #

If a constructor enables implicit conversions (e.g., from const char* to a custom string wrapper), discarding a temporary conversion object might be part of valid testing or short-lived expression work:

struct StringWrapper {
    StringWrapper(const char* str) { /* convert and store string data */ }
};

// Testing the conversion logic without retaining the wrapper
StringWrapper("test input");

Marking this constructor [[nodiscard]] would trigger warnings for perfectly reasonable code, creating unnecessary friction for developers.

4. Temporary Objects Used for Transient State Modifications #

Imagine a class whose constructor modifies a global or shared state, but the object itself has no ongoing purpose:

struct AppConfigResetter {
    AppConfigResetter() {
        // Reset application config to default values
        reset_app_config();
    }
};

// Reset config and move on—no need to hold the object
AppConfigResetter();

Discarding this temporary is intentional, and [[nodiscard]] would incorrectly signal an error here.

The Core Rule of Thumb #

A constructor should only get [[nodiscard]] if discarding its temporary object would lead to a bug, resource leak, or clearly nonsensical behavior (like discarding a lock guard or a resource-acquiring constructor like my_unique(int fd)). If the constructor’s work is complete once it’s called, or if the object itself isn’t needed to maintain state or hold resources, skip the attribute.

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