C++ - TIME

  • #1
G

Game12

Bekanntes Mitglied
Themenersteller
Dabei seit
07.01.2005
Beiträge
436
Reaktionspunkte
0
In QB gibt es eine Variable TIME , die die Sekunden seit Mitternacht angibt .
gibt es etwas änliches in C++. Ich brauche das um Warteschleifen zu machen bei denen sich die länge der Wartezeit nicht auf die Geschwindigkeit des Rechners bezieht wie in diesem Beispiel :

Code:
 long x;
 for(x=0;x<500000000;1 )
 {
   x++;
 }


edit :


wie kann man Zahlen Zufällig bestimmen?

also ich will z.B. das x Zwischen 100 und 1000 liegt und bei (jedem) Programmstart einer anderen Zahl entspricht.

ich weiß QB nevt euch :

Code:
x= INT(RND(1) * 900 +100)
 
  • #2
Ich brauche das um Warteschleifen zu machen bei denen  sich die länge der Wartezeit nicht  auf die Geschwindigkeit des Rechners bezieht

Gibt's nicht unter Standard-C++, da es plattformabhängig ist. D.h., man kann sich schon etwas zusammenbasteln (z.B. mit Hilfe der time-Funktion), aber es ist weder schön noch genau. Du solltest dafür die Funktion Sleep (WinAPI) verwenden. Hat auch noch den Vorteil, dass der Thread dann wirklich inaktiv ist und keine Rechenzeit verbraucht.

wie kann man Zahlen Zufällig bestimmen?
also ich will z.B. das x Zwischen 100 und 1000  liegt

int x= rand() % 901 + 100;

und bei (jedem) Programmstart einer anderen Zahl entspricht.

Dann vorher (einmal)

srand((unsigned)time(NULL));

Für srand und rand evtl. cstdlib einbinden, für time ctime. Also
#include <cstdlib>
#include <ctime>
 
  • #3
kann man auch Zehntel- , Hundertstel-, Tausenstellsekunden seit Mitternacht angeben ?


also so,dass es eine Gleitkommazahl (float,double) sein müsste ?

ich brauch es für dieses Programm :

Code:
// Programm zur Zählgeschwindigkeits Berechnung...
#include <iostream>
#include <ctime>

using namespace std;
int main ()
{

 int c[100000];
 long b=1;
 long a;
 long x;
 long y=0;
 int d;
 int e;
 double f=0;
 int g;



 cout <<  Programm zur Zählgeschwindigkeits Berechnung<< endl;
 cout << endl <<  Wieviele Tests wollen sie durchführen(max. 100000) ? :;
 cin >> a;
 cout <<  Wie Hoch soll der Rechner zählen ?           :;
 cin >> g;
 cout << endl << endl;

 if (a <=0 )
 {
  cout << Falsche Eingabe, wird beendet...;
  cin.get();
  cin.get();
  return 1;
 }
 if(g<=0)
 {
  cout<<  Falschge Eingabe, wird beendet...;
  cin.get();
  cin.get();
  return 1;
 }



 for(d=0;d<a;++d)
 {

  cout << Test << b <<: ;
  b++;

  c[y]= ((unsigned)time(NULL));

  for(x=1;x < g;1)
  {
   x++;
  }
  c[y] =((unsigned)time(NULL))-c[y];
  cout << c[y] << Sekunden<< endl;
  ++y;
 }

 for(e=0;e<a;++e)
 {

  c[e] =
  f+=c[e];

 }

 f = f / e;

 if (a == 1)
 {
  cout << endl << Mittelwert des Tests:  << f;
 }

 else if (a > 0)
 {
  cout << endl << Mittelwert der Tests:  << f;
 }

 else
 {
 cout << Falsche eingabe...;
 }

 cin.get();
 cin.get();

 return 1;
}


edit:

n QB gibt es den Locate befel ,der Buchsaben an die gewünschte stelle setzt :BSP



Code:
LOCATE 4,15 PRINTO



Code:

ausgabe :


O




wie kann man in C++ z.B die Pfeiltasten,ESC,ENTER usw benutzen , wie kann ich ein spiel screiben ,dass auf die Pfeiltasten reagiert...?
 
  • #4
