T.46 contradicts the idea of type traits and is not resource-friendly

[kitsnet]

T.46, which requires types used as template arguments to be at least semiregular, seems to make type traits use (or any kind of generic compile-time reasoning based on types) disallowed for non-default-constructible and/or non-copyable types.

Another problem with T.46 is that it disallows using generic implementations with resource-conscious or lifetime-conscious types. Even the example of std::vector<T>, provided as a motivation for the rule, can show the deficiency of this rule when T is (non-copyable) std::unique_ptr.

[bgloyer]

I agreed this rule is out of place. A template should not unnecessary constrain parameters and semi-regualar could exclude valid uses. Stl vector and sort do not require semi-regular. It also contriducts rule T.40 which recommends passing function objects which don't have to be semi-regular.

[hsutter]

Editors call: Thanks! We should change T.46 to recommend, not require, and Exceptions examples of unique_ptr and traits.

[jwakely]

I think T.46 is just a bad guideline, and should be removed entirely.

There's no reason you can't use std::vector<X> with a non-default constructible X. You can't insert default constructed elements, but everything else works, and we go to great lengths to ensure that the spec for vector (and other library types) is very precise about which operations require default constructibility (or require movability, or assignability, etc.). It works fine by design.

The guideline basically says "all templates should work with all types" and that's just nonsense. Why did we even bother to standardize concepts if we're just going to say "don't use template arguments that might not support some operations".

If the guideline is to be kept, it needs much better justification than "you can't default construct things that you can't default construct".

[jwakely]

You can consider one the simplest templates in the standard library, std::pair. It's designed to work fine with types that aren't movable or aren't default-constructible. It correctly reflects the properties of its template arguments, so that std::pair<T, U> is movable if both T and U are, and is default-constructible if both T and U are. So the guideline says "don't use std::pair for things that it's carefully designed to support". Why not?

The rationale of "preventing surprises and errors" doesn't convince me at all. I would find it surprising if I could default construct a std::pair of non-default-constructible types, but it doesn't seem surprising that I can't.

[hsutter]

Editors call: After reviewing this again, we agree that T.46 should be removed.