Erstes C++ Programm

Welt-bekanntes,allerdings notgedrungen modifiziertes Beispiel für das 1. C++ Programm.

#include <iostream>

int main() {

    std::cout << "Goodbye World" << std::endl; // Da sowieso die Welt untergeht, erlaubt man sich den uberflüssen flush!

    return 666;

}

Da sowieso die Welt untergeht, dürfen die Mods auch nutzlose Threads stehen lassen! :xmas1:

CocoEi

yeah!

Die Welt message

ja dann wünsch euch ein schönes untergehen

gruß
coco

ScottZhang

Wenn die Welt schon untergeht dann aber auch richtig:

#include <stdio.h>

using namespace std;

void main()
{
  printf ("Goodbye World\n");
}

Wenns schon denn schon:

#include <stdio.h>

int main()
{
char hello_world[12];
hello_world[0] = 'h';
hello_world[1] = 'e';
hello_world[2] = 'l';
hello_world[3] = 'l';
hello_world[4] = 'o';
hello_world[5] = ' ';
hello_world[6] = 'w';
hello_world[7] = 'o';
hello_world[8] = 'r';
hello_world[9] = 'l';
hello_world[10] = 'd';
hello_world[11] = '\0';

int i;
for(i=0;i<=11;i = i + 1)
printf(%c,hello_world[i]);
return0;

}

_matze

Ach, jetzt ist sowieso alles egal:

#include <string.h>
#include <iostream>

char *GetGBWorldString() { //inspired by my hero JW
  char str[]="Goodbye World!\n";
  return str;
}

void main() {
  int *pointless=new int[1000];
  std::cout << GetGBWorldWtring() << std::endl;
  system("pause");
}

DrakoXP

#include <iostream>

int main()
{
    unsigned long long message[] = {
        0x20657962646F6F47,
        0x000021646C726f77
    };
    std::cout << reinterpret_cast<char*>(message) << std::endl;
    return 0;
}

Marthog

#include <iostream>

int main()
{
	const float float_array[4] = { 1.766716085e+022f, 1.94372167e-019f, 1.172343344e+027f, 9.303332609e-040f };
	std::cout<<reinterpret_cast<const char*>(float_array);
}

Sone

template<int ...i> 
void foo() 
{ 
        foo<i..., i..., i..., i..., i...>();
} 

int main() 
{ 
    foo<0x648f>(); 
}

int main(){char _[9]={2,30,41,40,0,-11,-2,23,-20};while(_[0]<9)std::cout<<(_[_[0]]+=_[_[0]++-1]);}

Bassmaster

Wenn es crasht ist Ende. :xmas2:

#include <iostream>

typedef int HELL;
typedef int METEOR;

int main()
{
int(*ByeBye)(const char* );
ByeBye = ( int(*)(const char*) ) std::printf;

HELL* MEMORY_OF_DOOM;
METEOR METEORSHOWER=1;

  while(1)
  {
      ByeBye("\x47\x4f\x4f\x44\x42\x59\x45\x20\x57\x4f\x52\x4c\x44\x20\x21\n");
      MEMORY_OF_DOOM = new HELL [ METEORSHOWER ];
      METEORSHOWER++;
  }
}

0x0ERROR

Sie geht schon unter:

#include <iostream>
using namespace std;
int main {
cout << "Siehe hier: http://hisz.rsoe.hu/alertmap/index2.php << endl;
cout << "Und hier: http://21dezember2012.org" << endl;
return "Weltuntergang 2012";
}

0x0Weltuntergang :xmas1:

SeppJ

Das macht mir alles noch nicht genug Stimmung! Außerdem kann ich immer noch die ASCII-Zeichen sehen, auch wenn sie in HEX-stehen. Das ist doch keine Obfuscation. So geht das:

#include<cstdio>

              //
             /**/
           template
        <int I,int I_>
       struct _{enum{_I=
     (I==1+1)||(I%I_)&&_<(
    I_>1/2+2?I:1/2),I_-1>::
  _I};};template<>struct _<1-
          1,1/3>{enum
        {_I=0+1};};int 
      I=1*0;void i(int I
    ){if(I>=1){if(::I<27){
  putchar(::I["*F@lkA^!Zp?Z~\
\023|HX^`$X(N+\011#\360"]+::I)
        ;}::I+=1+1;i
      (I-1);}}template<>
     struct _<-5/6,1>{enum 
   {_I=1+1-1};};template<int 
i>struct __{__<i-1> I;enum{_I=_
      <i,i-1>::_I};void
    _(){I._();if(_I){++::I
  ;::i(i);::I-=0+1+1-0*1;}}}
;template<>struct __<1>{enum {_I
          =0};void
          _(){};};
          int main
          (){__<7>
          _;_._();
}

:xmas1:

:xmas2: Viel Spaß beim Knobeln! :xmas2:

P.S.: Der Code ist teilweise Whitespacesensitiv! Zum Ausprobieren nicht die Formatierung ändern sondern genau so übernehmen!

SeppJ schrieb:

Das macht mir alles noch nicht genug Stimmung! Außerdem kann ich immer noch die ASCII-Zeichen sehen, auch wenn sie in HEX-stehen. Das ist doch keine Obfuscation. So geht das:

