מקשי החיצים באסקי?

[SweeT_EviL]

אני לא מוצא איזה מספרים הם(גם ESC).

אם מישהו יכול לעזור...

[CliCK]

UpArrw (00,72) (0x00,0x48)

DnArrw (00,80) (0x00,0x50)

LftArrw (00,75) (0x00,0x4b)

RtArrw (00,77) (0x00,0x4d)

http://www.jimprice.com/jim-asc.shtml

מקווה שזה איכשהו עוזר לך

[TheReaper]

אני מניח שאתה עושה פרוייקט באסמבלר?

אם יש לך את EMU8086 אז מתי שאתה במצב EMU (שאתה מפעיל את התוכנה) אז למטה זה מראה את הASCI של כל מקש שאתה לוחץ (המספרים למטה צריכים לעבור איזה מעבד בסיסים נרלי... אני לא בטוח)

[SweeT_EviL]

את הHEXA ידעתי אבל איך אני משתמש באסקי בC

ככה

X=0072

כשX CHAR

?

ובאסמבלר כבר עשיתי את מה שאני עושה...(סתם משחק להגשה לתחילת יג...)

[TheReaper]

מצטער אבל ממש אין לי מושג בC....

[SweeT_EviL]

בקשר לSWITCH CASE בC

אחרי זה

case x:

אני יכול לתת אנטר ורשום בלוק פקודות? צריך }{ ?

וכמובן מה לעשות עם מקשי החיצים והESC (מספיק אחד ואני ידע כבר מה לעשות...).

[Ghosthunter]

בSWITCH לא צריך בלוק לכל CASE

switch(a)
{
case 1: hello();
    break;
case 2: bello();
}

[SweeT_EviL]

סבבה ובקשר לחצים?

עריכה:

מצאתי מה לעשות, מה שנקלט זה בעצם 2 תווים - NULL ואות(אחרי זה פירוט) ולפי זה בניתי את זה:

c1 = getch();
  if (c1 != '\0')
  {
      // whatever
  }
  else
  {
    c2 = getch();
    switch(c2)
    {
        // whatever
    }
  }
}

עוד לא הרצתי בדיקה D= אבל בעיקרון מה שצריך לעשות. הקטע של הGETCH השני הוא שהוא ישר מעביר את האות שמסמלת את הכיוון - המחשב לא מחכה לקלט! (נזכרתי בזה בגלל שככה זה באסמבלר..)

בקשר לאותויות(חייב גדול):

H-UP

P-DOWN

K-LEFT

M- RIGHT

תגידו C/C++ זה CASE SENSITIVE ?

[Ghosthunter]

אה.. חשבתי שענו לך.

תבדוק למה הערך האסקי שלהם בדצימאלי שווה, ואז תשתמש בSWITCH.

אתה יכול לרשום מייד אחרי האינקלודים:

#define name value

כדי שזה יהייה יותר נוח לקריאה.

משהו כזה בסך הכל(סתם שמתי ערכים):

#define ESC_KEY 33
#define RIGHT_KEY 3
#define LEFT_KEY 17

....
....

switch(input)
{
case ESC_KEY: bla();
  break;
case RIGHT_KEY: bla2();
    bla3();
    break;
case LEFT_KEY: bla4();
}

[SweeT_EviL]

כן, לא...

בכל אופן סתקל בעריכה...

עריכה:

ואם כבר אנחנו פה

יש איזה קומפיילר מחליף לTC (בורלנד) שיהיה נוח לתכנת בו? מסתבר שאני כן צריך לעבוד בבורלנד ולא בVC...

[Ghosthunter]

סביבת הפיתוח הכי קרובה לBC(ממה שאני מכיר) היא dev-c.

חלק מהפונקציות שאתה עומד להשתמש בהן נמצאות שם, כך לא הכל. הפונ delay למשל, לא נמצאת, ולכן תצטרך להשתמש בפונקציה אחרת(Sleep למשל).

כדי לשמור על התאימות תוכל לרשום למעלה:

#define delay(x) Sleep(x)

כדי שהקוד יהייה זהה. נראה לי שגם הפונקציה window לא קיימת שם.

[SweeT_EviL]

תודה.

נמשיך בשאלות

1. אני יכול בתוך הSWITCH לשים IF לפני הCASE?

משהו כזה

switch (x)
{
	if(x=y)
		case x: x; break;
	case y: y; break;

}

אם X=Y אז הוא יבדוק את הCASE ואם כן אחרי זה יצא מהSWITCH או ימשיך כמובן...

2. FLUSHALL או איך שלא רושמים את זה, מנקה את כל הCHARים בפונקציה או את כל המשתנים בפונקציה?(או בכלל בכל התוכנית?)

3. אני יכול לרשום ביטוי כזה:

if (x>y) : x--; y--; and more;

[שניצל]

1. לא. חוץ מזה, אתה חייב לשים ב-case ערכים קבועים. כלומר משהו כזה לא יעבוד:

int x;
int y;
int z;

switch(x)
{
 case y:
  // do something
  break;
 case z:
  // do something else
  break;
}

אבל משהו כזה כן:

int x;

switch(x)
{
 case 1:
  // do something
  break;
 case 2:
  // do something else
  break;
}

2. הפונקציה flushall פשוט מאפסת את כל הבאפרים/סטרימים הפתוחים, לא משנה איפה אתה בתכנית.

http://msdn2.microsoft.com/en-us/library/s9xk9ehd(VS.80).aspx

3. מה זה אמור לעשות? ממתי אפשר לשים נקודתיים אחרי if? אם אתה רוצה לבצע כמה הוראות ב-if, תשתמש ב-{} ככה:

if (x>y)
{
  x--;
  y--;
  // do more
}

וזה נכון לכל קיבוץ כלשהו של הוראות (ב-if, while, פונקציה...).

[SweeT_EviL]

בקשר ל3, הכוונה שלי אם יש דרך לרשום כמה פקודות בשורה אחת...(בתנאי IF), כמו שבCASE אפשר לרשום ככה:

case x: y++; x++; break;

[שניצל]

ב- c++ אין (כמעט) משמעות לירידות שורה. את הקוד הזה:

if (x>y)
{
 x--;
 y--;
}

אפשר לכתוב גם ככה:

if (x>y) { x--; y--; } 

וזה יהיה זהה לחלוטין, אבל זה פחות יפה וקריא. וכמו שאמרתי, אי אפשר להשתמש בנקודתיים אחרי if.

נקודתיים הן רק בשביל switch/case, ועוד שני שימושים שאולי תלמד עליהם בעתיד (goto ואופרטור :? )

שים לב שהקוד הבא לא יעבוד באותה צורה:

if (x>y) x--; y--;

הקוד הזה שקול לקוד הבא:

if (x>y)
{
 x--;
}
y--;

ולא יעשה מה שרצית.