P>int main(int argc, char* argv[])
P>{
P>    Temp t1;
P>    t1.f();//have output
P>    t1.f();//no effect
P>    t1.f();//no effect

P>    Temp t2;
P>    t2.f();//have output
P>    t2.f();//no effect
P>    t2.f();//no effect
    
P>    return 0;
P>}
P>

P>>int main(int argc, char* argv[])
P>>{
P>>    Temp t1;
P>>    t1.f();//have output
P>>    t1.f();//no effect
P>>    t1.f();//no effect

P>>    Temp t2;
P>>    t2.f();//have output
P>>    t2.f();//no effect
P>>    t2.f();//no effect
    
P>>    return 0;
P>>}
P>>

C>int main(int argc, char* argv[])
C>{
C>    {
C>        Temp t1;
C>        t1.f();//have output
C>        t1.f();//no effect
C>        t1.f();//no effect
C>    }

C>    {
C>        Temp t2;
C>        t2.f();//no effect!?!?! WTF???
C>    }
C>    return 0;
C>}
C>

I>void f()
I>{
I>    static char const s[] = "abcd";
I>    . . .
I>}
I>

I>void f()
I>{
I>    static char const s[] = "abcd";
I>    . . .
I>}
I>

P>// Freeze.cpp : Defines the entry point for the console application.
P>//
P>#include "stdafx.h"
P>#include <vector>
P>#include <algorithm>

P>#define FREEZABLE(ret) static std::vector<void*> __freezeHelper__;\
P>    std::vector<void*>::iterator result;\
P>    result = std::find(__freezeHelper__.begin(), __freezeHelper__.end(), this);\
P>    if (result == __freezeHelper__.end())\
P>        __freezeHelper__.push_back(this);\
P>    else return ret


P>

P>>// Freeze.cpp : Defines the entry point for the console application.
P>>//
P>>#include "stdafx.h"
P>>#include <vector>
P>>#include <algorithm>

P>>#define FREEZABLE(ret) static std::vector<void*> __freezeHelper__;\
P>>    std::vector<void*>::iterator result;\
P>>    result = std::find(__freezeHelper__.begin(), __freezeHelper__.end(), this);\
P>>    if (result == __freezeHelper__.end())\
P>>        __freezeHelper__.push_back(this);\
P>>    else return ret


P>>

E>void ups()
E>{
E>    Temp t;
E>    t.f();
E>}

E>int main(int argc, char* argv[])
E>{
E>    for( int i = 0; i < 10; i++ ) {
E>        ups();
E>    }
E>    return 0;
E>}
E>

E>>void ups()
E>>{
E>>    Temp t;
E>>    t.f();
E>>}

E>>int main(int argc, char* argv[])
E>>{
E>>    for( int i = 0; i < 10; i++ ) {
E>>        ups();
E>>    }
E>>    return 0;
E>>}
E>>

class FrozenInit {
E>public:
E>    bool Init()
E>    {
E>        if( isInited ) {
E>            return false;
E>        }
E>        //  Тут можно добвать поддержку многопоточности, если надо.
E>        isInited = true;
E>        DoFrozenInit();
E>        return true;
E>    }
E>protected:
E>    FrozenInit() : isInited( false ) {}
E>    FrozenInit( const FrozenInit& ) : isInited( false ) {} // или какая там у тебя семантика?
E>    void operator = ( const FrozenInit& ) {}

E>    virtual ~FrozenInit() {}

E>    virtual void DoFrozenInit() = 0;
E>private:
E>    bool isInited;
E>};

E>//  Пример использования:
E>class Test : public FrozenInit {
E>    void DoFrozenInit();
E>public:
E>    //  тут интерфейс класса... если надо, можешь явно упомянуть Init()
E>};
E>

static class SuperTemp : public Temp {
E>public:
E>    SuperTemp() { f(); }
E>    ~SuperTemp() { f(); }

E>} ups_ups;

E>>>void ups()
E>>>{
E>>>    Temp t;
E>>>    t.f();
E>>>}

E>>>int main(int argc, char* argv[])
E>>>{
E>>>    for( int i = 0; i < 10; i++ ) {
E>>>        ups();
E>>>    }
E>>>    return 0;
E>>>}
E>>>

class FrozenInit {
E>>public:
E>>    bool Init()
E>>    {
E>>        if( isInited ) {
E>>            return false;
E>>        }
E>>        //  Тут можно добвать поддержку многопоточности, если надо.
E>>        isInited = true;
E>>        DoFrozenInit();
E>>        return true;
E>>    }
E>>protected:
E>>    FrozenInit() : isInited( false ) {}
E>>    FrozenInit( const FrozenInit& ) : isInited( false ) {} // или какая там у тебя семантика?
E>>    void operator = ( const FrozenInit& ) {}

E>>    virtual ~FrozenInit() {}

E>>    virtual void DoFrozenInit() = 0;
E>>private:
E>>    bool isInited;
E>>};

E>>//  Пример использования:
E>>class Test : public FrozenInit {
E>>    void DoFrozenInit();
E>>public:
E>>    //  тут интерфейс класса... если надо, можешь явно упомянуть Init()
E>>};
E>>

P>class SomeClass {
P>public:
P>void someFunction() const, frozen, logable, busy {
P>//logable пишет что-то в лог о входе/выходе в функцию
P>//busy показывает "песочные часы"
P>}
P>};
P>

static class SuperTemp : public Temp {
E>>public:
E>>    SuperTemp() { f(); }
E>>    ~SuperTemp() { f(); }

E>>} ups_ups;

class FrozenInit {
E>>>public:
E>>>    bool Init()
E>>>    {
E>>>        if( isInited ) {
E>>>            return false;
E>>>        }
E>>>        //  Тут можно добвать поддержку многопоточности, если надо.
E>>>        isInited = true;
E>>>        DoFrozenInit();
E>>>        return true;
E>>>    }
E>>>protected:
E>>>    FrozenInit() : isInited( false ) {}
E>>>    FrozenInit( const FrozenInit& ) : isInited( false ) {} // или какая там у тебя семантика?
E>>>    void operator = ( const FrozenInit& ) {}

E>>>    virtual ~FrozenInit() {}

E>>>    virtual void DoFrozenInit() = 0;
E>>>private:
E>>>    bool isInited;
E>>>};

E>>>//  Пример использования:
E>>>class Test : public FrozenInit {
E>>>    void DoFrozenInit();
E>>>public:
E>>>    //  тут интерфейс класса... если надо, можешь явно упомянуть Init()
E>>>};
E>>>

P>>class SomeClass {
P>>public:
P>>void someFunction() const, frozen, logable, busy {
P>>//logable пишет что-то в лог о входе/выходе в функцию
P>>//busy показывает "песочные часы"
P>>}
P>>};
P>>

static class SuperTemp : public Temp {
E>>>public:
E>>>    SuperTemp() { f(); }
E>>>    ~SuperTemp() { f(); }

E>>>} ups_ups;

I>    static struct {
I>        char chr;
I>        char const* ref;
I>    } const char_ref[] = {
I>        { '<', "lt" },
I>        { '>', "gt" },
I>        { '&', "amp" },
I>        { '\'', "apos" },
I>        { '"', "quot" },
I>    };
I>