类功能的模板变量返回类型

Question

我试图创建一个类来解释各种位图类型（例如24位rgb或16位单色..不管）。我对模板不太了解，所以也许有人会告诉我为什么这会给我一堆错误？

enum PixelOptions { 
     I8, I16, I32, I64, F32, F64 
    }; 

    template <PixelOptions T> 
    class BitmapInterpreter { 
     uint32_t Width; 
     uint32_t Height; 
     void* Data; 

    public: 
     BitmapInterpreter(uint32_t Width, uint32_t Height, void* Data) { 
      this->Width = Width; 
      this->Height = Height; 
      this->Data = Data; 
     } 


     uint8_t* Pixel<I8>(const uint32_t &X, const uint32_t &Y) { 
      return nullptr; 
     } 
     uint16_t* Pixel<I16>(const uint32_t &X, const uint32_t &Y) { 
      return nullptr; 
     } 
     uint32_t* Pixel<I32>(const uint32_t &X, const uint32_t &Y) { 
      return nullptr; 
     } 
    }; 

该函数只是占位符。基本上我希望它根据声明的方式返回一个从x和y计算出来的变量类型指针。我认为添加<模板选项>功能会做到这一点，但编译器只是在定义第一个Pixel函数之后说“缺少;在<之前”。

编辑：PS！模板参数必须要有些东西我可以在一个变量存储数据，如枚举（我为什么不直接使用的模板类型）

Answer 1

使返回类型取决于非类型模板参数Pixel T。一个例子是创建一个辅助类用于此目的：

template <PixelOptions T> 
struct RetType; 

template <> 
struct RetType<I8> 
{ 
using type = uint8_t; 
}; 

///More specializations go here. 

，改变你原来的方法：

typename RetType<T>::type* Pixel(const uint32_t &X, const uint32_t &Y) { 
      return nullptr; 
     } 

Answer 2

您可以专注的方法是这样的：

template <PixelOptions T> struct PixelType; 

template <> struct PixelType<I8> { 
    using type = uint8_t; 
}; 

template <> struct PixelType<I16> { 
    using type = uint8_t; 
}; 

template <> struct PixelType<I32> { 
    using type = uint16_t; 
}; 

template <PixelOptions T> class BitmapInterpreter 
{ 
    uint32_t Width; 
    uint32_t Height; 
    void* Data; 

public: 
    BitmapInterpreter(uint32_t Width, uint32_t Height, void* Data) 
    { 
     this->Width = Width; 
     this->Height = Height; 
     this->Data = Data; 
    } 

    typename PixelType<T>::type* Pixel(const uint32_t& X, const uint32_t& Y); 
}; 
template <> typename PixelType<I8>::type* BitmapInterpreter<I8>::Pixel(const uint32_t& X, const uint32_t& Y) 
{ 
    return nullptr; 
} 
template <> typename PixelType<I16>::type* BitmapInterpreter<I16>::Pixel(const uint32_t& X, const uint32_t& Y) 
{ 
    return nullptr; 
} 
template <> typename PixelType<I32>::type* BitmapInterpreter<I32>::Pixel(const uint32_t& X, const uint32_t& Y) 
{ 
    return nullptr; 
} 

Answer 3

你模板方法Pixel<>而不声明它们是模板。我猜你想要做的是一样的东西：

enum PixelOptions { 
    I8, I16, I32, I64, F32, F64 
}; 

// No need for template here, nothing else than one method is templated 
class BitmapInterpreter { 
    uint32_t Width; 
    uint32_t Height; 
    void* Data; 

public: 
    BitmapInterpreter(uint32_t Width, uint32_t Height, void* Data) { 
     this->Width = Width; 
     this->Height = Height; 
     this->Data = Data; 
    } 


    // Declaring there is such a method 
    template <PixelOptions T> 
    uint8_t* Pixel(const uint32_t &X, const uint32_t &Y); 
}; 

// Defining specific versions of the method 
template <> 
uint8_t* BitmapInterpreter::Pixel<I8>(const uint32_t &X, const uint32_t &Y) { 
    return nullptr; 
} 
template <> 
uint16_t* BitmapInterpreter::Pixel<I16>(const uint32_t &X, const uint32_t &Y) { 
    return nullptr; 
} 
template <> 
uint32_t* BitmapInterpreter::Pixel<I32>(const uint32_t &X, const uint32_t &Y) { 
    return nullptr; 
} 

注意，这仍然不能产生有效的代码，因为返回类型在每种情况下的不同。你也需要模板化。