C++因式分解模板類的tempate方法專業化，可能嗎？

Question

我在模板類中有一個模板方法。
我讀過一個方法不能專門化，沒有專門的類之前。
但我想分解一些這些方法，這可能嗎？

例子：

class One { 
public: 
    static const int number = 1; 
}; 

class Two { 
public: 
    static const int number = 2; 
};  

template<typename num> class A { 
private: 
    num n; 

public: 
    template<typename type> 
    void multiplyBy(); // by 1 if <int> or 1,5 if <float> 
}; // A 

template<> template<> void A<One>::multiplyBy<int>() { 
    std::cout << 1.0*n.number << std::endl; 
} 

template<> template<> void A<One>::multiplyBy<float>() { 
    std::cout << 1.5*n.number << std::endl; 
} 

template<> template<> void A<Two>::multiplyBy<int>() { 
    std::cout << 1.0*n.number << std::endl; 
} 

template<> template<> void A<Two>::multiplyBy<float>() { 
    std::cout << 1.5*n.number << std::endl; 
} 

int main() { 
    A<One> aOne; 
    A<Two> aTwo; 
    aOne.multiplyBy<int>(); // 1 
    aOne.multiplyBy<float>(); // 1.5 
    aTwo.multiplyBy<int>(); // 2 
    aTwo.multiplyBy<float>(); // 3 

    return 0; 
} 

一個計算器相關的問題：C++ specialization of template function inside template class
尤其是此評論：C++ specialization of template function inside template class

有我扣除比沒有辦法因式分解multiplyBy（），一個用於int和另一個用於float？
由於英語不是我的自然語言，我可能會錯過簡單的東西，也許是部分專業化的解決方法。

編輯：把A :: n私下放在一起以便更好地匹配我的問題。

Answer 1

您可以使用標籤調度：

#include <iostream> 

class One { 
public: 
    static const int number = 1; 
}; 

class Two { 
public: 
    static const int number = 2; 
}; 

template<typename num> 
class A { 
    public: 
    num n; 

    private: 
    template<typename> struct Tag {}; 

    void multiplyBy(Tag<int>) { 
     std::cout << 1.0*n.number << std::endl; 
    } 

    void multiplyBy(Tag<float>) { 
     std::cout << 1.5*n.number << std::endl; 
    } 

    public: 
    template<typename type> 
    void multiplyBy() { 
     multiplyBy(Tag<type>()); 
    } 
}; 


int main() { 
    A<One> aOne; 
    A<Two> aTwo; 
    aOne.multiplyBy<int>(); // 1 
    aOne.multiplyBy<float>(); // 1.5 
    aTwo.multiplyBy<int>(); // 2 
    aTwo.multiplyBy<float>(); // 3 

    return 0; 
} 

Answer 2

但我想分解一些這樣的方法，這有可能嗎？

你可能知道，你不能使用：

template<> template<> void A<One>::multiplyBy<int>() { 
    std::cout << 1.0*n.number << std::endl; 
} 

沒有專門A<One>。

你可以做一些線沿線的：

#include <iostream> 

class One { 
public: 
    static const int number = 1; 
}; 

class Two { 
public: 
    static const int number = 2; 
};  

template<typename num, typename type = int> struct MultiplyBy { 
    static void doit(num n) 
    { 
     std::cout << 1.0*n.number << std::endl; 
    } 
}; 

template<typename num> struct MultiplyBy<num, float> { 
    static void doit(num n) 
    { 
     std::cout << 1.5*n.number << std::endl; 
    } 
}; 

template<typename num> class A { 
public: 
    num n; 

    template<typename type> 
    void multiplyBy() 
    { 
    MultiplyBy<num, type>::doit(n); 
    } 
}; 


int main() { 
    A<One> aOne; 
    A<Two> aTwo; 
    aOne.multiplyBy<int>(); // 1 
    aOne.multiplyBy<float>(); // 1.5 
    aTwo.multiplyBy<int>(); // 2 
    aTwo.multiplyBy<float>(); // 3 

    return 0; 
}