> Very well. You asked me to shatter your confidence in the vc71
> compiler/runtime right? You'll now get what you asked for.
> I stripped down my sources and obfuscated them just for you.
> The bug you are about to observe it TRULY bizarre and freakish!

> Here is how to reproduce - extract 4 files: a.cpp, b.cpp, c.h and
> build.bat and run build.bat. It will produce crash.exe, run it.

> Bizarre thing #1 if you remove <winsock2.h> from a.cpp, rebuild, then
> crash goes away (please note winsock2.h is not even relevant to the
> needs of the program, I do use it though in my code for tcp/ip comm.).

> Bizarre thing #2 if you restore <winsock2.h> in a.cpp the way it was
> and remove member "double a; " from class hahaha in c.h then crash goes
> away too!

> Also it's important to stress that concurrency is NOT an issue with
> this multithreaded program because the main thread waits for the other
> thread to completely finish and disappear before returning (and running
> the destructors).
> And finally note that _endthreadex does NOT have to be run in the
> subordinate thread because the return statement takes care of that
> implicitly.

> Also, comments about the logic of the program are useless because I've
> stripped it and obfuscated it enough that suggestions about the logic
> are meaningless.

> My computer runs XP, latest service pack.

> ----------- build.bat begins ----------------------
> cl -I. -nologo -MDd -EHsc  -W3 -DWINVER=0x400  -c a.cpp -Foa.obj
> cl -I. -nologo -MDd -EHsc  -W3 -DWINVER=0x400  -c b.cpp -Fob.obj
> cl -MDd -EHsc -nologo -Zi -W3 -Fecrash.exe a.obj b.obj
> ----------- build.bat ends ------------------------

> ----------- a.cpp begins --------------------------
> #include <winsock2.h>
> #include <string>
> #include <map>
> #include <stdio.h>

> #include "c.h"
> extern map<string,dainty> *ptr;

> void funct1(void *arg)
> {
>     try {
>    (*ptr)["xxxx"] = dainty();
>     } catch (...) {
>    printf("funct1: unknown exception\n");
>     }

>     printf("exiting funct1\n");
> }
> ------------a.cpp ends  ---------------------------

> ------------b.cpp begins ---------------------
> #pragma warning(disable:4786)
> #include <io.h>
> #include <windows.h>
> #include <process.h>

> #include <stdio.h>

> #include "c.h"

> map<string,dainty> *ptr;
> extern void funct1(void *arg);

> static unsigned __stdcall wrapper_str(void *arg)
> {
>     funct1(0);
>     return 0;
> }

> int main()
> {
>     try {
>    map<string,dainty> mymap;
>    ptr = &mymap;

>    unsigned thrid;
>    HANDLE h = (HANDLE) _beginthreadex(0, 2*8192, wrapper_str, 0, 0,
> &thrid);
>    WaitForSingleObject(h, INFINITE);
>    CloseHandle(h);
>     } catch (std::string &msg) {
>    printf("exception in main: %s\n", msg.c_str());
>     } catch (...) {
>         printf("main: unknown exception caught\n");
>     }
>     return 0;
> }
> ------------b.cpp ends -----------------------

> ----------- c.h begins -----------------------
> #ifndef _c_h_
> #define _c_h_

> #include <string>
> #include <vector>
> #include <map>
> using namespace std;

> class myobject {
> private:
>     void *opaque;
>     volatile unsigned long *refcnt;

>     void delete_myobject() {
>    if(refcnt) {
>        (*refcnt)--;
>        if(*refcnt == 0) {
>            free(opaque);
>            free((void *) refcnt);
>        }
>    }
>     }

> public:
>     myobject() {
>    opaque = malloc(4);
>    if(!opaque) {
>    out: throw string("myobject constructor failed");
>    }

>    refcnt = (volatile unsigned long *) malloc(sizeof *refcnt);
>    if(refcnt == 0) {
>    delete_myobject();
>    goto out;
>    }

>    *refcnt = 0;
>    (*refcnt)++;
>     }

>     myobject(const myobject &arg) : opaque(arg.opaque),
> refcnt(arg.refcnt) {
>    (*refcnt)++;
>     }

>     ~myobject() { delete_myobject(); }

>     myobject &operator=(myobject const& arg) {
>    if(this == &arg)
>        goto out;

>    if(refcnt != arg.refcnt) {
>        delete_myobject();
>        opaque = arg.opaque;
>        refcnt = arg.refcnt;
>        (*refcnt)++;
>    }

>     out: return *this;
>     }
> };

> class hahaha {
> public:
>     double a;
>     unsigned long b;
>     unsigned char c;
>     unsigned char d;
> };

> class my_data {
> public:
>     myobject x_obj;
> };

> class dainty {
> public:
>     hahaha s_day;
>     vector<my_data> s_intra;
>     myobject s_obj;
> };

> #endif /* _c_h_ */
> ------------c.h ends--------------------------