為什么C 禁止這種部分專用化？

為什么C 禁止這種部分專業化？

這種禁止的背后是什么樣的哲學，讓我可以接受它？
如果沒有這個禁令，編程會容易得多。

模板應防止冗余。

模板應防止出現冗余。
現在我必須為每一個帶有int d = 3的N類產生冗余。

//__________________________________________
//__________________________________________
// //
template<class N, int d>
class MyClass
{
public:
    void doo（）。
};

//__________________________________________
//__允許的_______________________________。
//
template<class N, int d>
void MyClass<N, d>::doo（)
{
    cout << "general"。
}

//__________________________________________
//__禁止的_____________________________。
//
template<class N>  
void MyClass<N, 3>::doo( )
{
    cout << "部分專業化"。
}

uj5u.com熱心網友回復：

首先，你需要對類本身進行部分專業化。就是這個類是一個模板。它的成員函式是一個非模板函式。 一個類的部分專業化可以在其定義上有所不同。也就是說，它們可以有不同的成員集。

例如

template<class N, int d>
class MyClass
{
public:
    void doo（）。
};

template<class N, int d>
void MyClass<N, d>::doo（)
{
    std::cout << "General";
}

template<class N>
class MyClass<N, 3>
{
public:
    void doo（）。
};

template<class N>  
void MyClass<N, 3>::doo( )
{
    std::cout << "部分專業化"。
}

至于函式模板，它們有自己的函式多載和函式特殊化機制。

uj5u.com熱心網友回復：

你可以先對類進行部分專業化，然后為專業化后的類實作方法：

Demo

uj5u.com熱心網友回復：

函式的部分專業化是一件非常非常棘手的事情，尤其是當你允許多載函式的時候。

它可能會導致不可專門化的函式，或者專門化發生在意外的多載上，或者專門化永遠不能被呼叫。

我最好的建議是遠離函式的專業化。

而對于你的問題，我想說，最好是簡單地使用C 17 if constexpr：

template<class N, int d>。
void MyClass<N, d>::doo（)
{
    if constexpr (d !=3) {
        cout << "General";
    } else{
        cout << "只有當d == 3"。
    }

uj5u.com熱心網友回復：

我過去經常依賴模式匹配，這使我經常容易受到語言的這種限制，對此我從未找到一個優雅的實用解決方案。 我想我本能地學會了遠離這種設計，盡管我仍然偶爾會遇到這種情況。

我知道的解決方案有四種：

我知道的解決方案有四種：

我知道的解決方案有四種。

1. 現代解決方案（if constexpr），（實用但不優雅，IMO）。
2. 經典的解決方案（在現實世界中不實用）。
3. 經典解決方案 CRTP (實用但優雅?)
4. "深奧 "的解決方案，enable_if（不優雅的 IMO）
。

這篇文章主要闡述了第3個問題。

這些解決方案中沒有一個能讓我100%滿意。 我看不出有什么基本的理由，當語言遇到一個專門的成員函式宣告時，不能直接對模板類進行專業化處理，至少要有限制。

例如，考慮一下如果你有一個更復雜的類會發生什么：

template<class N, int d>
class MyClass
{
public:
    void A（） const{....}。
    void B（） const{....}。
    .
    .
    .
    void Z（） const{....}。
    void doo(){std::cout << "general";}; }
};

不一定，但有可能你還需要有大量重復的代碼：

template<class N>
class MyClass<N, 3>
{
    void A（） const{....}.
    void B（） const{....}。
    .
    .
    .
    void Z（） const{....}。
    void doo（）。
};

我想不出一個最糟糕的DRY（Don't repeat yourself）違規案例。

template<class MyClassCRTP>
class BasicMyClass<MyClassCRTP> // eventually we need will need to know the derived class.
{
public:
    void A（） const{....}。
    void B（） const{....}。
    .
    .
    .
    void Z（） const{....}。
};

template<class N, int d>
class MyClass : BasicMyClass<MyClass<N, d> >
{
public:
    void doo(){std::cout << "general";};?
};

template<class N>
class MyClass<N, 3> : BasicMyClass<MyClass<N, 3> >
{
    void doo（）。
};

現在你可以對MyClass<N, 3>::doo進行專業化處理，而不需要太多的重復代碼。

這真的很優雅嗎？我不知道。 它確實也打開了其他的麻煩事。 當然不是很理想，我們想對一個（方法）函式進行專業化處理，結果是我們有了額外的類！

這是不理想的。

template<class N, int d>。
class MyClass
{
public:
    template<class Dummy, std::enable_if<d ! = 3 and sizeof（Dummy*）, int> = 0>
    void doo(){std::cout << "general";}。
    template<class Dummy, std:: enable_if<d == 3 and sizeof（Dummy*）, int> = 0>
    void doo(){std::cout << "special";}; };cout << "special";< ; }
};

標籤：

上一篇：如何讓函式模板取用的可呼叫型別與之匹配？

下一篇：Kotlin的術語"mutable"是錯誤的嗎？