C / C++ / MFC

static_assert(pixel_type::template equals<gfx::rgb_pixel<16>>::value,
                          "this code needs to be ported for your display format");

// creates an RGB pixel by making each channel 
// one third of the whole. Any remainder bits
// are added to the green channel
template<size_t BitDepth>
using rgb_pixel = pixel<
    channel_traits<channel_name::R,(BitDepth/3)>,
    channel_traits<channel_name::G,((BitDepth/3)+(BitDepth%3))>,
    channel_traits<channel_name::B,(BitDepth/3)>
>;
// creates an RGBA pixel by making each channel 
// one quarter of the whole. Any remainder bits
// are added to the green channel
template<size_t BitDepth>
using rgba_pixel = pixel<
    channel_traits<channel_name::R,(BitDepth/4)>,
    channel_traits<channel_name::G,((BitDepth/4)+(BitDepth%4))>,
    channel_traits<channel_name::B,(BitDepth/4)>,
    channel_traits<channel_name::A,(BitDepth/4),0,(1<<(BitDepth/4))-1,(1<<(BitDepth/4))-1>
>;
// creates a grayscale or monochome pixel
template<size_t BitDepth>
using gsc_pixel = pixel<
    channel_traits<channel_name::L,BitDepth>
>;
// creates a Y'UV pixel by making each channel 
// one third of the whole. Any remainder bits
// are added to the Y' channel
template<size_t BitDepth>
using yuv_pixel = pixel<
    channel_traits<channel_name::Y,((BitDepth/3)+(BitDepth%3))>,
    channel_traits<channel_name::U,(BitDepth/3)>,
    channel_traits<channel_name::V,(BitDepth/3)>
>;

// defines a channel for a pixel
template<
    // the channel name, like channel_name::R
    typename Name,
    // the bit depth
    size_t BitDepth, 
    // the minimum value
    bits::uintx<bits::get_word_size(BitDepth)> Min=0, 
    // the maximum value
#if HTCW_MAX_WORD >= 64
    bits::uintx<bits::get_word_size(BitDepth)> Max= ((BitDepth==64)?0xFFFFFFFFFFFFFFFF:((1<<BitDepth)-1)), 
#else
    bits::uintx<bits::get_word_size(BitDepth)> Max= ((BitDepth==32)?0xFFFFFFFF:((1<<BitDepth)-1)), 
#endif
    // the default value
    bits::uintx<bits::get_word_size(BitDepth)> Default = Min,
    // the scale denominator
    bits::uintx<bits::get_word_size(BitDepth)> Scale = Max
>
struct channel_traits {
    // this type
    using type = channel_traits<Name,BitDepth,Min,Max,Scale>;
    // the type that represents the name
    using name_type = Name;
    // the integer type of this channel
    using int_type = bits::uintx<bits::get_word_size(BitDepth)>;
    // the floating point type of this channel
    using real_type = bits::realx<16<=BitDepth?HTCW_MAX_WORD:32>;
    // the bit depth of this channel
    constexpr static const size_t bit_depth = BitDepth;
    // the minimum value
    constexpr static const int_type min = Min;
    // the maximum value
    constexpr static const int_type max = Max;
    // the default value
    constexpr static const int_type default_ = Default;
    // the scale denominator
    constexpr static const int_type scale = Scale;
    // the reciprocal of the scale denominator
    constexpr static const real_type scaler = 1/(real_type)Scale; 
    // a mask of the int value
    constexpr static const int_type int_mask = ~int_type(0);
    // a mask of the channel value
    constexpr static const int_type mask = bits::mask<BitDepth>::right;
    // constraints
    static_assert(BitDepth>0,"Bit depth must be greater than 0");
    static_assert(BitDepth<=64,"Bit depth must be less than or equal to 64");
    static_assert(Min<=Max,"Min must be less than or equal to Max");
    static_assert(Default>=Min,"Default must be greater than or equal to the minimum value");
    static_assert(Default<=Max,"Default must be less than or equal to the maximum value");
#if HTCW_MAX_WORD >= 64        
    static_assert(Max<=((BitDepth==64)?0xFFFFFFFFFFFFFFFF:((1<<BitDepth)-1)),"Max is greater than the maximum allowable value");
#else
    static_assert(Max<=((BitDepth==32)?0xFFFFFFFF:((1<<BitDepth)-1)),"Max is greater than the maximum allowable value");
#endif
    static_assert(Scale>0,"Scale must not be zero");
};

class BT_UTILITY_LIBRARY_EXPORT BT_Utility_Library
{
public:
    // class variable
    // forward declaration ? works here !
    class Test;

    //May31
    QString DEBUG_Process(void);
    QString DEBUG_Process(int *);
    QString DEBUG_Process(class Test *);
    QString DEBUG_Process_Class(class Test *);

    QString REG_EXP_Process(void);

    class Test
    {
       public:
       int a;
       //int b[a];
       QString text;
    }TestPointer;

<   class REG_EXP                         //regular_expression_class
    {
        int a;
        QString text;
        QString RegExp;
        QString Analyze;
    } TEST_REG_EXP;
/pre>

Search for the symbol "REG_EXP" in the entire project returned no result. 
The conclusion 
it is unknown why the error was posted.
Please consider this matter closed.