Mir ist nicht ganz klar, warum Du die seit Mitternacht vergangene Zeit haben willst (oder eine Warteschleife). Wenn Du eine einfache Warteschleife brauchst, nimm Sleep (Angabe der Zeit in Millisekunden). Wenn Du die Uhrzeit haben willst, time (ANSI) oder Windows-Funktionen. Wenn Du einen Zeitraum genau messen willst, clock (Prozesszeit; ANSI) oder die Windows-Funktion QueryPerformanceCounter.

also so,dass es eine  Gleitkommazahl (float,double) sein müsste ?

Siehe unten. Das funktioniert übrigens nicht wirklich, da die meisten Compiler Deine Schleife (schon standardmäßig) einfach wegoptimieren, wenn Du nicht auf Debug kompilierst (und mit->volatile' stimmt das Ergebnis nicht mehr, da der Code aufgebläht wird).

Nicht optimiert:
Code:
	mov	DWORD PTR _x$63405[ebp], 1
	jmp	SHORT $L63406
$L63407:
	mov	eax, DWORD PTR _x$63405[ebp]
	add	eax, 1
	mov	DWORD PTR _x$63405[ebp], eax
$L63406:
	mov	eax, DWORD PTR _x$63405[ebp]
	cmp	eax, DWORD PTR _nLoops$[ebp]
	jge	SHORT $L63408
	jmp	SHORT $L63407
$L63408:

Optimiert:
Code:
;)

Du kannst aber count bzw. QueryPerformanceCounter verwenden, wenn Du wissen willst, wie effizient Dein Programm ist und welche Wirkung Änderungen diesbezüglich haben; darum habe ich trotzdem beides unten eingefügt. BTW: Variablennamen können länger als ein Buchstabe sein ;) <duck>

Code:
#include <iostream>
#include <ctime>
#include <windows.h>

using namespace std;

const long maxTests= 100000;

bool getValues(long& nTests, long& nLoops)
{
  cout <<  Programm zur Zählgeschwindigkeits-Berechnung << endl;
  cout << endl <<  Wieviele Tests wollen sie durchführen (max.;
  cout << maxTests << )? : ;
  cin >> nTests;
  cout <<  Wie hoch soll der Rechner zählen?                   : ;
  cin >> nLoops;
  cout << endl << endl;

  if ((nTests <= 0) || (nTests > maxTests) || (nLoops <= 0))
    return false;
  else
    return true;
}

void runtest(long nLoops, int pass, double results[])
{
  clock_t start= clock();

  for(long x=1; x<nLoops; ++x);

  clock_t finish= clock();
  results[pass]= (double)(finish - start) / CLOCKS_PER_SEC;
}

void runtest2(long nLoops, int pass, double results[])
{
  LARGE_INTEGER frequency, start, finish;

  SetThreadAffinityMask(GetCurrentThread(), 1);
  QueryPerformanceFrequency(&frequency);
  QueryPerformanceCounter(&start);
	
  for(long x=1; x<nLoops; ++x);

  QueryPerformanceCounter(&finish);	
  results[pass]= (finish.QuadPart - start.QuadPart) / (double)frequency.QuadPart;
}

double average(long nTests, double results[]) {
  double sum= 0;
  for(long e=0; e<nTests; ++e)
    sum+= results[e];
  return sum / nTests;
}

int main()
{
  double results[maxTests];
  long   nTests, nLoops;

  if(getValues(nTests, nLoops)) {

    long pass= 0;
    do {			
      cout <<  Test  << pass+1 << : ;
      runtest(nLoops, pass, results); // bzw. runtest2
      cout << results[pass] <<  Sekunden << endl;
      pass++;
    } while(pass < nTests);

    cout << endl <<  Mittelwert ;
    cout << (nTests == 1 ? des  : der );	
    cout << Tests:  << average(nTests, results) <<  Sekunden << endl << endl;

  } else
    cout <<  Falsche Eingabe, Programm wird beendet ... << endl << endl;

  return 0;
}
 
  • #5
n QB gibt es den Locate befel ,der Buchsaben an die gewünschte stelle setzt :BSP

