1. С помошью стандартной модели можно реализовать все три типа параметров, но в местах вызова функций непонятно передается параметр по ссылке или по значению. Также для стандартной модели существует неавное приведение типов.
   
2. Для define-ов, так как они являются просто заглушками, характерны все высше перечисленные недостатки. К ним еще прибавляется несинхронизированность между вставленными IN, IN_OUT и OUT "украшательсвами" и реальными характеристиками параметров в результате частых изменений кода.

function_0( b );

function_0( d );

function_0( in< Base& >( b ) );

function_0( in< Base& >( d ) );

class A
{
};

void sink1(std::unique_ptr<const A> arg)
{
}

void sink2(in<std::unique_ptr<const A>> arg)
{
}

int main()
{
  std::unique_ptr<A> p1(new A);

  sink1(std::move(p1)); // ok

  std::unique_ptr<A> p2(new A);

  sink2(in<std::unique_ptr<const A>>(std::move(p2))); // error
}

MyType z = in<MyType&>(in<MyType&>(a) + in<MyType&>(in<MyType&>(b) * in<MyType&>(c)));

MyType z = a + b * c;

KO>class A
KO>{
KO>};

KO>void sink1(std::unique_ptr<const A> arg)
KO>{
KO>}

KO>void sink2(in<std::unique_ptr<const A>> arg)
KO>{
KO>}

KO>int main()
KO>{
KO>  std::unique_ptr<A> p1(new A);

KO>  sink1(std::move(p1)); // ok

KO>  std::unique_ptr<A> p2(new A);

KO>  sink2(in<std::unique_ptr<const A>>(std::move(p2))); // error
KO>}
KO>

class A
{
};

void sink1( const std::unique_ptr< const A > arg)
{
}

void sink2( in< std::unique_ptr< const A >& > arg)
{
}

int main( int argc, char **argv )
{
  std::unique_ptr< A > p1( new A );
  sink1( std::move( p1 ) ); // ok

  std::unique_ptr< A > p2( new A );
  sink2( in< std::unique_ptr< const A >& >( std::move( p2 ) ) ); // ok

  return 0;
}

KO>MyType z = in<MyType&>(in<MyType&>(a) + in<MyType&>(in<MyType&>(b) * in<MyType&>(c)));
KO>

KO>MyType z = a + b * c;
KO>

KO>>>class A
KO>>>{
KO>>>};

KO>>>void sink1(std::unique_ptr<const A> arg)
KO>>>{
KO>>>}

KO>>>void sink2(in<std::unique_ptr<const A>> arg)
KO>>>{
KO>>>}

KO>>>int main()
KO>>>{
KO>>>  std::unique_ptr<A> p1(new A);

KO>>>  sink1(std::move(p1)); // ok

KO>>>  std::unique_ptr<A> p2(new A);

KO>>>  sink2(in<std::unique_ptr<const A>>(std::move(p2))); // error
KO>>>}
KO>>>

KO>>>MyType z = in<MyType&>(in<MyType&>(a) + in<MyType&>(in<MyType&>(b) * in<MyType&>(c)));
KO>>>

KO>>>MyType z = a + b * c;
KO>>>

GRF>>Мы и не планировали что in, in_out и out будут так применяться .

KO>А как же ещё им применяться? Входные параметры есть, почему их не надо помечать? Впрочем, я, кажется, понимаю: благодаря удачным названиям функций способ использования передаваемых параметров очевиден, может, тогда, вместо изобретения велосипедов, стоит давать более удачные названия функциям?

void function( in< MyType& > a, in< MyType& > b, in< MyType& > c )
{
   MyType z = a() + b() * c();
}

MyType z = a + b * c;

KO>>>>MyType z = in<MyType&>(in<MyType&>(a) + in<MyType&>(in<MyType&>(b) * in<MyType&>(c)));
KO>>>>

GRF>>>Мы и не планировали что in, in_out и out будут так применяться .

