#include <iostream>
#ifndef IRW
#define IRW out
#endif

int main()
{
	std::cIRW<<"hallo"std::endl;
	return 0;
}

Ich dachte, es wird alles wortwörtlich übersetzt... oder habe ich das falsch verstanden und der Präprozessor verändert so etwas nicht?

Gruß Speedy_92

Das sollte gehen:

#include <iostream>
#define TEST cout

int main()
{
    std::TEST << "test" << endl;
    return 0;
}

Wenn du "cIRW" schreibst, ist das ein Ausdruck, der dem Compiler unbekannt ist. Du musst also schon erweitern, wie oben gezeigt.

Btw, Makros bzw. besser "typedefs" dienen lediglich dem eigenen Komfort. Außer du willst den Code halt absichtlich unleserlich halten.

Ok, aber ich dachte das es ja vielleicht doch geht... Naja schade drum

das wuerde doch nur zu massig problemen fuehren. denk einfach nur mal an die guten macros max() und min() oder _T()

furchtbar wenn der praeprozessor so dumm waere... dann koennte man ihn naemlich garnicht verwenden... er ist ja schon so viel zu dumm und macht dauernd probleme

*Edit:

#include <iostream>
#define TEST <<
#define Bla cout
#define Blub cout
#define KA <<
int main()
{
	std::Bla TEST "test" TEST std::endl;
	std::Blub KA "verwirrend" TEST std::endl;
    return 0;
}

So z.B. würde es schon reichen um dem Leser den Spaß zu verderben

Stimmt auch wieder. Hatte nur gedacht, dass man dadurch vielleicht seinen Code besser schützen könne. Weil falls es irgendwer schafft an den Code eines meiner Programme heranzukommen wäre dies von großem Vorteil. Dann würde ich vor dem Kompilieren eine Kopie von den Header-, Quelldateien, usw. machen und dann die Ganzen Dateien durch ein Programm laufen lassen, welche sie in dieser Art "verunstalten". Dadurch wäre es für Fremde ein großer Aufwand, den Quelltext zu lesen.

Sorry, aber ich habe noch nie grösseren Mist gehört.
Ich hoffe jetzt mal, dass es einfach schon spaet und du seeeeehr müde bist..

Stimmt auch wieder. Hatte nur gedacht, dass man dadurch vielleicht seinen Code besser schützen könne. Weil falls es irgendwer schafft an den Code eines meiner Programme heranzukommen wäre dies von großem Vorteil.

Leichter Anfall von Paranoia?
Ich denke kaum, dass sich jemand bemüht, um deinen Code zu stehlen und zu vermarkten :p

Speedy_92 schrieb:

Dadurch wäre es für Fremde ein großer Aufwand, den Quelltext zu lesen.

Und für dich genauso. Wenn du noch eine reine, noch nicht verunstaltete Form hättest, könnte der Feind ebenso an diese gelangen.

Denk immer an die Achse des Bösen :p

#define AB(x) x ## out<<
#define SD(x) s ## x ## d::

int main()
{
    SD(t)AB(c)"Hello World!";
}

Wenn du wirklich obfuscated programmieren willst, solltest du richtige Makromagie benutzen:

#define AB(x) x ## out<<
#define SD(x) s ## x ## d::

int main()
{
    SD(t)AB(c)"Hello World!";
}

Also die Macromagie gefällt mir so langsam

Tia... ich brauche halt ein wenig mehr Mittel um unleserlichen Code zu schreiben

#include <iostream>

#define _private public
#define _public private
#define _class struct
#define _struct class
#define _void int
#define _int void
#define _std xml
#define _xml std
#define _for while
#define _while for

#define MAIN(x)       \
        int main()    \
        {             \
            x;        \
            return 0; \
        }

_struct CTest
{
_private:
    static _int test(_void var) { _xml::cout << "test " << var << _xml::endl; };
};

MAIN(_while (_void i = 0; i < 5; ++i) { CTest::test(i); })

// usw. :D

Grüssli

#define m int main() {
#define f for(
#define w while(
#define t while(true);
#define i if(
#define v(a) int a;
#define y(a) int a = 0;
#define n(a) (++a)
#define s(a) std::cout << a << std::endl;

m
v(x)
f y(z) z<3; n(z))
 i z<2) {s("x="<<x)}
t
}

Noch besser siehts in einer Zeile aus:

m v(x) f y(z) z<3; n(z)) i z<2) {s("x="<<x)} t}

Viel Spass damit
(Eigentlich schade, dass man #define nicht auch noch abkürzen kann)...

#define for_Each(a,b) for(int i= (a), i< (b), ++i)

for_Each(0,10){

}

das find ich schön