Code:
LOCATE 4,15 PRINTO

Aus dem anderen Thread:

Code:
void cursorxy(int x, int y) {
  COORD point;
  point.X = x; point.Y = y;
  SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);
}

Vielleicht hilft Dir das hier auch weiter:

Konsolengröße (Screenbuffer) festlegen:
Code:
SMALL_RECT size;
size.Top = 0;
size.Left = 0;
size.Bottom = height-1;
size.Right = width-1;
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &size);
COORD Sz;
Sz.X = width;
Sz.Y = height;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), Sz);

Cursor verstecken:
Code:
HANDLE hScreenBuf = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO cci;
GetConsoleCursorInfo(hScreenBuf, &cci); 
cci.bVisible= FALSE;
SetConsoleCursorInfo(hScreenBuf, &cci);

wie kann man in C++ z.B die Pfeiltasten,ESC,ENTER usw benutzen , wie kann ich ein spiel screiben ,dass auf die Pfeiltasten reagiert...?

Das ist systemspezifisch, also gibt es das in C++ nicht ... Allerdings kannst Du unter Windows z.B. conio.h einbinden und die entsprechenden Windows-Funktionen benutzen. Wenn Du Zeichen ausgeben willst, ohne auf den nächsten Tastendruck zu warten, kannst Du _kbhit zusammen mit getch verwenden. So in der Art:

Code:
int getkey() {
  const int EXT1= 0, EXT2= 224;
  if(_kbhit()) {
    int input= getch();
    if((input == EXT1) || (input == EXT2))
      input= getch() << 8;
    return input;
  } else
    return kNone;
}

Die Definitionen:
Code:
#define kNone 0x0000

/* Miscellaneous upper-left of keyboard */ 

#define kESC    0x001b                  /* Escape                       */ 
#define kTAB    0x0009                  /* Tab                          */ 

/* Function keys F1 - F12 */ 

#define kF1     0x3b00                  /* Function key 1               */ 
#define kF2     0x3c00                  /* Function key 2               */ 
#define kF3     0x3d00                  /* Function key 3               */ 
#define kF4     0x3e00                  /* Function key 4               */ 
#define kF5     0x3f00                  /* Function key 5               */ 
#define kF6     0x4000                  /* Function key 6               */ 
#define kF7     0x4100                  /* Function key 7               */ 
#define kF8     0x4200                  /* Function key 8               */ 
#define kF9     0x4300                  /* Function key 9               */ 
#define kF10    0x4400                  /* Function key 10              */ 
#define kF11    0x8500                  /* Function key 11              */ 
#define kF12    0x8600                  /* Function key 12              */ 

/* Shifted function keys F1 - F12 */ 

#define ksF1    0x5400                  /* Shifted function key 1       */ 
#define ksF2    0x5500                  /* Shifted function key 2       */ 
#define ksF3    0x5600                  /* Shifted function key 3       */ 
#define ksF4    0x5700                  /* Shifted function key 4       */ 
#define ksF5    0x5800                  /* Shifted function key 5       */ 
#define ksF6    0x5900                  /* Shifted function key 6       */ 
#define ksF7    0x5a00                  /* Shifted function key 7       */ 
#define ksF8    0x5b00                  /* Shifted function key 8       */ 
#define ksF9    0x5c00                  /* Shifted function key 9       */ 
#define ksF10   0x5d00                  /* Shifted function key 10      */ 
#define ksF11   0x8700                  /* Shifted function key 11      */ 
#define ksF12   0x8800                  /* Shifted function key 12      */ 

/* Control function keys F1 - F12 */ 

#define kcF1    0x5e00                  /* Control function key 1       */ 
#define kcF2    0x5f00                  /* Control function key 2       */ 
#define kcF3    0x6000                  /* Control function key 3       */ 
#define kcF4    0x6100                  /* Control function key 4       */ 
#define kcF5    0x6200                  /* Control function key 5       */ 
#define kcF6    0x6300                  /* Control function key 6       */ 
#define kcF7    0x6400                  /* Control function key 7       */ 
#define kcF8    0x6500                  /* Control function key 8       */ 
#define kcF9    0x6600                  /* Control function key 9       */ 
#define kcF10   0x6700                  /* Control function key 10      */ 
#define kcF11   0x8900                  /* Control function key 11      */ 
#define kcF12   0x8a00                  /* Control function key 12      */ 

