chapter-2.cpp

Go to the documentation of this file.

// ===-- chapter-2/chapter-2.cpp -------------------------- -*- C++ -*- --=== //
#include "exercise-2-0.hpp"
#include "exercise-2-3.hpp"
#if __cplusplus >= 202002L
#   include "c++20/exercise-2-1.hpp"
#   include "c++20/exercise-2-2.hpp"
#   include "c++20/exercise-2-4.hpp"
#   include "c++20/exercise-2-5.hpp"
#else
#   include "exercise-2-1.hpp"
#   include "exercise-2-2.hpp"
#   include "exercise-2-4.hpp"
#   include "exercise-2-5.hpp"
#endif
 
#include <boost/type_traits/is_same.hpp>
 
#include <cxxabi.h>
 
#include <iostream>
#include <typeinfo>
 
 
// Testing / main()
 
namespace {
 
struct TestA { virtual ~TestA() {} };
struct TestB : TestA {};
 
static char const *demangle(char const *const name)
{
    static char buf[1024]; // Not re-entrant, but quick-and-dirty.
 
    size_t size = sizeof(buf)/sizeof(*buf);
    int    status;
 
    char const *const res = abi::__cxa_demangle(name, buf, &size, &status);
    return status != 0 ? NULL : res;
}
 
static void test_exercise_2_0()
{
#ifdef EXERCISE_2_0
    using namespace exercise_2_0;
    int z = 5;
 
    add_const_ref<int>::type x = z;
    add_const_ref<int&>::type y = z;
    std::cout << "Neither x: " << x << ", nor y: " << y
              << " are interesting.\n";
 
    std::cout <<
        boost::is_same<add_const_ref<int>::type, int const&>::value << '\n';
    std::cout <<
        boost::is_same<add_const_ref<int&>::type, int&>::value << '\n';
    std::cout <<
        boost::is_same<add_const_ref<int&>::type, int const&>::value << '\n';
    std::cout <<
        boost::is_same<
            add_const_ref<int const&>::type, int const&>::value << '\n';
    std::cout <<
        boost::is_same<
            add_const_ref<int const>::type, int const&>::value << '\n';
#endif
}
 
static void test_exercise_2_1()
{
#ifdef EXERCISE_2_1
    using namespace exercise_2_1;
    std::cout
        << boost::is_same<
               replace_type<void*, void, int>::type,
               int*>::value
        << '\n';
    std::cout
        << boost::is_same<
               replace_type<int const*[10], int const, long>::type,
               long*[10]>::value
        << '\n';
    std::cout
        << boost::is_same<
               replace_type<char& (*)(), char&, long&>::type,
               long& (*)()>::value
        << '\n';
    std::cout
        << boost::is_same<
               replace_type<char& (*)(char&), char&, long&>::type,
               long& (*)(long&)>::value
        << '\n';
#   if __cplusplus >= 202002L  // Test C++20 variadic template method.
    std::cout
        << boost::is_same<
               replace_type<char& (*)(char&, int, char*), char&, long&>::type,
               long& (*)(long&, int, char*)>::value
        << '\n';
    std::cout
        << boost::is_same<
               replace_type<float& (*)(char&, float*, float, float[5]),
                            float, long>::type,
               long& (*)(char&, long*, long, long[5])>::value
        << '\n';
#   endif
#   if NEGATIVE_TEST
    // This is an error in the current design:
    std::cout
        << boost::is_same<
               replace_type<char& (*)(char&), float, long&>::type,
               long& (*)(long&)>::value
        << '\n';
#   endif
#endif
}
 
static void test_exercise_2_2()
{
#ifdef EXERCISE_2_2
    using namespace exercise_2_2;
    TestB b;
    TestA *a_ptr = &b;
    TestB *b_ptr = polymorphic_downcast<TestB*>(a_ptr);
 
    std::cout << "Address of b_ptr = " << static_cast<void*>(b_ptr) << '\n';
 
    TestA& a_ref = b;
    TestB& b_ref = polymorphic_downcast<TestB&>(a_ref);
    std::cout << "Address of b_ref = " << static_cast<void*>(&b_ref) << '\n';
#endif
}
 
static void test_exercise_2_3()
{
#ifdef EXERCISE_2_3
    // ************************** TO-DO
#endif
}
 
static void test_exercise_2_4()
{
#ifdef EXERCISE_2_4
    using namespace exercise_2_4;
    // prints "int"
    std::cout << type_descriptor<int>() << '\n';
 
    // prints "char*"
    std::cout << type_descriptor<char*>() << '\n';
 
    // prints "short int[5]"
    std::cout << type_descriptor<short[5]>() << '\n';
 
    // prints "long int const*&"
    std::cout << type_descriptor<long const*&>() << '\n';
 
    // prints "char*()"
    std::cout << type_descriptor<char*()>() << '\n';
 
    // prints "char*()"
    std::cout << type_descriptor<char*(*)()>() << '\n';
#endif
}
 
static void test_exercise_2_5()
{
#ifdef EXERCISE_2_5
    using namespace exercise_2_5;
    std::cout << type_descriptor_eng<char*(*[])()>() << '\n';
#endif
}
 
} // namespace <anon>
 
 
int main()
{
    std::cout << demangle(typeid(int*).name()) << '\n';
 
    test_exercise_2_0();
    test_exercise_2_1();
    test_exercise_2_2();
    test_exercise_2_3();
    test_exercise_2_4();
    test_exercise_2_5();
    return 0;
}