Pausen zwischen den Buchstaben bei Textausgabe



  • Hallo,

    Ich wollte mal fragen ob jemand weiß wie man es schafft die Textausgabe in der Konsole so zu gestalten, dass zwischen den einzelnen Zeichen eines Wortes immer kurz eine Pause ist bevor der nächste Buchstabe kommt.
    Bisher habe ich das Problem so wie im Beispiel gelöst aber das ist ja ziemlich umständlich und außerdem kann ich damit zwischen den Zeichen eines eingelesenen Strings keine Pausen rein machen, weil ich den Namen von dem Benutzer der das Programm benutzt nicht kenne...
    Hat jemand eine Lösung wie man das Problem angehen kann? Vielleicht gibt es ja eine Funkion für sowas.

    #include <iostream> 
    #include <windows.h> 
    #include <string>
    #include <stdlib.h>
    
    int main() 
    { 
    	std::string name = "";
    
    	std::cout << " " << std::endl;
        std::cout << " H"; Sleep(50); std::cout << "a"; Sleep(50); std::cout << "l"; Sleep(50); std::cout << "l"; Sleep(50); std::cout << "o"; 
    	Sleep(50); std::cout << "! "; Sleep(50); std::cout << "W"; Sleep(50); std::cout << "i"; Sleep(50); std::cout << "e "; Sleep(50); std::cout << "h";
    	Sleep(50); std::cout << "e"; Sleep(50); std::cout << "i"; Sleep(50); std::cout << "s"; Sleep(50); std::cout << "s"; Sleep(50); std::cout << "t";
    	Sleep(50); std::cout << " "; Sleep(50); std::cout << "D"; Sleep(50); std::cout << "u"; Sleep(50); std::cout << "? "; 
    
    	std::cin >> name;
    	system("cls");
    	std::cout << " " << std::endl;
    	std::cout << " S"; Sleep(50); std::cout << "c"; Sleep(50); std::cout << "h"; Sleep(50); std::cout << "\x94"; Sleep(50); std::cout << "n"; Sleep(50);
    	std::cout << " "; Sleep(50); std::cout << "d"; Sleep(50); std::cout << "i"; Sleep(50); std::cout << "c"; Sleep(50); std::cout << "h";
    	Sleep(50); std::cout << " "; Sleep(50); std::cout << "k"; Sleep(50); std::cout << "e"; Sleep(50); std::cout << "n"; Sleep(50); std::cout << "n";
    	Sleep(50); std::cout << "e"; Sleep(50); std::cout << "n"; Sleep(50); std::cout << " "; Sleep(50); std::cout << "z"; Sleep(50); std::cout << "u";
    	Sleep(50); std::cout << " "; Sleep(50); std::cout << "l"; Sleep(50); std::cout << "e"; Sleep(50); std::cout << "r"; Sleep(50); std::cout << "n";
    	Sleep(50); std::cout << "e"; Sleep(50); std::cout << "n"; Sleep(50); std::cout << " "; Sleep(50); std::cout << name; Sleep(50); 
    	std::cout << "! " << "\x1" << std::endl;
    
    	std::getchar();
    	std::getchar();
    	return 0;
    }
    


  • for (const auto &c : "Wie heissen Sie?"){
        std::cout << c;
        Sleep(50);
    }
    for (const auto &c : name){
        std::cout << c;
        Sleep(50);
    }
    


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

    void slowOutput( const std::string& text )
    {
    for( unsigned count = 0; count < text.length(); ++count ) //ohne c++11 falls du das noch nicht kennst
    {
    std::cout << text[ count ];
    Sleep(50);
    }
    }

    int main()
    {
    slowOutput( "hello, world" );
    }



  • #include <string>
    #include <iostream>
    #include <windows.h>
    
    void slowOutput( const std::string& text )
    {
        for( unsigned count = 0; count < text.length(); ++count ) //ohne c++11 falls du das noch nicht kennst
        {
            std::cout << text[ count ];
            Sleep(50);
        }
    }
    
    int main()
    {
        slowOutput( "hello, world" );
    }
    

    sry 🙄


  • Mod

    Wie man absolut alles erwischt:

    #include <streambuf>
    #include <ios>    
    #include <thread>
    #include <chrono>
    
    class seppjs_super_duper_verzoegernder_streambuf : public std::streambuf
    {
    public:
      seppjs_super_duper_verzoegernder_streambuf(std::ios& in, unsigned milliseconds_delay)
        : in(in)
        , buf (in.rdbuf())
        , delay(milliseconds_delay)
      {
        in.rdbuf(this);
      }
      ~seppjs_super_duper_verzoegernder_streambuf()
      {
        in.rdbuf(buf);
      }
    
    protected:
     virtual int_type overflow(int_type c)
      {
        buf->sputc(c);
        std::this_thread::sleep_for(delay);
        buf->pubsync();
        return c;  
      }
    private:
      seppjs_super_duper_verzoegernder_streambuf( const seppjs_super_duper_verzoegernder_streambuf& ) = delete;    
      seppjs_super_duper_verzoegernder_streambuf& operator=( const seppjs_super_duper_verzoegernder_streambuf& ) = delete;
    
      std::ios& in;
      std::streambuf* buf;
      std::chrono::milliseconds delay;
    };
    
    #include <iostream>  
    
    int main()
    {
      {
        seppjs_super_duper_verzoegernder_streambuf foo(std::cout, 50); 
    
        std::cout << "Dies ist ein Text, nun ein paar Zahlen: " << 123456 << " " << std::hex << 123456 << " Blahblah\nBlahBlah\n";
      }
    }
    

    P.S.: Geht natürlich auch ohne C++11 für die Altmodischen. Einfach "= delete" entfernen und den Chrono/Thread-Kram durch ein systemabhängiges sleep ersetzen.

    edit2: Ups, da war noch Debugcode drin.


  • Mod

    #include <chrono>
    #include <thread>
    #include <iterator>
    #include <iostream>
    
    template< typename InputIterator,
              typename OutputIterator,
              typename Rep,
              typename Period >
    OutputIterator slowCopy( InputIterator first, InputIterator last,
                             OutputIterator out,
                             std::chrono::duration<Rep, Period> const& sleep_duration )
    {
    	while( first != last )
    	{
    		*out++ = *first++;
    		std::this_thread::sleep_for( sleep_duration );
    	}
    	return out;
    }
    
    int main()
    {
    	char const str[] = "Hello World!";
    	slowCopy( std::begin(str), std::end(str),
    	          std::ostream_iterator<char>{std::cout << std::unitbuf},
    	          std::chrono::seconds{1} );
    }
    

    Sie nutzt std::this_thread::sleep_for zum Anhalten.
    Damit garantiert ist, dass auch wirklich nach jedem Zeichen geflusht wird, muss unitbuf gesetzt werden.

    Edit: SeppJ's Lösung ist natürlich viel schöner, Touché. 👍


  • Mod

    @SeppJ:
    Kritik:

    virtual int_type overflow(int_type c)
    {
    buf->sputc(c);

    Du weißt was zu tun ist.

    • Du solltest prüfen ob rdbuf() nicht 'nen Nullzeiger zurückgibt.
    • Zeile 24 und 25 sollten vertauscht werden, oder?
    • Und der Typ des zweiten Konstruktorparameters sollte std::chrono::milliseconds sein.

  • Mod

    Arcoth schrieb:

    [*]Du solltest prüfen ob rdbuf() nicht 'nen Nullzeiger zurückgibt.

    Und wenn es einer ist? Mir fällt kein sinnvolles Verhalten ein, außer es, wie jetzt, einfach krachen zu lassen.

    [*]Zeile 24 und 25 sollten vertauscht werden, oder?

    Ja, vertauscht ist es wahrscheinlich schöner.

    Und der Typ des zweiten Konstruktorparameters sollte std::chrono::milliseconds sein.

    Wenn schon, dann richtig:

    template<class Rep, class Period> 
      seppjs_super_duper_verzoegernder_streambuf(std::ios& in, std::chrono::duration<Rep, Period> delay)
    

    Das dumme ist bloß, der Aufruf sieht dann so oder ähnlich aus:

    seppjs_super_duper_verzoegernder_streambuf foo(std::cout, std::chrono::seconds(1));
    

    Und das ist dann nicht mehr im Sinne des Erfinders. Das ist sinnloses Overenginering mit Codebloat als einzigem Effekt. Die sinnvollen Werte sind hier alle im Millisekundenbereich.



  • Ehm Sorry Leute, dass ist mir dann doch alles noch ein bisschen zu hoch..
    Ich werde meine Frage dass nächste mal besser formulieren und schreiben dass ich ein noob bin 😃

    Danke aber, LG Käffchen


Log in to reply