KO>>А как же ещё им применяться? Входные параметры есть, почему их не надо помечать? Впрочем, я, кажется, понимаю: благодаря удачным названиям функций способ использования передаваемых параметров очевиден, может, тогда, вместо изобретения велосипедов, стоит давать более удачные названия функциям?

GRF>void function( in< MyType& > a, in< MyType& > b, in< MyType& > c )
GRF>{
GRF>   MyType z = a() + b() * c();
GRF>}
GRF>

MyType operator+( in< MyType& > lhs, in< MyType& > rhs )
{
    return ...;
}

GRF>MyType z = a + b * c;
GRF>

KO>>>>>MyType z = in<MyType&>(in<MyType&>(a) + in<MyType&>(in<MyType&>(b) * in<MyType&>(c)));
KO>>>>>

GRF>>>>Мы и не планировали что in, in_out и out будут так применяться .

KO>>>А как же ещё им применяться? Входные параметры есть, почему их не надо помечать? Впрочем, я, кажется, понимаю: благодаря удачным названиям функций способ использования передаваемых параметров очевиден, может, тогда, вместо изобретения велосипедов, стоит давать более удачные названия функциям?

GRF>>void function( in< MyType& > a, in< MyType& > b, in< MyType& > c )
GRF>>{
GRF>>   MyType z = a() + b() * c();
GRF>>}
GRF>>

KO>MyType operator+( in< MyType& > lhs, in< MyType& > rhs )
KO>{
KO>    return ...;
KO>}
KO>

GRF>>MyType z = a + b * c;
GRF>>

#ifndef SPECIFICATION_HPP
#   define SPECIFICATION_HPP

#   if 1 // in< class Type > - Functions input parameter
/**
 * @brief Functions input parameter
 * @tparam Type none reference input parameter type
 */
template< class Type >
class in
{
public:
    /**
     * Initialization constructor
     * @param value input parameter value
     */
    explicit in( const Type& value ): value_( value ) {}

    /**
     * Cast operator
     * @return input parameter value
     */
    operator const Type&() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return input parameter value
     */
    const Type& operator ()() const
    {
        return value_;
    }

private:
    template< class OtherType >
    in( const OtherType& value ); // disable implicit conversion for none reference objects

    /**
     * input parameter value
     */
    const Type& value_;
};

/**
 * @brief Functions input parameter
 * @tparam Type reference input parameter type
 */
template< class Type >
class in< Type& >
{
public:
    /**
     * Initialization constructor
     * @param value input parameter value
     */
    explicit in( const Type& value ): value_( value ) {}

    /**
     * Cast operator
     * @return input parameter value
     */
    operator const Type&() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return input parameter value
     */
    const Type& operator ()() const
    {
        return value_;
    }

private:
    /**
     * input parameter value
     */
    const Type& value_;
};

/**
 * @brief Functions input parameter
 * @tparam Type pointer input parameter type
 */
template< class Type >
class in< Type* >
{
public:
    /**
     * Initialization constructor
     * @param value input parameter value
     */
    explicit in( const Type* const value ): value_( value ) {}

    /**
     * Cast operator
     * @return input parameter value
     */
    operator const Type*() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return input parameter value
     */
    const Type* operator ()() const
    {
        return value_;
    }

    /**
     * Member selection by pointer operator
     * @return input parameter value
     */
    const Type* operator ->() const
    {
        return value_;
    }

private:
    /**
     * input parameter value
     */
    const Type* const value_;
};
#   endif

#   if 1 // in_out< class Type& > - Functions input-output parameter
/**
 * @brief Functions input-output parameter
 * @tparam Type none pointer input-output parameter type
 */
template< class Type >
class in_out
{
public:
    /**
     * Initialization constructor
     * @param value input-output parameter value
     */
    explicit in_out( Type& value ): value_( value ) {}

    /**
     * Cast operator
     * @return input-output parameter value
     */
    operator Type&() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return input-output parameter value
     */
    Type& operator ()() const
    {
        return value_;
    }

    /**
     * Assignment operator
     * @param value         assignment value
     * @tparam ValueType    assignment value type
     * @return input-output parameter value
     */
    template< class ValueType >
    Type& operator =( const ValueType& value )
    {
        return value_ = value;
    }

private:
    /**
     * input-output parameter value
     */
    Type& value_;
};

