C++ fun: obfuscated "Hello world!"

Are you sure that you dont (quietly) assume an ASCII character set?

Well, you got me here... :cool:

For another non-portable one:

Code:

---

#include <stdio.h>

void print_double(double d)
{
  unsigned char *p = (unsigned char *) &d;
  int last = 0, mode = 0, n;

  for (int i = 0; i < 8; ++i) {
    for (int j = 0; j < 8; ++j) {
      if (*p & (1 << j)) {
        switch (mode) {
        case 0:
          mode = 2;
          n = 0;
          last = 0;
          break;
        case 1:
        case 2:
          if (n < 4) {
            last = (last << 1) + 1;
            ++n;
          } else {
            printf("%c", (last << 1) + ((mode & 2) << 4) + 'B');
            mode = 0;
          }
          break;
        case 3:
          mode = 1;
          n = 0;
          last = 0;
          break;
        }
      } else {
        switch (mode) {
        case 0:
          mode = 3;
          break;
        case 1:
        case 2:
          if (n < 4) {
            last = (last << 1);
            ++n;
          } else {
            printf("%c", (last << 1) + ((mode & 2) << 4) + 'A');
            mode = 0;
          }
          break;
        case 3:
          printf(" ");
          mode = 0;
          break;
        }
      }
    }
    ++p;
  }
}

int main()
{
  double d = -5.1642444895816811e+035;
  print_double(d);
  return 0;
}

---

This may not work on Mac, Sun et al.

Not very obfuscated but portable:

Code:

---

#include <process.h>
#include <iostream.h>

class CState
{
public:
        CState();
        ~CState();

        virtual CState* Transit() = 0;
        virtual void PrintStatus() = 0;
        void PrintError(char* message);
};

class CState0 : public CState
{
public:
        CState0();
        ~CState0();
       
        virtual CState* Transit();
        virtual void PrintStatus();
};

class CState1 : public CState
{
public:
        CState1();
        ~CState1();
       
        virtual CState* Transit();
        virtual void PrintStatus();       
};

class CState2 : public CState
{
public:
        CState2();
        ~CState2();
       
        virtual CState* Transit();       
        virtual void PrintStatus();
};

class CState3 : public CState
{
        static int nCounter;
public:
        CState3();
        ~CState3();
       
        virtual CState* Transit();
        virtual void PrintStatus();       
};

class CState4 : public CState
{
        static int nCounter;
public:
        CState4();
        ~CState4();
       
        virtual CState* Transit();
        virtual void PrintStatus();
};

class CState5 : public CState
{
public:
        CState5();
        ~CState5();
       
        virtual CState* Transit();
        virtual void PrintStatus();
};

class CState6 : public CState
{
public:
        CState6();
        ~CState6();
       
        virtual CState* Transit();
        virtual void PrintStatus();
};

class CState7 : public CState
{
public:
        CState7();
        ~CState7();
       
        virtual CState* Transit();
        virtual void PrintStatus();
};

class CState8 : public CState
{
public:
        CState8();
        ~CState8();
       
        virtual CState* Transit();
        virtual void PrintStatus();
};


CState::CState()
{
}

CState::~CState()
{
}

void CState::PrintError(char* message)
{
        cout << message << endl;
        exit(0);
}

CState0::CState0()
{
}

CState0::~CState0()
{
}

CState* CState0::Transit()
{
        return new CState1;
}

void CState0::PrintStatus()
{
}

CState1::CState1()
{
}

CState1::~CState1()
{
}

CState* CState1::Transit()
{
        return new CState2;
}

void CState1::PrintStatus()
{
        cout << 'H';
}

CState2::CState2()
{
}

CState2::~CState2()
{
}

CState* CState2::Transit()
{
        return new CState3;
}

void CState2::PrintStatus()
{
        cout << 'e';
}

CState3::CState3()
{
}

CState3::~CState3()
{
}

CState* CState3::Transit()
{
        switch(nCounter++)
        {
        case 0: return new CState3;
        case 1: return new CState4;
        case 2: return new CState7;
        default: PrintError("Counter out of range");
        }

        return NULL;
}

void CState3::PrintStatus()
{
        cout << 'l';
}

CState4::CState4()
{
}

CState4::~CState4()
{
}

CState* CState4::Transit()
{
        switch(nCounter++)
        {
        case 0: return new CState8;
        case 1: return new CState6;
        default: PrintError("Counter out of range");
        }

        return NULL;
}

void CState4::PrintStatus()
{
        cout << 'o';
}

CState5::CState5()
{
}

CState5::~CState5()
{
}

CState* CState5::Transit()
{
        return new CState4;
}

void CState5::PrintStatus()
{
        cout << 'W';
}

CState6::CState6()
{
}

CState6::~CState6()
{
}

CState* CState6::Transit()
{
        return new CState3;
}

void CState6::PrintStatus()
{
        cout << 'r';
}

CState7::CState7()
{
}

CState7::~CState7()
{
}

CState* CState7::Transit()
{
        return NULL;
}

void CState7::PrintStatus()
{
        cout << 'd';
}

CState8::CState8()
{
}

CState8::~CState8()
{
}

CState* CState8::Transit()
{
        return new CState5;
}

void CState8::PrintStatus()
{
        cout << ' ';
}

int CState3::nCounter = 0;
int CState4::nCounter = 0;

int main(int argc, char* argv[])
{
        CState *state = new CState0;

        while(state != NULL)
        {
                CState *temp = state->Transit();
                delete state;
                state = temp;

                if(state != NULL)
                        state->PrintStatus();
        }

        return 0;
}

---