/* Miscellaneous control keys: right side of keyboard */ 

#define kBACK   0x0008                  /* Backspace                    */ 
#define kENTER  0x000d                  /* Enter                        */ 
#define kINS    0x5200                  /* Insert                       */ 
#define kDEL    0x5300                  /* Delete                       */ 
#define kHOME   0x4700                  /* Home                         */ 
#define kEND    0x4f00                  /* End                          */ 
#define kPGUP   0x4900                  /* Page Up                      */ 
#define kPGDN   0x5100                  /* Page Down                    */ 

/* Cursor keys */ 

#define kUP     0x4800                  /* Cursor Up                    */ 
#define kDOWN   0x5000                  /* Cursor Down                  */ 
#define kLEFT   0x4b00                  /* Cursor Left                  */ 
#define kRIGHT  0x4d00                  /* Cursor Right                 */ 

/* Alternate miscellaneous keys: upper-left of keyboard */ 

#define kaESC   0x0100                  /* Alternate Escape             */ 
#define kaTAB   0xa500                  /* Alternate Tab                */ 
#define kaBQUOT 0x2900                  /* Alternate ` or ~             */ 

/* Alternate Function keys F1 - F12 */ 

#define kaF1    0x6800                  /* Alternate Function key 1     */ 
#define kaF2    0x6900                  /* Alternate Function key 2     */ 
#define kaF3    0x6a00                  /* Alternate Function key 3     */ 
#define kaF4    0x6b00                  /* Alternate Function key 4     */ 
#define kaF5    0x6c00                  /* Alternate Function key 5     */ 
#define kaF6    0x6d00                  /* Alternate Function key 6     */ 
#define kaF7    0x6e00                  /* Alternate Function key 7     */ 
#define kaF8    0x6f00                  /* Alternate Function key 8     */ 
#define kaF9    0x7000                  /* Alternate Function key 9     */ 
#define kaF10   0x7100                  /* Alternate Function key 10    */ 
#define kaF11   0x8b00                  /* Alternate Function key 11    */ 
#define kaF12   0x8c00                  /* Alternate Function key 12    */ 

/* Alternate Numeric keys F1 - F12 */ 

#define ka1     0x7800                  /* Alternate 1                  */ 
#define ka2     0x7900                  /* Alternate 2                  */ 
#define ka3     0x7a00                  /* Alternate 3                  */ 
#define ka4     0x7b00                  /* Alternate 4                  */ 
#define ka5     0x7c00                  /* Alternate 5                  */ 
#define ka6     0x7d00                  /* Alternate 6                  */ 
#define ka7     0x7e00                  /* Alternate 7                  */ 
#define ka8     0x7f00                  /* Alternate 8                  */ 
#define ka9     0x8000                  /* Alternate 9                  */ 
#define ka0     0x8100                  /* Alternate 0                  */ 

/* Alternate letter keys A - Z */ 

#define kaA     0x1e00                  /* Alternate A                  */ 
#define kaB     0x3000                  /* Alternate B                  */ 
#define kaC     0x2e00                  /* Alternate C                  */ 
#define kaD     0x2000                  /* Alternate D                  */ 
#define kaE     0x1200                  /* Alternate E                  */ 
#define kaF     0x2100                  /* Alternate F                  */ 
#define kaG     0x2200                  /* Alternate G                  */ 
#define kaH     0x2300                  /* Alternate H                  */ 
#define kaI     0x1700                  /* Alternate I                  */ 
#define kaJ     0x2400                  /* Alternate J                  */ 
#define kaK     0x2500                  /* Alternate K                  */ 
#define kaL     0x2600                  /* Alternate L                  */ 
#define kaM     0x3200                  /* Alternate M                  */ 
#define kaN     0x3100                  /* Alternate N                  */ 
#define kaO     0x1800                  /* Alternate O                  */ 
#define kaP     0x1900                  /* Alternate P                  */ 
#define kaQ     0x1000                  /* Alternate Q                  */ 
#define kaR     0x1300                  /* Alternate R                  */ 
#define kaS     0x1f00                  /* Alternate S                  */ 
#define kaT     0x1400                  /* Alternate T                  */ 
#define kaU     0x1600                  /* Alternate U                  */ 
#define kaV     0x2f00                  /* Alternate V                  */ 
#define kaW     0x1100                  /* Alternate W                  */ 
#define kaX     0x2d00                  /* Alternate X                  */ 
#define kaY     0x1500                  /* Alternate Y                  */ 
#define kaZ     0x2c00                  /* Alternate Z                  */ 

