Error C2338: The C++ Standard doesn't provide a hash for this type

#include <iostream>
#include <conio.h>
#include <stdint.h>
#include <assert.h>
#include <vector>
#include <fstream>
 
#include "main.h"
 
void RGB2HSV(unsigned int&, unsigned char&, unsigned char&, unsigned char, unsigned char, unsigned char);
 
int main(int argc, char *argv[])
{
    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " file_name" << std::endl;
        return 0;
    }
    char *fileName = argv[1];
    char *wFile = "bbff.txt";
 
    // открываем файл
    std::ifstream fileStream(fileName, std::ifstream::binary);
    if (!fileStream) {
        std::cout << "Error opening file '" << fileName << "'." << std::endl;
        return 0;
    }
 
    // открываем файл 
    std::ofstream fcout(wFile);
    if (!fcout) {
        std::cout << "Error opening file '" << wFile << "'." << std::endl;
        return 0;
    }
 
    // заголовк изображения
    BITMAPFILEHEADER fileHeader;
 
    read(fileStream, fileHeader.bfType, sizeof(fileHeader.bfType));
    read(fileStream, fileHeader.bfSize, sizeof(fileHeader.bfSize));
    read(fileStream, fileHeader.bfReserved1, sizeof(fileHeader.bfReserved1));
    read(fileStream, fileHeader.bfReserved2, sizeof(fileHeader.bfReserved2));
    read(fileStream, fileHeader.bfOffBits, sizeof(fileHeader.bfOffBits));
 
    if (fileHeader.bfType != 0x4D42) {
        std::cout << "Error: '" << fileName << "' is not BMP file." << std::endl;
        return 0;
    }
 
    // информация изображения
    BITMAPINFOHEADER fileInfoHeader;
    read(fileStream, fileInfoHeader.biSize, sizeof(fileInfoHeader.biSize));
 
    // bmp core
    if (fileInfoHeader.biSize >= 12) {
        read(fileStream, fileInfoHeader.biWidth, sizeof(fileInfoHeader.biWidth));
        read(fileStream, fileInfoHeader.biHeight, sizeof(fileInfoHeader.biHeight));
        read(fileStream, fileInfoHeader.biPlanes, sizeof(fileInfoHeader.biPlanes));
        read(fileStream, fileInfoHeader.biBitCount, sizeof(fileInfoHeader.biBitCount));
    }
 
    // получаем информацию о битности
    int colorsCount = fileInfoHeader.biBitCount >> 3;
 
    if (colorsCount < 3) {
        colorsCount = 3;
    }
    int bitsOnColor = fileInfoHeader.biBitCount / colorsCount;
    int maskValue = (1 << bitsOnColor) - 1;
    
    // bmp v1
    if (fileInfoHeader.biSize >= 40) {
        read(fileStream, fileInfoHeader.biCompression, sizeof(fileInfoHeader.biCompression));
        read(fileStream, fileInfoHeader.biSizeImage, sizeof(fileInfoHeader.biSizeImage));
        read(fileStream, fileInfoHeader.biXPelsPerMeter, sizeof(fileInfoHeader.biXPelsPerMeter));
        read(fileStream, fileInfoHeader.biYPelsPerMeter, sizeof(fileInfoHeader.biYPelsPerMeter));
        read(fileStream, fileInfoHeader.biClrUsed, sizeof(fileInfoHeader.biClrUsed));
        read(fileStream, fileInfoHeader.biClrImportant, sizeof(fileInfoHeader.biClrImportant));
    }
 
    // bmp v2
    fileInfoHeader.biRedMask = 0;
    fileInfoHeader.biGreenMask = 0;
    fileInfoHeader.biBlueMask = 0;
 
    if (fileInfoHeader.biSize >= 52) {
        read(fileStream, fileInfoHeader.biRedMask, sizeof(fileInfoHeader.biRedMask));
        read(fileStream, fileInfoHeader.biGreenMask, sizeof(fileInfoHeader.biGreenMask));
        read(fileStream, fileInfoHeader.biBlueMask, sizeof(fileInfoHeader.biBlueMask));
    }
 
    // если маска не задана, то ставим маску по умолчанию
    if (fileInfoHeader.biRedMask == 0 || fileInfoHeader.biGreenMask == 0 || fileInfoHeader.biBlueMask == 0) {
        fileInfoHeader.biRedMask = maskValue << (bitsOnColor * 2);
        fileInfoHeader.biGreenMask = maskValue << bitsOnColor;
        fileInfoHeader.biBlueMask = maskValue;
    }
 
    // bmp v3
    if (fileInfoHeader.biSize >= 56) {
        read(fileStream, fileInfoHeader.biAlphaMask, sizeof(fileInfoHeader.biAlphaMask));
    }
    else {
        fileInfoHeader.biAlphaMask = maskValue << (bitsOnColor * 3);
    }
 
    // bmp v4
    if (fileInfoHeader.biSize >= 108) {
        read(fileStream, fileInfoHeader.biCSType, sizeof(fileInfoHeader.biCSType));
        read(fileStream, fileInfoHeader.biEndpoints, sizeof(fileInfoHeader.biEndpoints));
        read(fileStream, fileInfoHeader.biGammaRed, sizeof(fileInfoHeader.biGammaRed));
        read(fileStream, fileInfoHeader.biGammaGreen, sizeof(fileInfoHeader.biGammaGreen));
        read(fileStream, fileInfoHeader.biGammaBlue, sizeof(fileInfoHeader.biGammaBlue));
    }
 
    // bmp v5
    if (fileInfoHeader.biSize >= 124) {
        read(fileStream, fileInfoHeader.biIntent, sizeof(fileInfoHeader.biIntent));
        read(fileStream, fileInfoHeader.biProfileData, sizeof(fileInfoHeader.biProfileData));
        read(fileStream, fileInfoHeader.biProfileSize, sizeof(fileInfoHeader.biProfileSize));
        read(fileStream, fileInfoHeader.biReserved, sizeof(fileInfoHeader.biReserved));
    }
 
    // проверка на поддерку этой версии формата
    if (fileInfoHeader.biSize != 12 && fileInfoHeader.biSize != 40 && fileInfoHeader.biSize != 52 &&
        fileInfoHeader.biSize != 56 && fileInfoHeader.biSize != 108 && fileInfoHeader.biSize != 124) {
        std::cout << "Error: Unsupported BMP format." << std::endl;
        return 0;
    }
 
    if (fileInfoHeader.biBitCount != 16 && fileInfoHeader.biBitCount != 24 && fileInfoHeader.biBitCount != 32) {
        std::cout << "Error: Unsupported BMP bit count." << std::endl;
        return 0;
    }
 
    if (fileInfoHeader.biCompression != 0 && fileInfoHeader.biCompression != 3) {
        std::cout << "Error: Unsupported BMP compression." << std::endl;
        return 0;
    }
 
    size_t bytes = (fileInfoHeader.biBitCount / 8);
    size_t linePadding = ((fileInfoHeader.biWidth * bytes) % 4) & 3;
 
    fcout << " R"
        << "  G"
        << "  B        "
        << "  H"
        << "  S"
        << "  V" << '\n';
 
    assert(bytes <= sizeof(uint32_t));
    std::vector<char> line(fileInfoHeader.biWidth * bytes + linePadding);
    for (size_t i = 0; i < fileInfoHeader.biHeight; ++i)
    {
        if (fileStream.read(&line[0], line.size()))
        {
            for (size_t j = 0; j < (fileInfoHeader.biWidth * bytes); j += bytes)
            {
                uint32_t num = 0;
                std::memcpy(&num, &line[j], bytes);
 
                uint8_t r = bitextract(num, fileInfoHeader.biRedMask);
                uint8_t g = bitextract(num, fileInfoHeader.biGreenMask);
                uint8_t b = bitextract(num, fileInfoHeader.biBlueMask);
                uint8_t a = bitextract(num, fileInfoHeader.biAlphaMask);
 
                uint8_t  sat, val;
                uint32_t hue;
                RGB2HSV(hue, sat, val, r, g, b);
 
                fcout << std::hex
                    << +r << " "
                    << +g << " "
                    << +b << "        "
                    << std::dec
                    << +hue << " "
                    << +sat << " "
                    << +val << "        "
                    << '\n';
            }
        }
    }
    _getch();
    return 0;
}
 
