# stl_pair.h

Go to the documentation of this file.

    00001 // Pair implementation -*- C++ -*-
    00002
    00003 // Copyright (C) 2001, 2004 Free Software Foundation, Inc.
    00004 //
    00005 // This file is part of the GNU ISO C++ Library.  This library is free
    00006 // software; you can redistribute it and/or modify it under the
    00007 // terms of the GNU General Public License as published by the
    00008 // Free Software Foundation; either version 2, or (at your option)
    00009 // any later version.
    00010
    00011 // This library is distributed in the hope that it will be useful,
    00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00014 // GNU General Public License for more details.
    00015
    00016 // You should have received a copy of the GNU General Public License along
    00017 // with this library; see the file COPYING.  If not, write to the Free
    00018 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    00019 // USA.
    00020
    00021 // As a special exception, you may use this file as part of a free software
    00022 // library without restriction.  Specifically, if other files instantiate
    00023 // templates or use macros or inline functions from this file, or you compile
    00024 // this file and link it with other files to produce an executable, this
    00025 // file does not by itself cause the resulting executable to be covered by
    00026 // the GNU General Public License.  This exception does not however
    00027 // invalidate any other reasons why the executable file might be covered by
    00028 // the GNU General Public License.
    00029
    00030 /*
    00031  *
    00032  * Copyright (c) 1994
    00033  * Hewlett-Packard Company
    00034  *
    00035  * Permission to use, copy, modify, distribute and sell this software
    00036  * and its documentation for any purpose is hereby granted without fee,
    00037  * provided that the above copyright notice appear in all copies and
    00038  * that both that copyright notice and this permission notice appear
    00039  * in supporting documentation.  Hewlett-Packard Company makes no
    00040  * representations about the suitability of this software for any
    00041  * purpose.  It is provided "as is" without express or implied warranty.
    00042  *
    00043  *
    00044  * Copyright (c) 1996,1997
    00045  * Silicon Graphics Computer Systems, Inc.
    00046  *
    00047  * Permission to use, copy, modify, distribute and sell this software
    00048  * and its documentation for any purpose is hereby granted without fee,
    00049  * provided that the above copyright notice appear in all copies and
    00050  * that both that copyright notice and this permission notice appear
    00051  * in supporting documentation.  Silicon Graphics makes no
    00052  * representations about the suitability of this software for any
    00053  * purpose.  It is provided "as is" without express or implied warranty.
    00054  */
    00055
    00056 /** @file stl_pair.h
    00057  *  This is an internal header file, included by other library headers.
    00058  *  You should not attempt to use it directly.
    00059  */
    00060
    00061 #ifndef _PAIR_H
    00062 #define _PAIR_H 1
    00063
    00064 namespace std
    00065 {
    00066   /// pair holds two objects of arbitrary type.
    00067   template<class _T1, class _T2>
    00068     struct pair
    00069     {
    00070       typedef _T1 first_type;    ///<  @c first_type is the first bound type
    00071       typedef _T2 second_type;   ///<  @c second_type is the second bound type
    00072
    00073       _T1 first;                 ///< @c first is a copy of the first object
    00074       _T2 second;                ///< @c second is a copy of the second object
    00075
    00076       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00077       // 265.  std::pair::pair() effects overly restrictive
    00078       /** The default constructor creates @c first and @c second using their
    00079        *  respective default constructors.  */
    00080       pair()
    00081       : first(), second() { }
    00082
    00083       /** Two objects may be passed to a @c pair constructor to be copied.  */
    00084       pair(const _T1& __a, const _T2& __b)
    00085       : first(__a), second(__b) { }
    00086
    00087       /** There is also a templated copy ctor for the @c pair class itself.  */
    00088       template<class _U1, class _U2>
    00089         pair(const pair<_U1, _U2>& __p)
    00090     : first(__p.first), second(__p.second) { }
    00091     };
    00092
    00093   /// Two pairs of the same type are equal iff their members are equal.
    00094   template<class _T1, class _T2>
    00095     inline bool
    00096     operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    00097     { return __x.first == __y.first && __x.second == __y.second; }
    00098
    00099   /// <http://gcc.gnu.org/onlinedocs/libstdc++/20_util/howto.html#pairlt>
    00100   template<class _T1, class _T2>
    00101     inline bool
    00102     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    00103     { return __x.first < __y.first
    00104          || (!(__y.first < __x.first) && __x.second < __y.second); }
    00105
    00106   /// Uses @c operator== to find the result.
    00107   template<class _T1, class _T2>
    00108     inline bool
    00109     operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    00110     { return !(__x == __y); }
    00111
    00112   /// Uses @c operator< to find the result.
    00113   template<class _T1, class _T2>
    00114     inline bool
    00115     operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    00116     { return __y < __x; }
    00117
    00118   /// Uses @c operator< to find the result.
    00119   template<class _T1, class _T2>
    00120     inline bool
    00121     operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    00122     { return !(__y < __x); }
    00123
    00124   /// Uses @c operator< to find the result.
    00125   template<class _T1, class _T2>
    00126     inline bool
    00127     operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    00128     { return !(__x < __y); }
    00129
    00130   /**
    00131    *  @brief A convenience wrapper for creating a pair from two objects.
    00132    *  @param  x  The first object.
    00133    *  @param  y  The second object.
    00134    *  @return   A newly-constructed pair<> object of the appropriate type.
    00135    *
    00136    *  The standard requires that the objects be passed by reference-to-const,
    00137    *  but LWG issue #181 says they should be passed by const value.  We follow
    00138    *  the LWG by default.
    00139    */
    00140   // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00141   // 181.  make_pair() unintended behavior
    00142   template<class _T1, class _T2>
    00143     inline pair<_T1, _T2>
    00144     make_pair(_T1 __x, _T2 __y)
    00145     { return pair<_T1, _T2>(__x, __y); }
    00146 } // namespace std
    00147
    00148 #endif /* _PAIR_H */