Warum wird Bool nicht als boost :: true_type in C++ betrachtet?

Question

Die folgenden Codes stammen aus einem Beispielcode, um zu veranschaulichen, wie boost :: type_traits verwendet wird. Es wird zwei Methoden verwenden, um zwei Variablen zu tauschen. Es ist leicht zu verstehen, dass, wenn die beiden Variablen ganzzahlig (int) sind, ihre Typmerkmale true_type entsprechen. Wenn zwei Variablen vom bool-Typ sind, werden sie nicht mehr als true_type angesehen. Warum würde es passieren? Vielen Dank.

#include <iostream> 
#include <typeinfo> 
#include <algorithm> 
#include <iterator> 
#include <vector> 
#include <memory> 

#include <boost/test/included/prg_exec_monitor.hpp> 
#include <boost/type_traits.hpp> 

using std::cout; 
using std::endl; 
using std::cin; 

namespace opt{ 

// 
// iter_swap: 
// tests whether iterator is a proxying iterator or not, and 
// uses optimal form accordingly: 
// 
namespace detail{ 

template <typename I> 
static void do_swap(I one, I two, const boost::false_type&) 
{ 
    typedef typename std::iterator_traits<I>::value_type v_t; 
    v_t v = *one; 
    *one = *two; 
    *two = v; 
} 
template <typename I> 
static void do_swap(I one, I two, const boost::true_type&) 
{ 
    using std::swap; 
    swap(*one, *two); 
} 

} 

template <typename I1, typename I2> 
inline void iter_swap(I1 one, I2 two) 
{ 
    // 
    // See is both arguments are non-proxying iterators, 
    // and if both iterator the same type: 
    // 
    typedef typename std::iterator_traits<I1>::reference r1_t; 
    typedef typename std::iterator_traits<I2>::reference r2_t; 

    typedef boost::integral_constant<bool, 
     ::boost::is_reference<r1_t>::value 
     && ::boost::is_reference<r2_t>::value 
     && ::boost::is_same<r1_t, r2_t>::value> truth_type; 

    detail::do_swap(one, two, truth_type()); 
} 


}; // namespace opt 

int cpp_main(int argc, char* argv[]) 
{ 
    // 
    // testing iter_swap 
    // really just a check that it does in fact compile... 
    std::vector<int> v1; 
    v1.push_back(0); 
    v1.push_back(1); 
    std::vector<bool> v2; 
    v2.push_back(0); 
    v2.push_back(1); 
    opt::iter_swap(v1.begin(), v1.begin()+1); 
    opt::iter_swap(v2.begin(), v2.begin()+1); 

    return 0; 
} 

Answer 1

Sie haben die Antwort dort im Code bekommen (als Kommentar):

See ist beiden Argumente sind nicht-Proxying Iteratoren

vector<bool> hat Proxy-Iteratoren, weil Sie können nicht direkt auf ein Bit verweisen. Wenn vector<bool> seine Elemente als einzelne Boolesche Elemente gespeichert hat (je nach System 1-4 Byte/Eintrag), könnten die Iteratoren nicht-Proxying sein. Stattdessen speichert vector<bool> 8 Einträge/Byte und verwendet Proxy-Iteratoren.