Here are some examples of how simple definitions where the compiler deduces
template arguments can (and cannot) be specified. 

    Starting point:
    verb(    template <class ...Types>           // any set of types
    class Deduce
    {
        public:
            Deduce(Types ...params);    // constructors
            void fun();                 // a member function
    };)

Some definitions:
        verb(                                    // deduce:     full definition:
                                    // --------------------------------
    Deduce first{1};                // 1: int   -> Deduce<int> first{1} 
    Deduce second;                  // no Types -> Deduce<> second;  
    Deduce &&ref = Deduce<int>{ 1 };// int      -> Deduce<int> &&ref

    template <class Type>
    Deduce third{ static_cast<Type *>(0) };)

The template tt(third) is a recipe for constructing tt(Deduce)
objects from a type that's specified for tt(third). The pointer's type simply 
is a pointer to the specified type (so, specifying tt(third<int>) implies an
tt(int *)). Now that the type of tt(third)'s argument is available (i.e., an
tt(int *)) the compiler deduces that tt(third{0}) is a tt(Deduce<int *>).

This tt(Deduce<int *>) object could, e.g., be used to initialize a named
tt(Deduce<int *>) object:
        verb(    auto x = third<int>;        // x's full definition: Deduce<int *> x{0})

tt(Deduce's) member functions can be used by anonymous and named objects:
        verb(    x.fun();                    // OK: fun called by named object
    third<int>.fun();           // OK: fun called by anonymous object)

Here are some examples that won't compile:
        verb(    extern Deduce object;       // not an object definition
    Deduce *pointer = 0;        // any set of types could be intended
    Deduce function();          // same.)

When defining objects, either using function-type or curly brace definitions
template argument deduction is realized as follows:
    itemization(
    it() First, a list of available constructors is formed. The list contains
all available ordinary constructors and constructor templates (i.e,
constructors defined as member templates);
    it() For each element of that list a parallel imaginary function
is formed by the compiler (forming function templates for constructor
templates, and ordinary functions for ordinary constructors);
    it() The return types of these imaginary functions are the class types of
the constructors, using the template parameters of the original class
template. For example, for the tt(Deduce::Deduce) constructor the imaginary
function 
        verb(    template <class ...Types>
    Deduce<Types ...> imaginary(Types ...params);)

is formed.
    it() Next, ordinary argument deduction and overload resolution is applied
to the set of imaginary functions. If this results in a best match for 
one of these imaginary functions then that function's class type (or
specialization) will be used. Otherwise the program is ill-formed.
    )

Let's apply this process to the class tt(Deduce). The set of imaginary
functions matching tt(Deduce) looks like this:
        verb(                                        // already encountered: matching
    template <class ...Types>           // Deduce(Types ...params)
    Deduce<Types ...> imaginary(Types ...params);

                                        // the copy constructor: matching
    template <class ...Types>           // Deduce(Deduce<Types ...> const &)
    Deduce<Types ...> imaginary(Deduce<Types ...> const &other);
                                    
                                        // the move constructor, matching
    template <class ...Types>           // Deduce(Deduce<Types ...> &&)
    Deduce<Types ...> imaginary(Deduce<Types ...> &&tmp);)

For the construction tt(Deduce first{1}) the first imaginary function wins
the overload contest, resulting in the template argument deduction tt(int) for
tt(class ...Types), and hence tt(Deduce<int> first{1}) is defined.

Note that when a class template is nested under a class template, the nested
class template's name depends on the outer class type. The outer class then
provides the name qualifier for the inner class template. In such cases
template argument deduction is used for the nested class, but (as it is not
used for name qualifiers) is not used for the outer class. Here is an example:
adding a nested class template to tt(Outer):

    verb(    template <class OuterType>
    class Outer
    {
        public:
            template <class InnerType>
            struct Inner
            {
                Inner(OuterType);
                Inner(OuterType, InnerType);
                template <typename ExtraType>
                Inner(ExtraType, InnerType);
            };
    };
    // defining:
    Outer<int>::Inner inner{2.0, 1};)

In this case, the compiler uses these imaginary functions:
    verb(    template <typename InnerType>
    Outer<int>::Inner<InnerType>            // copy constructor
        imaginary(Outer<int>::Inner<InnerType> const &);

    template <typename InnerType>       
    Outer<int>::Inner<InnerType>            // move constructor
        imaginary(Outer<int>::Inner<InnerType> &&);

    template <typename InnerType>           // first declared constructor
    Outer<int>::Inner<InnerType> imaginary(int);

    template <typename InnerType>           // second declared constructor
    Outer<int>::Inner<InnerType> imaginary(int, InnerType);

    template <typename InnerType>           // third declared constructor
    template <typename ExtraType>       
    Outer<int>::Inner<InnerType> imaginary(ExtraType, InnerType);)

Template argument deduction for calling  tt(imaginary(2.0, 1)) results in
tt(double) for its first argument and tt(int) for its second. Overload
resolution then favors the last imaginary function, and so tt(ExtraType:
double) and tt(InnerType: int). Consequently, 
    verb(    Outer<int>::Inner inner{ 2.0, 1 };)

is defined as:
    verb(    Outer<int>::Inner<int> Inner{ 2.0, 1 };)