/* Alternate miscellaneous symbol keys - right side of keyboard */ 

#define kaMIN   0x8200                  /* Alternate - or _             */ 
#define kaEQ    0x8300                  /* Alternate = or +             */ 
#define kaLB    0x1a00                  /* Alternate [ or {             */ 
#define kaRB    0x1b00                  /* Alternate ] or }             */ 
#define kaBSL   0x2b00                  /* Alternate \ or |             */ 
#define kaSC    0x2700                  /* Alternate ; or :             */ 
#define kaQUOT  0x2800                  /* Alternate-> or                 */ 
#define kaLT    0x3300                  /* Alternate , or <          */ 
#define kaGT    0x3400                  /* Alternate . or >          */ 
#define kaSLSH  0x3500                  /* Alternate / or ?             */ 

/* Alternate miscellaneous control keys - right side of keyboard */ 

#define kaBACK  0x0e00                  /* Alternate Backspace          */ 
#define kaENTER 0x1c00                  /* Alternate Enter              */ 
#define kaINS   0xa200                  /* Alternate Insert             */ 
#define kaDEL   0xa300                  /* Alternate Delete             */ 
#define kaHOME  0x9700                  /* Alternate Home               */ 
#define kaEND   0x9f00                  /* Alternate End                */ 
#define kaPGUP  0x9900                  /* Alternate Page Up            */ 
#define kaPGDN  0xa100                  /* Alternate Page Down          */ 

/* Alternate Cursor keys */ 

#define kaUP    0x9800                  /* Alternate Cursor Up          */ 
#define kaDOWN  0xa000                  /* Alternate Cursor Down        */ 
#define kaLEFT  0x9b00                  /* Alternate Cursor Left        */ 
#define kaRIGHT 0x9d00                  /* Alternate Cursor Right       */ 

/* Alternate Numeric Keypad */ 

#define kagSLASH        0xa400          /* Alternate /             */ 
#define kagSTAR         0x3700          /* Alternate *             */ 
#define kagMINUS        0x4a00          /* Alternate -             */ 
#define kagPLUS         0x4e00          /* Alternate +             */ 
#define kagENTER        0xa600          /* Alternate Enter         */ 

/* Control + miscellaneous upper-left of keyboard */ 

#define kcTAB           0x9400          /* Control Tab                  */ 

/* Control + miscellaneous keys - right side of keyboard                */ 

#define kcBACK          0x007f          /* Control Backspace            */ 
#define kcENTER         0x000a          /* Control Enter                */ 
#define kcINS           0x9200          /* Control Insert               */ 
#define kcDEL           0x9300          /* Control Delete               */ 
#define kcHOME          0x7700          /* Control Home                 */ 
#define kcEND           0x7500          /* Control End                  */ 
#define kcPGUP          0x8400          /* Control Page Up              */ 
#define kcPGDN          0x7600          /* Control Page Down            */ 

/* Control + Cursor keys */ 

#define kcUP            0x8d00          /* Control Cursor Up            */ 
#define kcDOWN          0x9100          /* Control Cursor Down          */ 
#define kcLEFT          0x7300          /* Control Cursor Left          */ 
#define kcRIGHT         0x7400          /* Control Cursor Right         */ 

/* Control + keys on Numeric Keypad */ 

#define kcgSLASH        0x9500          /* Control /               */ 
#define kcgSTAR         0x9600          /* Control *               */ 
#define kcgMINUS        0x8e00          /* Control -               */ 
#define kcgPLUS         0x9000          /* Control +               */
 
  • #6
