C++Guns – RoboBlog blogging the bot

Möchte man ohne zusätzliche Libs den Cursor auf der Konsole frei bewegen, langt folgender kleiner Hack den man sich schnell aus dem Internet googelt.

Und schwubs di wupp war ein kleiner ASCII Bildschirmschoner hingezaubert.

#include < stdio.h >

void gotoxy(int x,int y)
{
  printf("%c[%d;%df",0x1B,y,x);
}

int main()
{
  int x = 0, y = 0;
  char c = 0;
  system("clear");

  while(1)
  {
    x = rand()%50;
    y = rand()%25;
    c = rand()%'z' + ' ';
    gotoxy(x,y);
    printf("%c", c);
    fflush(stdout);
    sleep(1);
  }
}

Und so schaut er aus

a  avD F        !    ` U /v   y'   z    Y y  j 5
 j   >         \            X         t
S     9                          e o          X
    R x              m    q            P c   E  >
-        7r .   =,  7          l       1
  r           m      e       c#     x     ]   "
         t  B       W  b          V
      G       l  m V  OO        zd
&   7        rX@"  >     dJ          3 )
h    &        H           R    F         3
   !    l   n     6 K m         #     @  u
        h  # |      O               ,    &
j  J        *   P     r c  E /      $
         S       \     S      ^  j5S%f          c
                         p     z_z l           n
               R        f       N   ;  7  q    0
     J   i&     H|   ?    *        y  I      s
a  |     #    Q   5   g\      D   F       e Ho
  f b  ]            
	

Hier gefunden http://www.wachtler.de/ck/8_4_Grunddatentypen.html

C erhält durch Zeigerarithmetik erst richtig Leben; die größere Effektivität von Programmen in C rührt zu einem großen Teil davon. Angenommen, eine Funktion soll ein Feld mit double-Elementen löschen, also alle Werte zu 0.0 setzen. Ein ehemaliger FORTRAN- oder Pascal-Programmierer würde die Funktion vielleicht so schreiben:

/* grloel.c 31. 7.95 kw
*/

#include

void loesche_double( double feld[], size_t wieviele )
{
size_t i;

for( i=0 ; i < wieviele ; i++ ) feld[i] = 0.0; } Das funktioniert natürlich, aber die Lösung enthält überflüssige Berechnungen. Abgesehen von der nötigen Erhöhung des Schleifenzählers (Auswertung von ++) muß bei jedem Durchlauf die Adresse des Elementes feld[i] berechnet werden. Dazu muß das Programm die Adresse hernehmen, die mit dem Namen feld verbunden ist (das ist die Adresse des ersten Feldelements), und dazu ein Produkt addieren, nämlich i*sizeof(double) (zur Auswertung von feld[i]). Mit Zeigerarithmetik läßt sich die Funktion wesentlich schneller machen: /* grloes.c 31. 7.95 kw */ #include

void loesche_double( double *feld, size_t wieviele )
{
double *pfeld = feld;
double *pende = feld+wieviele;

while( pfeld < pende ) *pfeld++ = 0.0; } Jetzt wird der Parameter feld als Zeiger auf das erste Element aufgefaßt. Ein Zeiger (pfeld) wandert durch das Feld und zeigt nacheinander auf die zu löschenden Elemente. Neben der eigentlichen Zuweisung (=) muß in der Schleife nur noch zu pfeld bei jedem Durchlauf der Wert sizeof(double) addiert werden (Auswertung von ++). Die aufwendige Multiplikation entfällt, außerdem hat man statt zwei Additionen nur noch eine.

Wer kennt das nicht, man möchte eine Zahl über USART ausgeben, scheut sich aber vor solche dicken Funktionen wie fprintf. Man höhrt dann öfters von einer itoa Funktion, die es aber nicht per default gibt. Hier ist meine uitoa Funktion, welche die Zahl gleich raussendet. Inspiriert vom midgard Projekt von buha.info . Die USARTtransmis* Funktionen sind von http://jump.to/fleury .

void USARTuitoa(uint16_t n)
{
// max. 5 stellige zahlen + die abschliessende 0 im string
unsigned char s[6];
// arrays fangen bei 0 an zu zählen. pos zeigt auf das letzte feld
register uint8_t pos = 5;

// den string mit einer 0 terminieren
s[pos] = (char) 0;

do {
uint8_t rest = n % 10;
n = (n - rest) / 10;

s[- -pos] = rest + '0';
} while(n && pos);

USARTtransmitString((unsigned char *) (s + pos));
}