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;
}

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

#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.

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é.

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.

[*]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.

Danke aber, LG Käffchen