unsigned char bitextract(const unsigned int byte, const unsigned int mask) {
    if (mask == 0) {
        return 0;
    }
 
    // определение количества нулевых бит справа от маски
    int
        maskBufer = mask,
        maskPadding = 0;
 
    while (!(maskBufer & 1)) {
        maskBufer >>= 1;
        maskPadding++;
    }
    // применение маски и смещение
    return (byte & mask) >> maskPadding;
}
 
// для перевода цвета из RGB в HSV воспользуйтесь следующим кодом
void RGB2HSV(unsigned int &hue, unsigned char &sat, unsigned char &val, unsigned char r, unsigned char g, unsigned char b) {
    double h, rc, gc, bc, dmax;
    unsigned char s, v;
    unsigned char minc, maxc;
    
    maxc = (r > g) ? ((r > b) ? r : b) : ((g > b) ? g : b);
    minc = (r < g) ? ((r < b) ? r : b) : ((g < b) ? g : b);
    s = 0; // Насыщенность
 
    if (maxc) {
        s = (maxc - minc) * 255 / maxc;
    }
    sat = 100 * s / 255;
    val = 100 * maxc / 255;
 
    if (!s) { // Ахроматический цвет
        hue = 0;
    }
    else { // Хроматический цвет
        dmax = maxc - minc;
        rc = (maxc - r) / dmax; /* rc - удаленность */
        gc = (maxc - g) / dmax; /* цвета от красного */
        bc = (maxc - b) / dmax;
 
        if (r == maxc) { // Цвет между желтым и пурпурным
            h = bc - gc;
        }
        else if (g == maxc) { // Цвет между голубым и желтым
            h = 2 + rc - bc;
        }
        else { // Цвет между пурпурным и голубым
            h = 4 + gc - rc;
        }
        h *= 60.0;
        if (h < 0.0) {
            h += 360.0;
        }
        hue = h;
        if (hue == 360) {
            hue = 0;
        }
    } // if (!s)
} // RGB 2 HSV