/**
 * @brief Functions input-output parameter
 * @tparam Type pointer input-output parameter type
 */
template< class Type >
class in_out< Type* >
{
public:
    /**
     * Initialization constructor
     * @param value input-output parameter value
     */
    explicit in_out( Type* & value ): value_( value ) {}

    /**
     * Cast operator
     * @return input-output parameter value
     */
    operator Type* &() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return input-output parameter value
     */
    Type* & operator ()() const
    {
        return value_;
    }

    /**
     * Assignment operator
     * @param value         assignment value
     * @tparam ValueType    assignment value type
     * @return input-output parameter value
     */
    Type* & operator =( Type* value )
    {
        return value_ = value;
    }

    /**
     * Member selection by pointer operator
     * @return input-output parameter value
     */
    Type* operator ->() const
    {
        return value_;
    }

private:
    /**
     * input-output parameter value
     */
    Type* & value_;
};
#   endif

#   if 1 // out< class Type* > - Functions output parameter
/**
 * @brief Functions output parameter
 * @tparam Type none pointer output parameter type
 */
template< class Type >
class out
{
public:
    /**
     * Initialization constructor
     * @param value output parameter value
     */
    explicit out( Type& value ): value_( value ) {}

    /**
     * Cast operator
     * @return output parameter value
     */
    operator Type&() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return output parameter value
     */
    Type& operator ()() const
    {
        return value_;
    }

    /**
     * Assignment operator
     * @param value         assignment value
     * @tparam ValueType    assignment value type
     * @return output parameter value
     */
    template< class ValueType >
    Type& operator =( const ValueType& value )
    {
        return value_ = value;
    }

    /**
     * Checks if parameter reference is null
     * @return <code>true</code> if parameter is null reference and <code>false</code> if parameter has reference
     */
    bool is_null()
    {
        return (&value_) == NULL;
    }

    /**
     * Creates null reference
     * @return null reference object
     */
    static Type& null()
    {
        return *reinterpret_cast< Type* >( NULL );
    }

private:
    /**
     * output parameter value
     */
    Type& value_;
};

/**
 * @brief Functions output parameter
 * @tparam Type pointer output parameter type
 */
template< class Type >
class out< Type* >
{
public:
    /**
     * Initialization constructor
     * @param value output parameter value
     */
    explicit out( Type* & value ): value_( value ) {}

    /**
     * Cast operator
     * @return output parameter value
     */
    operator Type* &() const
    {
        return value_;
    }

    /**
     * Gets parameter value
     * @return output parameter value
     */
    Type* & operator ()() const
    {
        return value_;
    }

    /**
     * Assignment operator
     * @param value         assignment value
     * @tparam ValueType    assignment value type
     * @return output parameter value
     */
    Type* & operator =( Type* value )
    {
        return value_ = value;
    }

    /**
     * Member selection by pointer operator
     * @return output parameter value
     */
    Type* operator ->() const
    {
        return value_;
    }

    /**
     * Checks if parameter reference is null
     * @return <code>true</code> if parameter is null reference and <code>false</code> if parameter has reference
     */
    bool is_null()
    {
        return (&value_) == NULL;
    }

    /**
     * Creates null reference
     * @return null reference object
     */
    static Type* & null()
    {
        return *reinterpret_cast< Type** >( NULL );
    }

private:
    /**
     * output parameter value
     */
    Type* & value_;
};
#   endif

/**
 * Ostream output operator
 * @param os            output stream
 * @param output        output value
 * @return output stream
 * @tparam CharType     @a os character type
 * @tparam OutputType   @a output type
 */
template< class CharType, class OutputType >
std::basic_ostream< CharType >& operator <<( in_out< std::basic_ostream< CharType > > os, const OutputType& output )
{
    return os() << output;
}

#endif /* SPECIFICATION_HPP */

MyType operator+( in< MyType& > lhs, in< MyType& > rhs )
{
    return lhs() + rhs();
}