Let's play some more. At some point in our program we defined tt(int b). Then,
in a compound statement we need to construct an em(anonymous) tt(Data) object,
initialized by tt(b), and then we're supposed to display tt(b) itself:
    COMMENT(examples/ambiguity.cc)
            verb(    int b = 18;
    {
        Data(b);
        cout << b;
    })

About that tt(cout) statement the compiler tells us (I modified the
error message to reveal its meaning):

em(error: cannot bind `std::ostream & << Data const &')

Here we didn't insert tt(int b) but tt(Data b). Had we omitted the compound
statement, the compiler would have complained about a doubly defined tt(b)
entity, as tt(Data(b)) simply means tt(Data b), a tt(Data) object constructed
by default. Here, the parentheses around tt(b) are superfluous and may be
omitted by the compiler when parsing a definition or declaration.

    Of course, the question now becomes how a temporary object tt(Data),
initialized with tt(int b) em(can) be defined. Remember that the compiler may
remove superfluous parentheses. So, what we need to do is to pass an tt(int)
to the anonymous tt(Data) object, without using the tt(int)'s name.
    itemization(
    it() We can use a cast: tt(Data(static_cast<int>(b)));
    it() We can use a curly brace initialization: tt(Data{ b }).
    )

Values and types make big differences. Consider the following definitions:
        verb(    Data (*d4)(int);    // 1
    Data (*d5)(3);      // 2)

Definition 1 should cause no problems: it's a pointer to a function,
expecting an tt(int), returning a tt(Data) object. Hence, tt(d4) is a pointer
variable.  

    Definition 2 is slightly more complex. Yes, it's a pointer. But it has
nothing to do with a function. So what's that argument list containing 3 doing
there? Well, it's not an argument list. It's an initialization that looks like
an argument list. Remember: variables can be initialized using assignment
statements, using parentheses, or using curly braes. In general, they're
interchangeable. So instead of tt(`(3)') we could have written tt(`= 3') or
tt(`{3}'). Let's pick the first alternative, resulting in:
        verb(    Data (*d5) = 3;)

Now we get to `play compiler' again. Removing some more superfluous
parentheses we get:
        verb(    Data *d5 = 3;)

It's a pointer to a tt(Data) object, initialized to 3. This is
em(syntactically) correct, but em(semantically) incorrect: at address 3
there's no tt(Data) object. If we had initially written
        verb(     Data (*d5)(&d1);      // 2)

the fun resulting from contrasting tt(int) and tt(3) would most likely
have been masked.
