C++ 如何减少函数模板专门化？

我正试图使用他们的反射系统编写一个在UE4中使用的属性验证器。 我首先想到的是：

class FDataValidator
{
public:
    FDataValidator( UObject & object, TArray< FText > & validation_errors ) :
        Object( object ),
        ValidationResult( validation_errors.Num() == 0 ? EDataValidationResult::Valid : EDataValidationResult::Invalid ),
        ObjectClass( Object.GetClass() ),
        ValidationErrors( validation_errors )
    {}

    template < class _TYPE_ >
    FDataValidator & GreaterThan( const FName property_name, const _TYPE_ value );

    EDataValidationResult Result() const
    {
        return ValidationResult;
    }

private:
    template < class _PROPERTY_TYPE_, class _VALUE_TYPE_, class _COMPARATOR_TYPE_ >
    FDataValidator & CompareProperty( const FName property_name, const _VALUE_TYPE_ value, _COMPARATOR_TYPE_ comparator = _COMPARATOR_TYPE_() )
    {
        if ( auto * property = GetTypedProperty< _PROPERTY_TYPE_ >( property_name ) )
        {
            const auto property_value = property->GetPropertyValue_InContainer( &Object );

            if ( !comparator( property_value, value ) )
            {
                AddError( FText::FromString( FString::Printf( TEXT( "%s must be greater than %f" ), *property_name.ToString(), value ) ) );
            }
        }

        return *this;
    }

    template < class _PROPERTY_TYPE_ >
    _PROPERTY_TYPE_ * GetTypedProperty( const FName property_name )
    {
        if ( auto * property = ObjectClass->FindPropertyByName( property_name ) )
        {
            if ( auto * typed_property = Cast< _PROPERTY_TYPE_ >( property ) )
            {
                return typed_property;
            }
        }

        return nullptr;
    }

    void AddError( FText text )
    {
        ValidationErrors.Emplace( text );
        ValidationResult = EDataValidationResult::Invalid;
    }

    UObject & Object;
    EDataValidationResult ValidationResult;
    UClass * ObjectClass;
    TArray< FText > & ValidationErrors;
};

template <>
FDataValidator & FDataValidator::GreaterThan< float >( const FName property_name, const float value )
{
    return CompareProperty< UFloatProperty, float, std::greater< float > >( property_name, value );
}

template <>
FDataValidator & FDataValidator::GreaterThan< int >( const FName property_name, const int value )
{
    return CompareProperty< UIntProperty, int, std::greater< int > >( property_name, value );
}

---

感谢

UFloatProperty

和其他数字类型似乎来自

TProperty\u numeric

。 因此，类似这样的解决方案可能是：

template <typename T>
FDataValidator& FDataValidator::GreaterThan<T>(const FName property_name, const T value)
{
    return CompareProperty<TProperty_Numeric<T>, T, std::greater<T>>(property_name, value);
}

模板
FDataValidator&FDataValidator:：GreaterThan（常量FName属性名称，常量T值）
{
返回CompareProperty（属性名称、值）；
}

template <typename T>
FDataValidator& FDataValidator::GreaterThan<T>(const FName property_name, const T value)
{
    return CompareProperty<TProperty_Numeric<T>, T, std::greater<T>>(property_name, value);
}