C++ sometimes uses the suffix _type
on type definitions (e.g. std::vector
),
also sometimes _t
(e.g. std::si
Member types are called type
or something_type
in the C++ standard library. This is readable and descriptive, and the added verbosity is not usually a problem because users don't normally spell out those type names: most of them are used in function signatures, then auto
takes care of member function return types, and in C++14 the _t
type aliases take care of type trait static type members.
That leads to the second point: Free-standing, non-member types are usually called something_t
: size_t
, int64_t
, decay_t
, etc. There is certainly an element of heritage from C in there, but the convention is maintained in the continuing evolution of C++. Presumably, succinctness is still a useful quality here, since those types are expected to be spelled out in general.
Finally, all the above only applies to what I might call "generic type derivation": Given X
, give me some related type X::value_type
, or given an integer, give me the 64-bit variant. The convention is thus restricted to common, vocabulary-type names. The class names of your actual business logic (including std::string
) presumably do not warrant such a naming pattern, and I don't think many people would like to have to mangle every type name.
If you will, the _t
and _type
naming conventions apply primarily to the standard library and to certain aspects of the standard library style, but you do not need to take them as some kind of general mandate.