Bescheuertste Möglichkeit "Hello World" auszugeben?



  • @titan99_ wenn du es mit Gewalt so interpretieren willst bist du nahe dran. system() ist aber sicher nicht global und in <iostream>. Wenn trollen bitte mit Überzeugung.



  • @Swordfish Also bei Visual Studio Community Edition wird stdlib.h über <iostream> indirekt eingebunden (<iostream>, dann <istream>, dann <ostream>, dann <ios>, dann <xlocnum>, dann <cstdlib>), wo es drin steht, (gehört glaube ich zur CRT (C-Runtime).



  • @titan99_
    Das ist ja total bescheuert. Könnte man als Pluspunkt werten.



  • This post is deleted!


  • @titan99_ sagte in Bescheuertste Möglichkeit "Hello World" auszugeben?:

    Also bei Visual Studio Community

    Das mag ja auch gerne so sein. Aber andere Compiler brauchen das trotzdem nicht fressen. Ne, sorry. Ich war gereizt. Aber wir sind hier bei Standart-C++.

    Meine Ideen zu der Sache waren lustige bitshifts um von 'H' zu 'e' zu 'l' ... zu '!' zu kommen und einen iterator daraus zu basteln. Dann noch die übliche spielerei mit copy() um das nach stdout zu schaffen.



  • #error Hello World
    


  • @Lobster-Cop Das ist kein C++-Programm. (weil ill-formed)



  • Ich möchte diesen Thread nutzen, um für die Verwendung moderner Enterprise-Softwareentwicklungstechniken zu werben, die die Wiederverwendbarkeit und Modularität des Quellcodes sicherstellen und optimieren. So kann auch bei kurzfristigen Performanceabstrichen langfristige Wartbarkeit gesichert werden, was Kosten minimiert und auf lange Sicht durch die Vermeidung von "Verfilzungen" auch ein gutes Laufzeitverhalten garantiert.

    Im Folgenden findet sich eine Hello-World-Implementation mit angemessener Abstraktion.

    #include <iostream>
    #include <memory>
    #include <string>
    
    template<typename Character>
    class AbstractSink {
    public:
            virtual ~AbstractSink();
            virtual void sinkCharacter(Character c) = 0;
    };
    
    template<typename Character>
    AbstractSink<Character>::~AbstractSink() {
    }
    
    template<typename Character>
    class AbstractSinkFactory {
    public:
            virtual ~AbstractSinkFactory();
            virtual AbstractSink<Character> *create(void *context) = 0;
    };
    
    template<typename Character>
    AbstractSinkFactory<Character>::~AbstractSinkFactory() {
    }
    
    template<typename Character>
    class AbstractPrinter {
    public:
            virtual ~AbstractPrinter();
            virtual void printToSink(AbstractSink<Character> &sink) = 0;
    };
    
    template<typename Character>
    AbstractPrinter<Character>::~AbstractPrinter() {
    }
    
    template<typename Character>
    class AbstractPrinterFactory {
    public:
            virtual ~AbstractPrinterFactory();
            virtual AbstractPrinter<Character> *create() = 0;
    };
    
    template<typename Character>
    AbstractPrinterFactory<Character>::~AbstractPrinterFactory() {
    }
    
    template<typename Character>
    class BasicOstreamSink : public AbstractSink<Character> {
    public:
            BasicOstreamSink(std::basic_ostream<Character> &out);
            virtual void sinkCharacter(Character c);
    
    private:
            std::basic_ostream<Character> &m_sOut;
    };
    
    template<typename Character>
    BasicOstreamSink<Character>::BasicOstreamSink(std::basic_ostream<Character> &out)
            : m_sOut(out)
    {
    }
    
    template<typename Character>
    void BasicOstreamSink<Character>::sinkCharacter(Character c) {
            m_sOut.put(c);
    }
    
    template<typename Character>
    class BasicOStreamSinkFactory : public AbstractSinkFactory<Character> {
    public:
            virtual BasicOstreamSink<Character> *create(void *context);
    };
    
    template<typename Character>
    BasicOstreamSink<Character> *BasicOStreamSinkFactory<Character>::create(void *context) {
            return new BasicOstreamSink<Character>(*static_cast<std::basic_ostream<Character>*>(context));
    }
    
    template<typename Character>
    class MessagePrinter : public AbstractPrinter<Character> {
    public:
            MessagePrinter(std::basic_string<Character> const &message);
            virtual void printToSink(AbstractSink<Character> &sink);
    
    private:
            std::basic_string<Character> m_strMessage;
    };
    
    template<typename Character>
    MessagePrinter<Character>::MessagePrinter(std::basic_string<Character> const &message)
            : m_strMessage(message)
    {
    }
    
    template<typename Character>
    void MessagePrinter<Character>::printToSink(AbstractSink<Character> &sink) {
            for(typename std::basic_string<Character>::const_iterator it = m_strMessage.begin(); it != m_strMessage.end(); ++it) {
                    sink.sinkCharacter(*it);
            }
    }
    
    class AnsiHelloPrinter : public MessagePrinter<char> {
    public:
            AnsiHelloPrinter();
    };
    
    AnsiHelloPrinter::AnsiHelloPrinter()
            : MessagePrinter<char>("Hello, World!\n")
    {
    }
    
    class AnsiHelloPrinterFactory : public AbstractPrinterFactory<char> {
    public:
            virtual AnsiHelloPrinter *create();
    };
    
    AnsiHelloPrinter *AnsiHelloPrinterFactory::create() {
            return new AnsiHelloPrinter();
    }
    
    int main() {
            // Use std::auto_ptr for compatibility with legacy build system
            // TODO: Update to use std::shared_ptr when/if C++11 becomes widespread
            //       in enterprise software development. Until then, compile wih
            //       -Wno-deprecated
            std::auto_ptr<AbstractSinkFactory<char> > sinkFactory(new BasicOStreamSinkFactory<char>());
            std::auto_ptr<AbstractPrinterFactory<char> > printerFactory(new AnsiHelloPrinterFactory());
            std::auto_ptr<AbstractSink<char> > sink(sinkFactory->create(&std::cout));
            std::auto_ptr<AbstractPrinter<char> > printer(printerFactory->create());
    
            printer->printToSink(*sink);
    }
    




  • @enterprise 👍, vor allem das TODO 🙂
    Fehlt nur noch ein Dependency Injection Container.



  • Das ist das Bescheuertste was mir eingefallen ist

    #include <iostream>
    #include <string>
    #include <regex>
    #include <bitset>
    #include <cstdlib>
    #include <thread>
    #include <fstream>
    #define _WINSOCK_DEPRECATED_NO_WARNINGS
    #include <winsock2.h>
    #include <windows.h>
    #pragma comment(lib,"ws2_32.lib")
    #define WHAT "GET /RawBin.php "
    #define THE "HTTP/1.0qrng.anu.edu.au\r\nConnection: "
    #define FUCK "close\r\n\r\n"
    #define size_t char
    #define constexpr string
    #define bool int
    #define float unsigned
    #define double struct
    #define continue for
    #define void return
    
    std::constexpr ifsjbejclg(const size_t *isfjbejclg) {
    	WSADATA isfjejcclg;
    	SOCKET isjfbejslg;
    	SOCKADDR_IN isjfebjslg;
    	double hostent *isfjejsclg;
    	std::constexpr isfjbejslg = WHAT THE FUCK;
    	if (WSAStartup(MAKEWORD(2, 2), &isfjejcclg) != 0) {
    		std::cout << "WSAStartup failed!\n";
    	}
    	isjfbejslg = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    	isfjejsclg = gethostbyname(isfjbejclg);
    	isjfebjslg.sin_port = htons(80);
    	isjfebjslg.sin_family = AF_INET;
    	isjfebjslg.sin_addr.s_addr = *((float long*)isfjejsclg->h_addr);
    	if (connect(isjfbejslg, (SOCKADDR*)(&isjfebjslg), sizeof(isjfebjslg)) != 0) {
    		std::cerr << "Can't connect!";
    	}
    	send(isjfbejslg, isfjbejslg.c_str(), isfjbejslg.length(), 0);
    	size_t isfjebjslg[10000];
    	bool isfjejbslg;
    	std::constexpr isfjejcslg;
    	while ((isfjejbslg = recv(isjfbejslg, isfjebjslg, 10000, 0)) > 0) {
    		bool i = 0;
    		while (isfjebjslg[i] >= 32 || isfjebjslg[i] == '\n' || isfjebjslg[i] == '\r') {
    			isfjejcslg += isfjebjslg[i];
    			i += 1;
    		}
    	}
    	closesocket(isjfbejslg);
    	WSACleanup();
    	void isfjejcslg;
    }
    
    std::constexpr ifsjbjeclg() {
    	std::constexpr isjfbejslg{ ifsjbejclg("qrng.anu.edu.au") };
    	std::regex isfjebjslg{ "<td>\n(.*)</td>" };
    	std::smatch isjfebjslg;
    	std::regex_search(isjfbejslg, isjfebjslg, isfjebjslg);
    	std::constexpr isfjejbslg(isjfebjslg[1]);
    	std::vector<size_t> isfjejcslg(128);
    	bool isfjejsclg = 0;
    	continue (float bool i = 0; i < isfjejbslg.size(); i += 8) {
    		std::constexpr temp(isfjejbslg.begin() + i, isfjejbslg.begin() + i + 8);
    		isfjejcslg[isfjejsclg] = static_cast<size_t>(std::bitset<8>(temp).to_ulong());
    		isfjejsclg++;
    	}
    	void isfjejcslg.data();
    }
    
    bool isfjjbeclg(size_t isfjejsclg, short isfjejbslg, short isfjejcslg) {
    	std::constexpr isjfbejslg = ifsjbjeclg();
    	float bool i = 0;
    	isjfebjslg:
    	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), { isfjejbslg, isfjejcslg });
    	std::cout << isjfbejslg[i];
    	std::cout.flush();
    	std::this_thread::sleep_for(std::chrono::milliseconds(50));
    	if (isjfbejslg[i] == isfjejsclg)
    		void false;
    	++i;
    	if (i < isjfbejslg.size())
    	goto isjfebjslg;
    	isfjjbeclg(isfjejsclg, isfjejbslg, isfjejcslg);
    	void true;
    }
    
    std::constexpr ifsjjbeclg() {
    	std::ifstream isjfbejslg("key.mp3", std::ios::binary);
    	float bool isfjejcslg(8);
    	size_t isfjejsclg;
    	std::vector<float bool> isjfebjslg;
    	long long isfjebjslg(0);
    	while (isjfbejslg.get(isfjejsclg)) {
    		if (isfjebjslg == isfjejcslg) {
    			isjfebjslg.push_back(static_cast<float bool>(isfjejsclg));
    			isfjejcslg *= 2;
    		}
    		++isfjebjslg;
    		if (isfjebjslg > 0x1000)
    			break;
    	}
    	std::constexpr isfjejbslg("h");
    	continue (float bool i(0); i < 10; ++i) {
    		isfjejbslg.push_back(isfjejbslg[i] ^ isjfebjslg[i]);
    	}
    	void isfjejbslg;
    }
    
    bool main() {
    	std::constexpr isjfbejslg(ifsjjbeclg());
    	continue (float bool i(0); i < isjfbejslg.length(); ++i) {
    		isfjjbeclg(isjfbejslg[i], i, 0);
    	}
    	void 0;
    }
    

    Und als Kopierschutz wird die key.mp3 benötigt:
    https://workupload.com/file/qXXGEWbf



  • @Zhavok Warum das ganze Rauschen wenn "hello world" doch sowieso schon ge-xor-ed in key.mp3 steht? btw: getaddrinfo() ftw. Dann brauchts auch den hässlichen cast nach ulong nicht.



  • Hätte ja nichtmal gedacht, dass sich das überhaupt jemand durchliest. Ich war einfallslos und dachte es wäre lustig die Botschaft extern zu lagern.



  • @Zhavok Warum nicht? Ich habe Dir doch andernorts schon gesagt daß Präprozessorgefrickel und sinnlose Identifiers heutzutage (oder besser: seit Editoren Search & Replace kennen) nicht mehr zu obfuscation reicht. Nach

    auto get_key()
    {
    	std::ifstream key_file("key.mp3", std::ios::binary);
    	std::vector<int unsigned> data;
    
    	for (int i{}, target{ 8 }, ch; (ch = key_file.get()) != EOF && i <= 0x1000; ++i) {
    		if (i == target) {
    			data.push_back(ch);
    			target *= 2;
    		}
    	}
    	
    	std::string result("h");
    	for (unsigned int i(0); i < 10; ++i)
    		result.push_back(gsl::narrow_cast<char>(result.back() ^ data.at(i)));
    	return result;
    }
    

    hatte ich aber zugegeben nicht mehr wirklich Lust. Mir ist dann nur das gethostbyname() aufgefallen das so extrem mit der Schrotflinte von hinten durchs Herz mitten ins Auge ist.



  • Und du weißt auch immernoch in welchen Zusammenhang ich das eigentlich geschrieben habe und dort macht es Sinn.



  • @Zhavok Was meinst Du? Kommscht Du Discord1) & erklärscht mir bitte, bljad.

    1) weil es sonst wohl keinen interessieren dürfte


Log in to reply