C / C++ / MFC

void MyCreate()
{
    //in here code looks for Window with title "MyWndWin".

	p->new CMyCwndSub;
	CString m = AfxRegisterWndClass(0);       //crashes in this line the 2nd time called.
	p->CreateEx(0, m, -T"MyWndWin",0,0,0,0,0,NULL,0);
	
	.
	.
	.
}

void MyUnCreate()
{
delete p;
p = NULL;
}

#include <stdio.h>

class foo {
    int m_bar;
public:
    foo(/*foo* this*/) : /*this->*/m_bar(0) {

    }
    int bar(/*foo* this*/) const { return this->m_bar; }
    void bar(/*foo* this, */ int value) { this->m_bar = value; }
};

typedef struct _foo_c {
    int bar;
} foo_c_t;

void foo_foo_foo_c_t(foo_c_t* handle) {
    // : m_bar(0)
    handle->bar = 0;
}
int foo_bar_foo_c_t(foo_c_t* handle) {
    // return this->bar;
    return handle->bar;
}
void foo_bar_foo_c_t_int(foo_c_t* handle, int value) {
    // this->bar = value;
    handle->bar = value;
}

int main(int argc, char** argv) {
    foo foo_cpp;
    foo_cpp.bar(42);

    foo_c_t foo_c;
    foo_foo_foo_c_t(&foo_c);
    foo_bar_foo_c_t_int(&foo_c,42);

    printf("foo_cpp: %d, foo_c: %d\n",foo_cpp.bar(),foo_bar_foo_c_t(&foo_c));

    return 0;
}

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;