Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/c++/15/typeindex

     1	// C++11 <typeindex> -*- C++ -*-
     2	
     3	// Copyright (C) 2010-2025 Free Software Foundation, Inc.
     4	//
     5	// This file is part of the GNU ISO C++ Library.  This library is free
     6	// software; you can redistribute it and/or modify it under the
     7	// terms of the GNU General Public License as published by the
     8	// Free Software Foundation; either version 3, or (at your option)
     9	// any later version.
    10	
    11	// This library is distributed in the hope that it will be useful,
    12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
    13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14	// GNU General Public License for more details.
    15	
    16	// Under Section 7 of GPL version 3, you are granted additional
    17	// permissions described in the GCC Runtime Library Exception, version
    18	// 3.1, as published by the Free Software Foundation.
    19	
    20	// You should have received a copy of the GNU General Public License and
    21	// a copy of the GCC Runtime Library Exception along with this program;
    22	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    23	// <http://www.gnu.org/licenses/>.
    24	
    25	/** @file include/typeindex
    26	 *  This is a Standard C++ Library header.
    27	 */
    28	
    29	#ifndef _GLIBCXX_TYPEINDEX
    30	#define _GLIBCXX_TYPEINDEX 1
    31	
    32	#ifdef _GLIBCXX_SYSHDR
    33	#pragma GCC system_header
    34	#endif
    35	
    36	#if __cplusplus < 201103L
    37	# include <bits/c++0x_warning.h>
    38	#else
    39	
    40	#include <typeinfo>
    41	#if __cplusplus > 201703L
    42	# include <compare>
    43	#endif
    44	
    45	namespace std _GLIBCXX_VISIBILITY(default)
    46	{
    47	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    48	
    49	  /**
    50	   * @brief Class type_index
    51	   * @ingroup utilities
    52	   *
    53	   *  The class type_index provides a simple wrapper for type_info
    54	   *  which can be used as an index type in associative containers
    55	   *  (23.6) and in unordered associative containers (23.7).
    56	   */
    57	  struct type_index
    58	  {
    59	    type_index(const type_info& __rhs) noexcept
    60	    : _M_target(&__rhs) { }
    61	
    62	    bool
    63	    operator==(const type_index& __rhs) const noexcept
    64	    { return *_M_target == *__rhs._M_target; }
    65	
    66	#if ! __cpp_lib_three_way_comparison
    67	    bool
    68	    operator!=(const type_index& __rhs) const noexcept
    69	    { return *_M_target != *__rhs._M_target; }
    70	#endif
    71	
    72	    bool
    73	    operator<(const type_index& __rhs) const noexcept
    74	    { return _M_target->before(*__rhs._M_target); }
    75	
    76	    bool
    77	    operator<=(const type_index& __rhs) const noexcept
    78	    { return !__rhs._M_target->before(*_M_target); }
    79	
    80	    bool
    81	    operator>(const type_index& __rhs) const noexcept
    82	    { return __rhs._M_target->before(*_M_target); }
    83	
    84	    bool
    85	    operator>=(const type_index& __rhs) const noexcept
    86	    { return !_M_target->before(*__rhs._M_target); }
    87	
    88	#if __cpp_lib_three_way_comparison
    89	    strong_ordering
    90	    operator<=>(const type_index& __rhs) const noexcept
    91	    {
    92	      if (*_M_target == *__rhs._M_target)
    93		return strong_ordering::equal;
    94	      if (_M_target->before(*__rhs._M_target))
    95		return strong_ordering::less;
    96	      return strong_ordering::greater;
    97	    }
    98	#endif
    99	
   100	    size_t
   101	    hash_code() const noexcept
   102	    { return _M_target->hash_code(); }
   103	
   104	    const char*
   105	    name() const noexcept
   106	    { return _M_target->name(); }
   107	
   108	  private:
   109	    const type_info* _M_target;
   110	  };
   111	
   112	  template<typename _Tp> struct hash;
   113	
   114	  /// std::hash specialization for type_index.
   115	  template<>
   116	    struct hash<type_index>
   117	    {
   118	      typedef size_t        result_type;
   119	      typedef type_index  argument_type;
   120	
   121	      size_t
   122	      operator()(const type_index& __ti) const noexcept
   123	      { return __ti.hash_code(); }
   124	    };
   125	
   126	_GLIBCXX_END_NAMESPACE_VERSION
   127	} // namespace std
   128	
   129	#endif  // C++11
   130	
   131	#endif  // _GLIBCXX_TYPEINDEX