welche zeit gibt denn sleep an ?

kannst du mir eine schleife zeigen die genau 1 sekunde wartet ?
:)
 
  • #7
Sleep(1000);

Der Thread wird damit für eine Sekunde angehalten; das ist also keine Schleife, die sinnlos Rechenzeit verbrät. Die Zeit wird in Millisekunden angegeben (1ms = 1/1000 Sekunde). Und, wie gesagt, es handelt sich um eine Windows-Funktion.
 
  • #8
also das mit der zeit habe ich jetzt so hinbekommen:

Code:
int time(void)
{
 time_t zs;
 tm *nun;
 zs = time(0);
 nun = localtime(&zs);
 int minute = nun->tm_min;
 int stunde = nun->tm_hour;
 stunde *= 3600;
 minute *= 60;

 int zeit = stunde + minute + nun->tm_sec;



 return zeit;
}

ich konnte einfach nicht auf meine Sekunden seit Mitternacht verzichten.......

das mit dem Cursorverschieben geht auch ganz gut....

nur das mit der Tasteneingabe funktioniert nicht so ganz......

wenn ich das hier ausführen will meckert mein Compiler rum:


Programm:

Code:
#include <iostream.h>
#include <windows.h>
#include <winuser.h>
#include <conio.h>


using namespace std;

int getkey() {
 const int EXT1= 0, EXT2= 224;
 if(_kbhit()) {
  int input= getch();
  if((input == EXT1) || (input == EXT2))
   input= getch() << 8;
  return input;
 } else
  return kNone;
}


void locate(int x, int y) {
 COORD point;
 point.X = x; point.Y = y;
 SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);

}

int main()
{
 HANDLE hScreenBuf = GetStdHandle(STD_OUTPUT_HANDLE);
 CONSOLE_CURSOR_INFO cci;
 GetConsoleCursorInfo(hScreenBuf, &cci);
 cci.bVisible= FALSE;
 SetConsoleCursorInfo(hScreenBuf, &cci);

 locate(12,12);
 cout << ;
 locate (12,12);
 cout << getkey();

 cin.get();






 return 0;
}


Fehlermeldung:
cursor.cpp: E2451 Undefiniertes Symbol->kNone' in Funktion getkey() in Zeile 17
cursor.cpp: E2268 Aufruf der undefinierten Funktion->_kbhit' in Funktion getkey() in Zeile 11
 
  • #9
cursor.cpp: E2451 Undefiniertes Symbol->kNone' in Funktion getkey() in Zeile 17

Hmm ... oben bei den Definitionen:
#define kNone 0x0000

cursor.cpp: E2268 Aufruf der undefinierten Funktion->_kbhit' in Funktion getkey() in Zeile 11

Dann schau mal nach, ob in Deiner conio.h _kbhit oder kbhit steht.
 
  • #10
ah danke, (in der conio.h stand kbhit statt _kbhit)

so nun habe ich aber noch eine Frage: Wie kann man einzelne Zeichen vom Bildschirm mit C++ (und nicht mit den Augen) einlesen also praktisch etwa so:

int a = getchar(x, y);

x und y sind die Koordinaten des Zeichens , dass ausgelesen werden soll. a ist der ASCII wert des Zeichens.......
 
  • #11
Das sollte so funktionieren ('charToOem' ist optional und hat mit dem Auslesen selbst nichts zu tun):

Code:
char charToOem(char character)
{ 
  char conv[2] = {character,->\0'};
  // Vorsicht: in = out ist nur bei der ANSI-Version erlaubt
  CharToOemA(conv, conv); 
  return conv[0];
}

bool getCharFromConsole(int x, int y, char& character) {
  CHAR_INFO buffer;
  COORD bufferSize = {1, 1};
  COORD bufferCoord = {0, 0};
  SMALL_RECT region = {x, y, x, y};  
  if(ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE), &buffer, bufferSize, bufferCoord, &region ) == 0)
    return false;
  else {
    character = buffer.Char.AsciiChar;
    return true;
  }
}

