寫這篇文章的原因，希望自己能在技術的道路上越走越遠，在一年前使用c語言寫了些資料結構後，學會了使用工具的stl，但是希望自己能在原始碼上對自己使用的stl更加的深入瞭解，由於本人的學識淺薄，如有錯誤，還望摘正

首先我們要有stl source code 使用github下載

git clone https://github.com/gcc-mirror/gcc

如果沒有安裝git使用上述的網站即可

開啟gcc-master後 然後我們的目光聚焦在libstdc++-v3資料夾裡的內容

所以我們的路徑是gcc-master/libstdc++-v3/include/std

關於順序，因為筆者是邊看原始碼邊寫理解所以順序不一定是最好的

我們先看std的algorithm部分

***** algorithm header *****
#ifndef _GLIBCXX_ALGORITHM
#define _GLIBCXX_ALGORITHM 1

#pragma GCC system_header

#include <utility> // UK-300.
#include <bits/stl_algobase.h>
#include <bits/stl_algo.h>

#ifdef _GLIBCXX_PARALLEL
# include <parallel/algorithm>
 

#endif

#endif /* _GLIBCXX_ALGORITHM */

#ifndef 
#define 


#endif 

簡單解釋下 ， 如果同一個標頭檔案被include兩次，其中定義的ADT可能會導致重定義的錯誤，使用include guard 保證編譯器可以跳過XXX，當XXX已經被定義。

#pragma GCC system_header
這一行程式碼告訴編譯器 整個檔案後面的內容都視作 系統標頭檔案

接下來的內容我們發現 平時我們#include < algorithm >真正的實現內容在接下來的標頭檔案中

接著 基礎的真正的演算法實現部分
#include <utility> // UK-300.
 

#include <bits/stl_algobase.h>
#include <bits/stl_algo.h>
下面 如果定義了_GLIBCXX_PARALLEL巨集則包含<parallel/algorithm>

大概就是如果 巨集定義了一個並行的 標誌  則需要多include 一個實現
#ifdef _GLIBCXX_PARALLEL
# include <parallel/algorithm>

我們先看#include < bits/stl_algobase.h >熱熱身 這也是 algorithm標頭檔案真正實現的部分

***** bits/stl_algobase.h *****
標頭檔案先忽略  

巨集定義也先忽略

如果c++版本小於11的swap先忽略

/**    我們扯到現在正兒八經看的第一段程式碼
*  @brief Swaps the contents of two iterators. 行為
*  @ingroup mutating_algorithms 分組
*  @param  __a  An iterator. 引數
*  @param  __b  Another iterator.
*  @return   Nothing. 返回
*
*  This function swaps the values pointed to by two iterators, not the iterators themselves.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
inline void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{
  // concept requirements
  __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
  _ForwardIterator1>)
  __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
  _ForwardIterator2>)

#if __cplusplus < 201103L
    ....c++ 11 以下的版本我們暫時忽略
#else
  swap(*__a, *__b);
#endif
}

先解釋__glibcxx_function_requires
__glibcxx_function_requires是巨集展開

#define __glibcxx_function_requires(...)                                 __gnu_cxx::__function_requires< __gnu_cxx::__VA_ARGS__ >();

__gnu_cxx::__function_requires是__gnu_cxx::名字空間下的函式

template <class _Concept>
inline void __function_requires()
{
  void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
}

對於下面的這段程式碼而言

__glibcxx_function_requires(_Mutable_ForwardIteratorConcept<  _ForwardIterator1>)

會在推斷不是可以修改的前向迭代器時終止編譯

最後看swap的實現

上述 swap在stl_algobase.h中的實現
template<typename _Tp>
inline void
swap(_Tp& __a, _Tp& __b)
{
  // concept requirements
  __glibcxx_function_requires(_SGIAssignableConcept<_Tp>)
  _Tp __tmp = __a;
  __a = __b;
  __b = __tmp;
}

首先我們認為迭代器是指標
然後使用把指向的內容取引用進行交換

接著看

把 一個容器【B,E】與另外一個容器交換
/**
*  @brief Swap the elements of two sequences.
*  @ingroup mutating_algorithms
*  @param  __first1  A forward iterator.
*  @param  __last1   A forward iterator.
*  @param  __first2  A forward iterator.
*  @return   An iterator equal to @p first2+(last1-first1).
*
*  Swaps each element in the range @p [first1,last1) with the
*  corresponding element in the range @p [first2,(last1-first1)).
*  The ranges must not overlap.
*/
template<typename _ForwardIterator1, typename _ForwardIterator2>
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
    // concept requirements這三個型別檢查 需要可以修改的前向迭代器
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    _ForwardIterator1>)
    __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
    _ForwardIterator2>)
    __glibcxx_requires_valid_range(__first1, __last1);

    for (; __first1 != __last1; ++__first1, (void)++__first2)
    std::iter_swap(__first1, __first2);呼叫我們上面說的迭代器交換 
    return __first2;
}

我們把前面的內容提煉一下
於是現在我們可以自己編寫屬於我們自己的swap

#include <vector>
#include <iostream>
//使用不同的名字空間 這是實現的核心
namespace lthstd{
  template <typename myTp>
  inline void
  myswap( myTp& __a , myTp& __b ){
    myTp __tmp = __a ;
    __a = __b;
    __b = __tmp ;
  }
  template<typename _forwardit1 , typename _forwardit2>
  inline void
  myiter_swap ( _forwardit1 __a , _forwardit2 __b){
    myswap( *__a , *__b );
  }
  template<typename _forwardit1, typename _forwardit2>
    _forwardit2
    swap_ranges(_forwardit1 __first1, _forwardit1 __last1,
    _forwardit2 __first2)
    {
        for (; __first1 != __last1; ++__first1, (void)++__first2)
            iter_swap(__first1, __first2);//呼叫我們上面說的迭代器交換 
        return __first2;
    }
}
int main(){
    std::vector< int > test { 3, 8 ,10, 24 } ;
    for( auto &x : test ) {
      std::cout << x << ' ' ;
    }
    std::cout <<'\n' ;
    auto it1 = test.begin() ;
    auto it2 = test.begin()+2;
    //確保呼叫的是我們自己的swap

    lthstd::myiter_swap( it1 ,it2 ) ;
    for( auto &x : test) {
      std::cout << x <<' ';
    }
    cout <<'\n';
    std::vector< int > test2 {123,23,12,324,32525};
    lthstd::swap_ranges( test.begin(), test.end() , test2.begin() ) ;  
    for( auto &x : test) {
      std::cout << x <<' ';
    }
    cout <<'\n';
    for( auto &x :test2) {
        std::cout << x <<' ';
    }
    /*最後結果希望讀者自己編寫
    因為vector的初始化使用了init list
    所以版本推薦c++ 11 以上*/
    return 0 ;
}