C++11中基于模板类型的结构体函数特化实现方案

在VS编译无符号类型的TRational实例时，由于C11不支持if constexpr，编译器会实例化std::is_signed<T>::value分支内的代码，导致无符号类型使用负号操作触发C4146警告。以下是两种C11兼容的解决方案：

方案一：SFINAE + 模板成员函数 #

利用std::enable_if实现条件编译，仅为匹配类型实例化对应的ReduceMe版本：

#include <type_traits>
#include <cstdlib>

template <typename T>
class TRational {
private:
    T numerator;
    T denominator;

    // 有符号类型专属约分逻辑
    template <typename U = T>
    typename std::enable_if<std::is_signed<U>::value, void>::type
    ReduceMe() {
        if (denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
        T gcd_val = GCD(std::abs(numerator), std::abs(denominator));
        numerator /= gcd_val;
        denominator /= gcd_val;
    }

    // 无符号类型专属约分逻辑
    template <typename U = T>
    typename std::enable_if<std::is_unsigned<U>::value, void>::type
    ReduceMe() {
        T gcd_val = GCD(numerator, denominator);
        numerator /= gcd_val;
        denominator /= gcd_val;
    }

    // 自定义GCD实现（C++17前无标准库gcd）
    T GCD(T a, T b) {
        while (b != 0) {
            T temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

public:
    TRational(T num, T den) : numerator(num), denominator(den) {
        ReduceMe();
    }

    // 其他成员函数...
};

通过std::enable_if的特性，编译器只会为当前类型匹配对应的ReduceMe版本，不会实例化不符合条件的分支，彻底避免C4146警告。

方案二：类模板特化 #

将约分逻辑拆分到特化的基类中，让TRational继承对应类型的基类实现：

#include <type_traits>
#include <cstdlib>

// 基类模板框架
template <typename T, bool IsSigned = std::is_signed<T>::value>
struct RationalReducer;

// 有符号类型特化基类
template <typename T>
struct RationalReducer<T, true> {
protected:
    void Reduce(T& numerator, T& denominator) {
        if (denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
        T gcd_val = GCD(std::abs(numerator), std::abs(denominator));
        numerator /= gcd_val;
        denominator /= gcd_val;
    }

    T GCD(T a, T b) {
        while (b != 0) {
            T temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
};

// 无符号类型特化基类
template <typename T>
struct RationalReducer<T, false> {
protected:
    void Reduce(T& numerator, T& denominator) {
        T gcd_val = GCD(numerator, denominator);
        numerator /= gcd_val;
        denominator /= gcd_val;
    }

    T GCD(T a, T b) {
        while (b != 0) {
            T temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
};

// TRational继承特化后的基类
template <typename T>
class TRational : private RationalReducer<T> {
private:
    T numerator;
    T denominator;

    void ReduceMe() {
        this->Reduce(numerator, denominator);
    }

public:
    TRational(T num, T den) : numerator(num), denominator(den) {
        ReduceMe();
    }

    // 其他成员函数...
};

这种方式通过类模板特化，为有符号/无符号类型提供完全独立的约分逻辑实现，从根源上避免了无效代码的编译。

内容的提问来源于stack exchange，提问作者Henk Demper