Falls Du Umlaute etc. ausgeben willst, kannst Du mit charToOem konvertieren.
Zum Ausprobieren (mit vorher leerer Konsole - z.B. von der Entwicklungsumgebung aus -, sonst bekommst Du natürlich kein Ü mit diesen Koordinaten):

Code:
printf(x\232abcdefgh=\n);

char character;
if(getCharFromConsole(1, 0, character)) {
  printf(\n\nGelesen: %c\n\n, charToOem(character));
}
else {
  // Fehler beim Lesen des Zeichens ...
  // Passiert z.B. bei ungültigen Koordinaten
}

Man kann auch ganze Blöcke von Zeichen - bis hin zum gesamten Konsoleninhalt - mit ReadConsoleOutput einlesen bzw. mit WriteConsoleOutput schreiben. Wenn Du (sehr) viele Ein- und Ausgaben hast, z.B. bei einem Spiel, wäre das die bessere Variante. Du kannst dann in ein Array schreiben und alles in einer einzigen Operation ausgeben.
 
  • #12
ersteinmal Danke

aber irgendwie werde ich Anfänger daraus nicht so ganz schlau........


also ein Beispiel:

ich schreibe mit cout das Wort C++ an die Position x=1 , y=1 nun will ich die Koordinate x=1,y=1 auslesen und in einer neuen Zeile ausgeben.

Das Programm müsste dann das hier von sich geben:

C++
C

aber wie maqche ich das?
 
  • #13
cout << C++ << endl;

char character;
if(getCharFromConsole(0, 0, character)) {
  cout << character << endl;   
}

Ich habe jetzt mal 0, 0 genommen, also das erste Zeichen links oben. Wenn Du das Programm von Hand in einem Konsolenfenster startest, siehst Du natürlich nicht C, sondern etwas anderes. Hier z.B. das S von Setting:

cons.gif


Das meinte ich oben.

// Nachtrag

Falls es Dich irritiert hat, dass das Zeichen nicht als normaler Rückgabeparameter geliefert wird:

bool getCharFromConsole(int x, int y, char& character)

character ist eine Referenz, darum kann der Wert in der Funktion verändert werden. Am Rückgabeparameter (bool) kannst Du erkennen, ob das Auslesen geklappt hat. So kannst Du dann einfach schreiben

if(getCharFromConsole(...))
  ...

BTW: Dass die Variable auch character heisst, ist nur Zufall und hat nichts mit der Referenz zu tun; Du kannst auch einen anderen Namen beim Aufruf verwenden.
 
  • #14
ach so.... jetzt verstehe ich das erst mit dem Zeichenauslesen...... naja ich baue mir am liebsten Funktionen , die ich so schreibe , dass ich sie wie befehle in Basic verwenden kann und nenne sie dann so wie den Basicbefehl.... dann muss ich nicht soviel umdenken ;D

naja ich wollte so eine Art Pacman schreiben.... hier mein zwischenstand... aber wehe du schreibst für mich einen Gegner!!!!!! sonst ist ja der ganze Reiz der Sache weg :2funny: :2funny:


Code:
#include <iostream.h>
#include <windows.h>
#include <winuser.h>
#include <conio.h>
#include <time.h>
#include <stdio.h>
#include <string.h>


using namespace std;

HANDLE hStdout;



void level()
{
 cout << endl << ###################################;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOO*OOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << #OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO#;
 cout << endl << ###################################;
}

void color(int x, int y)
{

 hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
 SetConsoleTextAttribute(hStdout, x | y);
}


void cursor()
{
 HANDLE hScreenBuf = GetStdHandle(STD_OUTPUT_HANDLE);
 CONSOLE_CURSOR_INFO cci;
 GetConsoleCursorInfo(hScreenBuf, &cci);
 cci.bVisible= FALSE;
 SetConsoleCursorInfo(hScreenBuf, &cci);
}


void locate(int y, int x)
{
 COORD point;
 point.X = x; point.Y = y;
 SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);
}



