使用CRTP技术确保唯一的模板参数

Question

From boost::units :

struct my_base_dimension1 : units::base_dimension<my_base_dimension1, 1> { };  // ok
struct my_base_dimension2 : units::base_dimension<my_base_dimension2, 2> { };  // ok
struct my_base_dimension3 : units::base_dimension<my_base_dimension3, 2> { };  // error

I'm trying to understand how the code ensures that template arguments are unique. I don't understand how check_base_dimension ends up returning a non-zero, which triggers ordinal_has_already_been_defined<true> . I think it has something to do with boost_units_is_registered() being redefined in base_dimension , but I have no idea how the friend version gets called. Any ideas?

The files in question are base_dimension.hpp and prevent_redefinition.hpp .

template<class Derived, long N,
         class = typename detail::ordinal_has_already_been_defined<
             check_base_dimension<Derived, N>::value
             >::type
         >
class base_dimension : public ordinal<N>
{
public:
    typedef base_dimension this_type;
    typedef list<dim<Derived,static_rational<1> >, dimensionless_type> dimension_type;
    typedef Derived type;

private:                                                                                                                           
    friend Derived*
    check_double_register(const units::base_dimension_ordinal<N>&)
        { return(0); }

    friend detail::yes
    boost_units_is_registered(const units::base_dimension_ordinal<N>&)
        { detail::yes result; return(result); }

    friend detail::yes
    boost_units_is_registered(const units::base_dimension_pair<Derived, N>&)
        { detail::yes result; return(result); }
};

Answer 1

Aha, I believe I have it.

The answer is in this section:

/// Register this ordinal
        /// INTERNAL ONLY
        friend detail::yes 
        boost_units_is_registered(const units::base_dimension_ordinal&) 
        { return(detail::yes()); }

        /// But make sure we can identify the current instantiation!
        /// INTERNAL ONLY
        friend detail::yes 
        boost_units_is_registered(const units::base_dimension_pair&) 
        { return(detail::yes()); }

The friend declaration indicates that a function matching those arguments exists, and returns detail::yes .

When the enum in check_base_dimension is instantiated for a given template, it looks for a boost_units_is_registered function that takes those two types. If no previous instantiation of those template parameters exists, it finds the function defined in prevent_redefinition.hpp that returns a detail::no , but if one does exist, it finds a declaration of a function (the friend ) matching those arguments that returns the detail::yes .

It's important to note that this is all at compile-time, not run-time. The compiler users argument-dependent lookup to find a matching function. The sizeof the result of that function depends only on what the function returns – it does not need to be run or called at all, it just needs a declaration that gives the return value's size. So when the compiler finds the friend function, it can determine the sizeof the return value then-and-there – the function need not actually have a definition. Of course, if you tried to use it (as in, have it actually run), you'd get a linker error, since it is declared but never defined.

As a result, the sizeof() is determined, at compile time, to be the size of a detail::yes which is distinct from the size of a detail::no . The result of the expression is thus false , and therefore check_base_dimension::value is false , and the instantiation of ordinal_has_already_been_defined does not get a member variable called type .

The compiler therefore throws an error stating that

detail::ordinal_has_already_been_defined<check_base_dimension<Derived, N>::value> does not have a member variable 'type'

Or similar. In the end, the goal is achieved: you cannot compile the code with two instances of the class with the same template parameter values. Huzzah!