Question

首次发布。是否可以将所有模板类型传递给操作员？ __Depth对象分配运算符都已被重载，并且打算使色彩通道运算符过载，而不必编写每个单独的色彩深度和通道组合。谢谢你。

struct Depth8
    {
        unsigned char Depth;

        void operator =(const Depth16& _Depth)
        {
            Depth = 255 * _Depth.Depth / 65535;
        }
    };
    struct Depth16
    {
        unsigned short Depth;

        void operator =(const Depth8& _Depth)
        {
            Depth = 65535 * _Depth.Depth / 255;
        }
    };


template<class __Depth>struct ColorRGB
    {
        __Depth R;
        __Depth G;
        __Depth B;

        void    operator =(ColorBGR& _Color) // << Want to do this instead of..
        {
            R = _Color.R;
            G = _Color.G;
            B = _Color.B;
        }

void    operator =(ColorBGR<__Depth>& _Color) // << this..
            {
                R = _Color.R;
                G = _Color.G;
                B = _Color.B;
            }

void    operator =(ColorBGR<Depth16>& _Color) // << or this..
            {
                R = _Color.R;
                G = _Color.G;
                B = _Color.B;
            }
    };
        };

Answer 1

您可以使用模板作为成员，以避免重复：

template<class Depth>
struct ColorRGB
{
    Depth R;
    Depth G;
    Depth B;

    ColorRGB(const Depth& r, const Depth& b, const Depth& g) : R(r), G(g), B(b) {}

    // Allow conversion between different depths.
    template <class Depth2>
    ColorRGB(const ColorRGB<Depth2>& rhs) :
        R(rhs.R),
        G(rhs.G),
        B(rhs.B)
    {
    }


    template <class Depth2>
    ColorRGB& operator =(const ColorRGB<Depth2>& rhs)
    {
        R = rhs.R;
        G = rhs.G;
        B = rhs.B;
        return *this;
    }



    ColorRGB(const ColorRGB& rhs) = default;
    ColorRGB& operator =(const ColorRGB& rhs) = default;
};

模板版本不处理副本构造函数，但幸运的是，默认设置为OK。

C ++将所有模板类型传递给运算符，而不指定所有类型

1 个答案: