C++ 类和成员函数模板专门化出错

我试图专门化一个

Color

类及其成员函数

to（）

，以便从一个颜色空间转换到另一个颜色空间并返回。以下是我目前掌握的情况：

enum ColorSpace {
    BGR, RGB, LAB, HSV, XYZ, YUV, HSL, CMY, YIQ, LUV, HLAB, LCH, OHTA
};

template<ColorSpace _CS, typename _Dtp> class Color;

template<typename _Dtp>
class Color<RGB, _Dtp> {

public:

    Color(_Dtp R, _Dtp G, _Dtp B) : R(R), G(G), B(B) { ;; };
    Color() : Color(0, 0, 0) { ;; };
    ~Color() { ;; };

    _Dtp R, G, B;

    template<ColorSpace _CS, typename _Dtp2 = _Dtp>
    Color<_CS, _Dtp2> to<>();

    template<typename _Dtp2 = _Dtp>
    Color<HSV, _Dtp2> to<HSV, _Dtp2>() {
        Color<HSV, _Dtp2> res;

        rgb2hsv(R, G, B, res.H, res.S, res.V);

        return res;
    }

};

template<typename _Dtp = double>
class Color<HSV, _Dtp> {

public:

    Color(_Dtp H, _Dtp S, _Dtp V) : H(H), S(S), V(V) { ;; };
    Color() : Color(0, 0, 0) { ;; };
    ~Color() { ;; };

    _Dtp H, S, V;

    template<ColorSpace _CS, typename _Dtp2 = _Dtp>
    Color<_CS, _Dtp2> to<>();

    template<typename _Dtp2 = _Dtp>
    Color<RGB, _Dtp2> to<RGB, _Dtp2>() {
        Color<RGB, _Dtp2> res;

        hsv2rgb(H, S, V, res.R, res.G, res.B);

        return res;
    }

};

我得到以下错误：

错误：类“Color”没有成员“to”

我的最后一个问题是，当我尝试为class

Color

使用默认类型时：

