void Function(Value const&);
template<class T> void Function(T const& x) { Function(up_cast<Value>(x)); }


template<class To, class From>
typename enable_if<is_base_and_derived<To,From>, To const&>::type
up_cast(From const& x) { return x; }

template<class To, class From>
typename enable_if<is_base_and_derived<To,From>, To&>::type
up_cast(From& x) { return x; }

// или даже вообще
template<class T> void Function(T) { STATIC_ASSERT(false); }

void Function(ref_t<Value const> v);

// где
template<class T>
struct ref_t
{
    T& value;
    ref_t(T& v) : value(v) {}
    // методы и операторы для доступа - добавьте по вкусу
}

Value v = 0; // int ==> Value -> cctor
Function(v); // Value& -> Value const& ==> ref_t<Value>
Function(Value(0)); // Value -> Value const& ==> ref_t<Value>
Function(0); // int ==> Value -> Value const& ==> ref_t<Value>

W>// Неявно преобразуется к виду:
W>// ExplicitInt I( ExplicitInt::ImplicitRef( 0 ));
W>ExplicitInt I = 0; // OK

template<class T>
struct approved_t
{
    T value;
    /*implicit*/ approved_t(T v) : value(v) {}
};
// для вывода типа
template<class T> approved_t<T> approved(T v) { return approved_t<T>(v); }


template<Mega List Of Params>
class YourType
{
public:
    /*implicit*/ YourType(approved_t<T> t) : something(t.value) {.....}
    explicit YourType(T v) : something(v) {.....}
};


.....

YourType<Your Mega Args> x = 123; // хочется, но нельзя
YourType<Your Mega Args> x = YourType<Your Mega Args>(123); // громоздко
YourType<Your Mega Args> x = approved(123); // можно

void fun(YourType<Your Mega Args>);
fun(123); // нельзя
fun(YourType<Your Mega Args>(123)); // громоздко
fun(approved(123)); // можно

class test
{
   int i_;
public:
   test(int i) : i_(i) {}
};

test t = 1;

12.2/1
...
Even when the creation of the temporary object is avoided (12.8), all the semantic
restrictions must be respected as if the temporary object was created. [Example: even if the copy constructor
is not called, all the semantic restrictions, such as accessibility (clause 11), shall be satisfied. ]

class test
{
   int i_;
public:
   test(int i) : i_(i) {}
};

class test2
{
public:
   test2(const test& t) {}
};

test2 t = 1;

W>ExplicitTest TestObj1(0);                      // OK
W>ExplicitTest TestObj1 = ExplicitTest(0);       // OK
W>ExplicitTest *pTestObj = new ExplicitTest(0);  // OK
W>ExplicitTest TestObj2 = 0;                     // Want to be OK

W>void Function( const ExplicitTest &obj);

W>Function( 0 ); // Error
W>

class Param // то, что мы принимаем и используем
{
protected:
    // конструкторы
    Param();
    explicit Param(int); // здесь explicit для того, чтоб не ошибиться, пребывая в дружественном контексте
    .....
public:
    // всё остальное, предназначенное для использования
    .....
};

class Value : public Param // то, что мы создаём
{
public:
    // только конструкторы
    Value() {}
    /*implicit*/ Value(int x) : Param(x) {}
    .....
};

void Function(const Param& obj);

void usage()
{
    Value v1(0);
    Value v2 = 0;
    Function(Value(0));
    Function(0); // error
}

template<class Param>
class Value : public Param
{
public:
    Value() {}

    template<class A1>
    /*implicit*/ Value(A1 const& a1) : Param(a1) {}
    
    template<class A1, class A2>
    Value(A1 const& a1, A2 const& a2) : Param(a1,a2) {}
    
    // и т.д.
};

class ExplicitTest
{
    int m_a;
public:
    explicit ExplicitTest( int a ) :
        m_a( a ) {}
    ExplicitTest( const ExplicitTest &obj ) :
        m_a( obj.m_a ) {}
    virtual ~ExplicitTest() {}
};

ExplicitTest TestObj1(0);                      // OK
ExplicitTest TestObj1 = ExplicitTest(0);       // OK
ExplicitTest *pTestObj = new ExplicitTest(0);  // OK
ExplicitTest TestObj2 = 0;                     // Want to be OK

void Function( const ExplicitTest &obj);

Function( 0 ); // Error

12.2/1
...
even if the copy constructor is not called, all the semantic restrictions, such as accessibility (clause 11), shall be satisfied.
...

ExplicitTest TestObj2 = 0;

class ExplicitTest
{
public:
    ExplicitTest( int a );
// ...
};

void Function( const ExplicitTest &obj);

Function( 0 ); // Want to be error

W>class ExplicitTest
W>{
W>public:
W>    ExplicitTest( int a );
W>// ...
W>};

W>void Function( const ExplicitTest &obj);

W>Function( 0 ); // Want to be error
W>

W>Не понял вопроса?

Вообщем хочется запретить создавать неявно временные объекты и разрешить все остальное.

void Function(const Value& obj);

ExplicitTest TestObj2 = 0;

template < typename T1, typename T2 /*, ... */  >
class ExplicitTest
{
// ... 
};

typedef ExplicitTest< T1, T2 /*, ... */ > ExplicitTestInstance1;
typedef ExplicitTest< V1, V2 /*, ... */ > ExplicitTestInstance2;
// ...

void Function1( const ExplicitTestInstance1& );
void Function2( const ExplicitTestInstance2& );
// ...

template <typename T>
    class ExplicitTest
{
    // Объявим в private секции, чтоб явно не юзали )
    struct ImplicitRef
    {
        const T &m_a;
        ImplicitRef( const T &a ): m_a(a){}

    private:
        // Запрещаем присваивание, чтоб не ругался на const member
        ImplicitRef &operator =( const ImplicitRef & );
    };

    T m_a;

public:
    explicit ExplicitTest( const T &a ) :
        m_a( a ) {}

    ExplicitTest( const ExplicitTest &obj ) :
        m_a( obj.m_a ) {}

    // Самое интересное: неявное создание ImplicitRef
    // для неявной инициализации ExplicitTest.
    ExplicitTest( ImplicitRef ref ) :
        m_a( ref.m_a ) {}

    virtual ~ExplicitTest() {}
};

typedef ExplicitTest<int> ExplicitInt;

void Function1 ( const ExplicitInt & ref );
void Function2 ( ExplicitInt ref );

// Неявно преобразуется к виду:
// ExplicitInt I( ExplicitInt::ImplicitRef( 0 ));
ExplicitInt I = 0; // OK

// Неявно преобразуется к виду:
// Function1( ExplicitInt( 0 ));
Function1( 0 );      // Error here!!!
Function2( 0 );      // Error here!!!

void function( CRef<YourClass> );