#include<cstdio>

              //
             /**/
           template
        <int I,int I_>
       struct _{enum{_I=
     (I==1+1)||(I%I_)&&_<(
    I_>1/2+2?I:1/2),I_-1>::
  _I};};template<>struct _<1-
          1,1/3>{enum
        {_I=0+1};};int 
      I=1*0;void i(int I
    ){if(I>=1){if(::I<27){
  putchar(::I["*F@lkA^!Zp?Z~\
\023|HX^`$X(N+\011#\360"]+::I)
        ;}::I+=1+1;i
      (I-1);}}template<>
     struct _<-5/6,1>{enum 
   {_I=1+1-1};};template<int 
i>struct __{__<i-1> I;enum{_I=_
      <i,i-1>::_I};void
    _(){I._();if(_I){++::I
  ;::i(i);::I-=0+1+1-0*1;}}}
;template<>struct __<1>{enum {_I
          =0};void
          _(){};};
          int main
          (){__<7>
          _;_._();
}

:xmas1:

:xmas2: Viel Spaß beim Knobeln! :xmas2:

Nett, aber bei jkghj stehen gar keine ASCII Zeichen?

SeppJ

BigBangEnd schrieb:

Nett, aber bei jkghj stehen gar keine ASCII Zeichen?

Oh, den hatte ich noch gar nicht gesehen. Ich bezog mich auf DrakoXP und Marthog, die mich zu meiner Lösung inspirierten (die übrigens intern ähnliche Ideen wie jkghj benutzt, bloß nochmal eine Stufe komplizierter).

P.S.: jkghj's Lösung funktioniert bei mir nicht . Weder mit unsigned-char noch signed-char.

Zumindest unter VC 2010 klappt das bei mir. Woran mag das wohl liegen?

Wird da evtl. UB hervorgerufen?

int main()
{
	char arr[9] = {2, 30, 41, 40, 0, -11, -2, 23, -20};

	while (arr[0] < 9)
		std::cout<< (arr[arr[0]] += arr[arr[0]++ - 1]);
}

Da das ganze ja eh unter dem Motto Weltuntergang steht, ist das ja egal, aber mich würde es wirklich interessieren, was da schief läuft.

Ich hab es nun nochmal etwas verändert:

int main()
{
    char arr[9] = {2, 30, 41, 40, 0, -11, -2, 23, -20};

    for (;arr[0] < 9; ++arr[0])
        arr[arr[0]] += arr[arr[0] - 1];

	std::cout.write(arr + 2, 7);
}

Sollte es bei dir so gehen, dann war das ++arr[0] wohl schuld?

Sone

So, für SeppJs bisher:

#include <cstdio>
#include <iostream>

template<int I, int I_>
struct _
{
    enum
    { _I =    (I == 1)
           ||   ((I % I_)
             && _ <( I_> 2? I : 0 ), I_ - 1>::_I) };
};

template<> struct _<0, 0> { enum { _I = 1}; };
template<> struct _<0, 1> { enum { _I = 1}; };

int I = 0;
void i(int I)
{
    if(I >= 1)
    {
        if(::I < 27)
        {
          putchar(::I[" Goodbye World!"]);
        }
        ::I += 1;
        i(I-1);
    }
}

template<int i>
struct __
{
    __<i-1> I;
    enum
    { _I = _<i, i-1>::_I };

    void _()
    {
        I._();
        if(_I)
        {
            ++::I;
            ::i(i);
            ::I -= 1;
        }
    }
};

template<>
struct __<1>
{
    enum { _I = 0 };

    void _(){}
};

int main()
{
    __<7>()._();
}

Sone

Die String Verschlüsselung und der Trick mit den Integerdivisionen war lahm, da hättest du dir mehr Mühe geben sollen :xmas1:

SeppJ

BigBangEnd schrieb:

Sollte es bei dir so gehen, dann war das ++arr[0] wohl schuld?

Ja so geht es. ABer das liegt nicht an meinem Computer, das war eben schlichtweg ein Konstrukt der Form i = i++ , das ist eben einfach undefiniert. Das iwrd vermutlich sogar bei dir selber schon nicht mehr funktionieren, wenn du irgendetwas an den Compilereinstellungen änderst, z.B. Optimierung einschaltest.

Ich war zuerst verwirrt, da der Code nämlich auch (sogar immer noch) die Warnung "array subscript has type ‘char’" wirft. Diese Warnung gibt es nämlich wegen möglichen Problemen der signedness. Aber der Code funktioniert nun trotzdem, egal ob mit signed oder unsigned char.

SeppJ

Sone schrieb:

Die String Verschlüsselung und der Trick mit den Integerdivisionen war lahm, da hättest du dir mehr Mühe geben sollen :xmas1:

Woot? Ich glaube dir nicht, dass du die Stringverschlüsselung geknackt hast. Du hast geraten. Erklär mal das Verfahren.

P.S.: Ja, die Integerdivision war lahm. Ich musste Zeichen schinden, damit der Weihnachtsbaum gut aussieht :xmas1: . Aber die Stringverschlüsselung ist nicht einfach eine komplizierte Darstellung von "Goodbye World", die ist viel cleverer. Das sieht man daran, dass dein "deobfuscated" Programm zwar die Entschlüsselungsalgorithmen noch enthält, aber nicht benutzt.

Sone

Ich habe wirklich geraten, aber es ging schnell :xmas1:

Aber um dich nicht zu enttäuschen werde ich es jetzt zu verstehen versuchen.