chapter-3.cpp

Go to the documentation of this file.

// ===-- chapter-3/chapter-3.cpp -------------------------- -*- C++ -*- --=== //
#if __cplusplus >= 202002L
#   include "c++20/exercise-3-0.hpp"
#else
#   include "exercise-3-0.hpp"
#endif
#include "exercise-3-1.hpp"
#include "exercise-3-2.hpp"
#include "exercise-3-3.hpp"
#include "exercise-3-4.hpp"
#include "exercise-3-5.hpp"
#include "exercise-3-6.hpp"
 
#include <boost/static_assert.hpp>
 
#include <boost/mpl/equal.hpp>
#include <boost/mpl/vector_c.hpp>
 
 
namespace test_3_0
{
using namespace exercise_3_0;
 
#if __cplusplus >= 202002L
constexpr uint32_t one   = checked_binary(1);
constexpr uint32_t three = checked_binary(11);
constexpr uint32_t five  = checked_binary(101);
constexpr uint32_t seven = checked_binary(111);
constexpr uint32_t nine  = checked_binary(1001);
 
#   ifdef NEGATIVE_TEST  // Fails "check" in checked_binary().
constexpr uint32_t bogus = checked_binary(2);
#   endif
#else
unsigned const one   = checked_binary<1>::value;
unsigned const three = checked_binary<11>::value;
unsigned const five  = checked_binary<101>::value;
unsigned const seven = checked_binary<111>::value;
unsigned const nine  = checked_binary<1001>::value;
 
#   ifdef NEGATIVE_TEST // Fails BOOST_STATIC_ASSERT.
unsigned const bogus = checked_binary<2>::value;
#   endif
#endif
}
 
 
namespace test_3_1 {
using namespace exercise_3_1;
 
typedef boost::mpl::vector_c<int, 1, 2, 3> init_vector_t;
 
typedef ex_3_1<init_vector_t>::type new_vector_t;
init_vector_t x;
new_vector_t y;
 
typedef ex_3_1b<init_vector_t>::type new_vectorb_t;
new_vectorb_t z;
 
BOOST_STATIC_ASSERT((
    boost::mpl::equal<
        new_vectorb_t,
        boost::mpl::vector_c<int, 2, 3, 4> >::type::value));
 
} // namespace test_3_1
 
 
namespace test_3_2 {
using namespace exercise_3_2;
 
typedef boost::mpl::vector_c<int, 1, 2, 3> init_vector_t;
 
typedef ex_3_2<init_vector_t>::type new_vector_t;
new_vector_t x;
 
BOOST_STATIC_ASSERT((
    boost::mpl::equal<
        new_vector_t,
        boost::mpl::vector_c<int, 1, 4, 9> >::type::value));
 
} // namespace test_3_2
 
 
namespace {
 
static void test_exercise_3_5()
{
    using namespace exercise_3_5::section_3_1;
 
    // Test simple addition
    {
        quantity<float, length> len1(1.0);
        quantity<float, length> const len2(2.0);
 
        len1 = len1 + len2;
    }
 
    // Test multiplication
    {
        quantity<float, mass> const         m(2.3);
        quantity<float, acceleration> const a(0.3);
 
        quantity<float, force> const f = m*a;
        f.value(); // Quiet the unused var warning w/o disabling it totally
    }
 
    // Test division
    {
        quantity<float, length> const l(1.0);
        quantity<float, time> const   s(3.0);
 
        quantity<float, velocity> const v = l/s;
        v.value(); // Quiet the unused var warning w/o disabling it totally
    }
 
    // Exercise 3-5
    {
        quantity<float, force>              f(1.2);
        quantity<float, mass> const         m(2.3);
        quantity<float, acceleration> const a(0.3);
 
        f = f + m * a;
    }
}
 
} // namespace <anon>
 
int main()
{
    test_exercise_3_5();
    return 0;
}