```
template<class T> struct tuple_size;
```

Remarks: All specializations of tuple_size shall meet the
UnaryTypeTrait requirements with a
base characteristic of integral_constant<size_t, N>
for some N.

```
template<class... Types>
class tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };
```

```
template<size_t I, class... Types>
class tuple_element<I, tuple<Types...>> {
public:
using type = TI;
};
```

```
template<class T> class tuple_size<const T>;
template<class T> class tuple_size<volatile T>;
template<class T> class tuple_size<const volatile T>;
```

If the expression TS::value is well-formed
when treated as an unevaluated operand, then each
of the three templates shall meet the
UnaryTypeTrait requirements
with a base characteristic of

integral_constant<size_t, TS::value>Otherwise, they shall have no member value.

Only the validity of the immediate context of the expression is considered.

[ Note

: *end note*

]The compilation of the expression can result in side effects
such as the instantiation of class template specializations and
function template specializations, the generation of implicitly-defined functions, and so on.

Such side effects are not in the “immediate context” and
can result in the program being ill-formed.

— ```
template<size_t I, class T> class tuple_element<I, const T>;
template<size_t I, class T> class tuple_element<I, volatile T>;
template<size_t I, class T> class tuple_element<I, const volatile T>;
```

Then
each of the three templates shall meet the
TransformationTrait
requirements with a member typedef type that names the following
type: