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.


Log in to reply