char screen(int y, int x)
{
 char character;
 CHAR_INFO buffer;
 COORD bufferSize = {1, 1};
 COORD bufferCoord = {0, 0};
 SMALL_RECT region = {x, y, x, y};

 ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE), &buffer, bufferSize, bufferCoord, &region);
 character = buffer.Char.AsciiChar;

 return character;

}

int getkey() {
 const int EXT1= 0, EXT2= 224;
 if(kbhit()) {
  int input= getch();
  if((input == EXT1) || (input == EXT2))
   input= getch() << 8;
  return input;
 } else
  return 0;
}


class pos
{
 public:

 int x;
 int y;
 int point;

 void ausgabe()
 {

  locate(y,x);
  cout << @;
  locate(30,10);
  cout << point;
 }

 int gehe()
 {
  int taste = 0;
  while (taste == 0)
  {
   taste = getkey();
  }

  if (taste == 0x4800)
  {
   y--;
   char z = screen(y,x);
   if (z ==->#')
   {
    y++;
   }
   if (z ==->O')
   {
    point++;
   }

  }
  if (taste == 0x5000)
  {
   y++;
   char z = screen(y,x);
   if (z ==->#')
   {
    y--;
   }
   if (z ==->O')
   {
    point++;
   }


  }
  if (taste == 0x4b00)
  {
   x--;
   char z = screen(y,x);
   if (z ==->#')
   {
    x++;
   }
   if (z ==->O')
   {
    point++;
   }


  }
  if (taste == 0x4d00)
  {
   x++;
   char z = screen(y,x);
   if (z ==->#')
   {
    x--;
   }
   if (z ==->O')
   {
    point++;
   }


  }
  return taste;
 }

 void clear()
 {
  point=0;
  x=10;
  y=10;
 }

 void check()
 {
  char z =->->;

  z = screen(y - 1,x);
  if ( z ==->@')
  {
   locate(y - 1,x);
   cout <<  ;
  }

  z = screen(y + 1,x);
  if ( z ==->@')
  {
   locate(y + 1,x);
   cout <<  ;
  }

  z = screen(y,x - 1);
  if ( z ==->@')
  {
   locate(y,x - 1);
   cout <<  ;
  }

 z = screen(y,x + 1);
  if ( z ==->@')
  {
   locate(y,x + 1);
   cout <<  ;
  }
 }



};

int main()
{
 cursor();
 level();

 pos I;

 I.clear();
 I.ausgabe();
 int esc = 0;
 while(esc != 0x001b)
 {
  esc = I.gehe();
  I.ausgabe();
  I.check();
 }
 return 0;
}
 
  • #15
ich konnte einfach nicht auf meine Sekunden seit Mitternacht verzichten.......
Solltest Du aber! Denn wenn während der Wartezeit zufällig der nächste Tag beginnt, hängt sich Dein Programm für immer auf! Das ist Murks!
 
  • #16
gibt es in C++ eine Möglichkeit alle Zeichen auf dem Bildschirm zu löschen (Clear Screen oder CLS)
 
  • #17
Game12 schrieb:
gibt es in C++ eine Möglichkeit alle Zeichen auf dem Bildschirm zu löschen (Clear Screen oder CLS)

Nein, das ist ja (wie die anderen Funktionen hier: Zeichen an vorgegebenen Positionen einlesen, Cursor positionieren etc.) systemspezifisch. Aber Du kannst über die (oder das) Win-API den Inhalt eines Konsolenfensters löschen:

Code:
bool clrscr()
{
  CONSOLE_SCREEN_BUFFER_INFO csbi;
  COORD	startCoord = {0, 0};
  DWORD	dummy;

  HANDLE hCon = GetStdHandle(STD_OUTPUT_HANDLE);
  GetConsoleScreenBufferInfo(hCon, &csbi);

  return FillConsoleOutputCharacter(hCon,->->, csbi.dwSize.X * csbi.dwSize.Y, startCoord, &dummy) != 0;
}

Danach musst Du u.U. den Cursor wieder positionieren.
 
Thema:

C++ - TIME

ANGEBOTE & SPONSOREN

Statistik des Forums

Themen
113.838
Beiträge
707.961
Mitglieder
51.491
Neuestes Mitglied
haraldmuc
Oben