0

我正在考虑在我的程序中使用颜色空间结构。现在您可以看到每个色彩空间对其每个组件都有其限制。所以考虑这样的结构。

template<typename T>
struct SomeColorSpace{
    T component1,component2,.....; // or std::array<T,N> components, N is compile-time const
};

现在我需要以某种方式定义一个范围，所以我创建了一个结构。

template<typename T>
struct Range{

    T min, max;

    // Some constructors initializing min and max...
};

现在我需要我的颜色空间结构来了解其每个组件的范围。但正如你所见，我不能只保留std::array<Ranges<T>,N> ranges我的结构，因为范围因类型而异。作为一个例子，考虑struct RGB每个组件可能是float左右unsigned char，当组件是float每个组件的范围[0,1];时，它是 unsigned char 它是[0,255];。为每种情况编写模板专业化是一种解决方案，但我想要这样的签名。using RGBFloat = RGB<float,Range<float>...>. 我的意思是我想通过模板参数包传递范围。我知道例如Range<float>(0,1);是一个非类型模板参数，所以一种解决方法是struct Range像这样重构

template<typename T,T _MIN, T _MAX>
struct Range{
    static constexpr T MIN = _MIN;
    static constexpr T MAX = _MAX;
};

所以我可以Range<T,T min, T max>作为模板参数包传递，但是我必须将包保存在一个std::tuple（我也不想要这个）。我的问题是您是否通过重构Range结构或其他方式看到任何其他可能性以具有定义颜色空间的这种签名。using DefineColorSpace = ColorSpace<unsigned char, ranges....>. 我知道这C++ 20对非类型模板参数有很大的重构，但我正在使用clang，似乎它们还不支持该功能。任何建议都会有所帮助，谢谢）

4

2 回答 2

0

对文字类作为非类型模板参数的支持已经在 clang 主干中。在godbolt上看到它：

template<typename T>
struct Range
{
    T min, max;
};

template<typename T, Range<T> R>
struct SomeColorSpace
{
    static constexpr Range<T> r = R;

    T component1, component2;
};

using Rgb = SomeColorSpace<float, Range<float>{0.0f, 1.0f}>;

auto test()
{
    Rgb color{0.4f, 0.1f};

    float c1 = color.component1;
    float min = Rgb::r.min;

    return Rgb::r.max;
}

所以它很快就会在铿锵声中到达。在此之前，一种可能的解决方法是使用特征。在godbolt上看到它：

template<class T, class Trait>
struct SomeColorSpace
{
    static constexpr T min = Trait::min;
    static constexpr T max = Trait::max;

    T component1, component2;
};

struct RgbTrait
{
    static constexpr float min = 0.0f;
    static constexpr float max = 1.0f;
};

using Rgb = SomeColorSpace<float, RgbTrait>;

auto test()
{
    Rgb color{0.4f, 0.1f};

    float c1 = color.component1;
    float min = Rgb::min;

    return Rgb::max;
}
于 2020-12-13T04:01:58.977 回答
0

不太清楚你想要什么，至于颜色，r/g/b/(a) 将根据类型具有相同的范围。

因此，一个简单的特征允许映射floatto[0.f,1.f]和std::uint8_tto的最小值/最大值[0,255]：

template <typename T> struct RangeTraits;

template <> struct RangeTraits<double>
{
    constexpr double min = 0.;
    constexpr double max = 1.;
};
template <> struct RangeTraits<std::uint8_t>
{
    constexpr std::uint8_t min = 0;
    constexpr std::uint8_t max = 255;
};
// ...

和

template <typename T>
struct SomeColorSpace{
    std::array<T, N> components;// N is compile-time constant

// use RangeTraits<T>::min, RangeTraits<T>::max when needed.
};

另一种解释是您的模板参数是初始化的“只是”默认值：

template <typename T, T DefaultMin, T DefaultMax>
struct Range{
    T min = DefaultMin;
    T max = DefaultMax;

    // Some constructors initializing min and max...
};

但这些默认值应该在之后忘记

因此，您可能可以执行以下操作：

std::array<Range<std::int8_t>, 2> components{Range<std::int8_t, 0, 127>, Range<std::int8_t, -10, 10>};

然后你可能会这样做：

template <typename T, T...> struct Range;

template <typename T>
struct Range<T>
{
    T min;
    T max;

    Range(T min, T max) : min(min), max(max) {}

    template <T Min, T Max,>
    Range(Range<T, Min, Max>& rhs) : min(rhs.min), max(rhs.max) {}

    Range(Range& rhs) = default;
    // ...
};

template <typename T, T Min, T Max>
struct Range<T, Min, Max>
{
    T min = Min;
    T max = Max;

    Range() = default;
    Range(Range& rhs) = default;

    // Possibly keep constructors of conversion and the one with runtime min/max
    // ...
};
于 2020-12-13T15:12:09.630 回答