template<typename _Dtp = double>
class Color<RGB, _Dtp> {
...
...

模板
类颜色{
...
...

在这种情况下，我甚至不能写这个：

Color<RGB> c;

c色；

它给了我这个错误：

错误：需要一个声明

---

您的代码应该如下所示：

enum ColorSpace {
    BGR, RGB, LAB, HSV, XYZ, YUV, HSL, CMY, YIQ, LUV, HLAB, LCH, OHTA
};

template<ColorSpace _CS, typename _Dtp> class Color;

template<typename _Dtp>
class Color<RGB, _Dtp> {

public:

    Color( _Dtp R, _Dtp G, _Dtp B ) : R( R ), G( G ), B( B ) { ;; };
    Color() : Color( 0, 0, 0 ) { ;; };
    ~Color() { ;; };

    _Dtp R, G, B;


    template<ColorSpace _CSO, typename _Dtp2> struct STo;
    template<typename _Dtp2> struct STo<HSV, _Dtp2>
    {
        Color<HSV, _Dtp2> to()
        {
            Color<HSV, _Dtp2> res;

            rgb2hsv( R, G, B, res.H, res.S, res.V );

            return res;
        }
    };

    template<ColorSpace _CSO, typename _Dtp2>
    Color<_CSO, _Dtp2> to()
    {
        STo<_CSO, _Dtp2> object;
        return object.to();
    }

};

template<typename _Dtp>
class Color<HSV, _Dtp> {

public:

    Color( _DtpH, _DtpS, _DtpV ) : H( H ), S( S ), V( V ) { ;; };
    Color() : Color( 0, 0, 0 ) { ;; };
    ~Color() { ;; };

    _DtpH, S, V;

    template<ColorSpace _CSO, typename _Dtp2> struct STo;
    template<typename _Dtp2> struct STo<RGB, _Dtp2>
    {
        Color<RGB, _Dtp2> to()
        {
            Color<RGB, _Dtp2> res;

            hsv2rgb( H, S, V, res.R, res.G, res.B );

            return res;
        }
    };

    template<ColorSpace _CSO, typename _Dtp2>
    Color<_CSO, _Dtp2> to()
    {
        STo<_CSO, _Dtp2> object;
        return object.to();
    }
};

enum颜色空间{
BGR、RGB、实验室、HSV、XYZ、YUV、HSL、CMY、YIQ、LUV、HLAB、LCH、OHTA
};
模板类颜色；
模板
类颜色{
公众：
颜色（_dtpr，_dtpg，_dtpb）：R（R），G（G），B（B）{；}；
颜色（）：颜色（0,0,0）{；；}；
~Color（）{；；}；
_dtpr，G，B；
模板结构STo；
模板结构STo
{
颜色到（）
{
彩色分辨率；
rgb2hsv（R、G、B、res.H、res.S、res.V）；
返回res；
}
};
模板
颜色到（）
{
STo对象；
返回object.to（）；
}
};
模板
类颜色{
公众：
颜色（_DtpH，_DtpS，_DtpV）：H（H），S（S），V（V）{；}；
颜色（）：颜色（0,0,0）{；；}；
~Color（）{；；}；
_DtpH，S，V；
模板结构STo；
模板结构STo
{
颜色到（）
{
彩色分辨率；
hsv2rgb（H、S、V、res.R、res.G、res.B）；
返回res；
}
};
模板
颜色到（）
{
STo对象；
返回object.to（）；
}
};

---

你不能只写没有定义的函数专门化。这就是为什么你应该删除“to”函数中的括号。但在这种情况下，我们遇到了另一个问题-我们不能对函数使用部分专门化，但对类可以。在这种情况下，我使用“to”函数类似于可能的结构专门化“STo”的条目为转换添加构造函数可能更简单：

enum ColorSpace {
    BGR, RGB, LAB, HSV, XYZ, YUV, HSL, CMY, YIQ, LUV, HLAB, LCH, OHTA
};

template <ColorSpace, typename = double> class Color;

template <typename T>
class Color<RGB, T> {
public:

    Color(T R, T G, T B) : R(R), G(G), B(B) {}
    Color() : Color(0, 0, 0) {}
    Color(const Color&rhs) = default;
    ~Color() = default;

    T R, G, B;

    template <typename T2>
    /*explicit*/ Color(const Color<HSV, T2>& rhs) 
    {
        hsv2rgb(rhs.H, rhs.S, rhs.V, R, G, B);
    }
};
template <typename T>
class Color<HSV, T> {
public:
    Color(T H, T S, T V) : H(H), S(S), V(V) {}
    Color() : Color(0, 0, 0) {}
    Color(const Color&rhs) = default;
    ~Color() = default;

    T H, S, V;

    template <typename T2>
    /*explicit*/ Color(const Color<RGB, T2>& rhs) 
    {
        rgb2hsv(rhs.R, rhs.G, rhs.B, H, S, V);
    }

};

enum颜色空间{
BGR、RGB、实验室、HSV、XYZ、YUV、HSL、CMY、YIQ、LUV、HLAB、LCH、OHTA
};
模板类颜色；
模板
类颜色{
公众：
颜色（tr，tg，tb）：R（R），G（G），B（B）{
Color（）：Color（0,0,0）{}
颜色（常量颜色和rhs）=默认值；
~Color（）=默认值；
tr，G，B；
模板
/*显式*/颜色（常量颜色和rhs）
{
hsv2rgb（rhs.H、rhs.S、rhs.V、R、G、B）；
}
};
模板
类颜色{
公众：
颜色（th，ts，tv）：H（H），S（S），V（V）{
Color（）：Color（0,0,0）{}
颜色（常量颜色和rhs）=默认值；
~Color（）=默认值；
th，S，V；
模板
/*显式*/颜色（常量颜色和rhs）
{
rgb2hsv（rhs.R、rhs.G、rhs.B、H、S、V）；
}
};

可能的用法：

Color<RGB, double> c(255, 255, 125);

Color<HSV, double> c2{c};

c色（255、255、125）；
颜色c2{c}；

您的意思是：

模板颜色到（）

即使我删除它，我也会得到相同的错误。哦，我明白你的字面意思只是

。好的，在这种情况下，我会得到一个新的错误：

非法使用显式模板参数

是的。问题是，该函数不能部分专用化。我找到了解决方案。我将在这篇博文中给你答案，而不是部分专用化f实际上，我专门化了一个结构，然后在函数内部使用。很好的方法，谢谢。[OT]：

\u CS

和

\u Dtp

是保留名称（u）后跟大写字母）。

Color<RGB, double> c(255, 255, 125);

Color<HSV, double> c2{c};