如何读懂狗屎一般的、非人类的 C++ 类模板？
如何读懂可读性不高的 C++ 类模板？
本文章写给和我一样不会 OOP 的蒟蒻们。
我在写另外一篇全站推荐文章《C++ 26 的前瞻特性与其在 OI 中的应用》的时候需要常常阅读 C++ 的类模板。而作为一个 OIer，我习惯了去写一些格式比较简单、可读性较高（自认为如此）的代码。
而 C++ 的类模板在大多数时候都不是“偏向人类的”，所以我们想要去读懂它、挖掘它，就需要读懂这些可读性不高的代码。
从简单地、我们明确知道作用的东西入手
C++ 26 的特性我们还不知道是干什么、是怎么用的，那让我们来看看我们比较熟悉的东西吧。
1. std::stack
我们知道 std::stack 是基于 std::deque 并强制 FILO 的数据结构。
我们可以从 <bits/stl_stack.h> 找到 C++ 中 std::stack 的类模板。
::::info[完整代码（去除版权信息）]
#ifndef _STL_STACK_H
#define _STL_STACK_H 1
#include <bits/concept_check.h>
#include <debug/debug.h>
namespace std _GLIBCXX_VISIBILITY(default) {
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A standard container giving FILO behavior.
*
* @ingroup sequences
*
* @tparam _Tp Type of element.
* @tparam _Sequence Type of underlying sequence, defaults to deque<_Tp>.
*
* Meets many of the requirements of a
* <a href="tables.html#65">container</a>,
* but does not define anything to do with iterators. Very few of the
* other standard container interfaces are defined.
*
* This is not a true container, but an @e adaptor. It holds
* another container, and provides a wrapper interface to that
* container. The wrapper is what enforces strict
* first-in-last-out %stack behavior.
*
* The second template parameter defines the type of the underlying
* sequence/container. It defaults to std::deque, but it can be
* any type that supports @c back, @c push_back, and @c pop_front,
* such as std::list, std::vector, or an appropriate user-defined
* type.
*
* Members not found in @a normal containers are @c container_type,
* which is a typedef for the second Sequence parameter, and @c
* push, @c pop, and @c top, which are standard %stack/FILO
* operations.
*/
template<typename _Tp, typename _Sequence = deque<_Tp> >
class stack {
// concept requirements
typedef typename _Sequence::value_type _Sequence_value_type;
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
__glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept)
__glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept)
template<typename _Tp1, typename _Seq1>
friend bool
operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
template<typename _Tp1, typename _Seq1>
friend bool
operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
public:
typedef typename _Sequence::value_type value_type;
typedef typename _Sequence::reference reference;
typedef typename _Sequence::const_reference const_reference;
typedef typename _Sequence::size_type size_type;
typedef _Sequence container_type;
protected:
// See queue::c for notes on this name.
_Sequence c;
public:
// XXX removed old def ctor, added def arg to this one to match 14882
/**
* @brief Default constructor creates no elements.
*/
#if __cplusplus < 201103L
explicit
stack(const _Sequence& __c = _Sequence())
: c(__c) { }
#else
explicit
stack(const _Sequence& __c)
: c(__c) { }
explicit
stack(_Sequence&& __c = _Sequence())
: c(std::move(__c)) { }
#endif
/**
* Returns true if the %stack is empty.
*/
bool
empty() const {
return c.empty();
}
/** Returns the number of elements in the %stack. */
size_type
size() const {
return c.size();
}
/**
* Returns a read/write reference to the data at the first
* element of the %stack.
*/
reference
top() {
__glibcxx_requires_nonempty();
return c.back();
}
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %stack.
*/
const_reference
top() const {
__glibcxx_requires_nonempty();
return c.back();
}
/**
* @brief Add data to the top of the %stack.
* @param __x Data to be added.
*
* This is a typical %stack operation. The function creates an
* element at the top of the %stack and assigns the given data
* to it. The time complexity of the operation depends on the
* underlying sequence.
*/
void
push(const value_type& __x) {
c.push_back(__x);
}
#if __cplusplus >= 201103L
void
push(value_type&& __x) {
c.push_back(std::move(__x));
}
template<typename... _Args>
void
emplace(_Args&&... __args) {
c.emplace_back(std::forward<_Args>(__args)...);
}
#endif
/**
* @brief Removes first element.
*
* This is a typical %stack operation. It shrinks the %stack
* by one. The time complexity of the operation depends on the
* underlying sequence.
*
* Note that no data is returned, and if the first element's
* data is needed, it should be retrieved before pop() is
* called.
*/
void
pop() {
__glibcxx_requires_nonempty();
c.pop_back();
}
#if __cplusplus >= 201103L
void
swap(stack& __s)
noexcept(noexcept(swap(c, __s.c))) {
using std::swap;
swap(c, __s.c);
}
#endif
};
/**
* @brief Stack equality comparison.
* @param __x A %stack.
* @param __y A %stack of the same type as @a __x.
* @return True iff the size and elements of the stacks are equal.
*
* This is an equivalence relation. Complexity and semantics
* depend on the underlying sequence type, but the expected rules
* are: this relation is linear in the size of the sequences, and
* stacks are considered equivalent if their sequences compare
* equal.
*/
template<typename _Tp, typename _Seq>
inline bool
operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) {
return __x.c == __y.c;
}
/**
* @brief Stack ordering relation.
* @param __x A %stack.
* @param __y A %stack of the same type as @a x.
* @return True iff @a x is lexicographically less than @a __y.
*
* This is an total ordering relation. Complexity and semantics
* depend on the underlying sequence type, but the expected rules
* are: this relation is linear in the size of the sequences, the
* elements must be comparable with @c <, and
* std::lexicographical_compare() is usually used to make the
* determination.
*/
template<typename _Tp, typename _Seq>
inline bool
operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) {
return __x.c < __y.c;
}
/// Based on operator==
template<typename _Tp, typename _Seq>
inline bool
operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) {
return !(__x == __y);
}
/// Based on operator<
template<typename _Tp, typename _Seq>
inline bool
operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) {
return __y < __x;
}
/// Based on operator<
template<typename _Tp, typename _Seq>
inline bool
operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) {
return !(__y < __x);
}
/// Based on operator<
template<typename _Tp, typename _Seq>
inline bool
operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) {
return !(__x < __y);
}
#if __cplusplus >= 201103L
template<typename _Tp, typename _Seq>
inline void
swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
noexcept(noexcept(__x.swap(__y))) {
__x.swap(__y);
}
template<typename _Tp, typename _Seq, typename _Alloc>
struct uses_allocator<stack<_Tp, _Seq>, _Alloc>
: public uses_allocator<_Seq, _Alloc>::type { };
#endif
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif /* _STL_STACK_H */::::
我们就一个函数一个函数地去分析。