CODEWITHSUNDEEP
c++boosttype-traits
feelfree
feelfree

Reputation: 11753

Why bool is not regarded as boost::true_type in C++?

The following codes come from an example code to illustrate how to use boost::type_traits. It will use two methods to swap two variables. It is easy to understand that when the two variables are integer (int) their type traits correspond to true_type. However, when two variables are bool type they are not regarded as true_type any more. Why would it happen? Thanks. 

#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;
}

Upvotes: 0

Views: 296

Answers (1)

Marshall Clow
Marshall Clow

Reputation: 16670

You've got the answer there in your code (as a comment):

See is both arguments are non-proxying iterators

vector<bool> has proxy iterators, because you can't refer directly to a bit. If vector<bool> stored its' elements as individual booleans (taking 1-4 bytes/entry, depending on the system), the iterators could be non-proxying. But instead, vector<bool> stores 8 entries/byte and uses proxy iterators.

Upvotes: 2

Related Questions