* מההתחלה C *

המדריך השלם

משתנים

משתנה הוא מקום מוגדר בזיכרון היכול להכיל ערך מטיפוס מסוים כאשר סוג הטיפוס מוגדר בהצהרה על המשתנה. לכל משתנה יש שם ייחודי וערך אחד מוגדר. משתנה מאחסן נתונים וערכו יכול להיקבע ולהשתנות על ידי המתכנת (כשמו כן הוא). על המשתנים חייבים להצהיר מראש (ובכך מקצים זיכרון -נפח הזיכרון נמדד ב bytes).

דוגמא להצהרה על משתנה:
;int x
המשתנה הוא ,x מטיפוס int (שלם).

בהגדרת המשתנים חשוב (אין זו חובה אך מומלץ ביותר) להשתמש בשמות משמעותיים על מנת שהתוכנית שלנו תהיה קריאה ומובנית. נראה מספר דוגמאות: נניח כי התוכנית שלנו סוכמת את המספרים מ 1 עד 10, אזי נגדיר משתנה ושמו sum. ברור כעת שמשתנה זה יכיל בסיום התוכנית את הסכום של המספרים שסוכמו. או לדוגמא - תוכנית הקולטת שמות סטודנטים וציונם, אזי נגדיר שני משתנים הראשון name לצורך שמירת שמו של הסטודנט ו-grade לצורך שמירת ציונו.

הערה: שם המשתנה מוגבל בדרך כלל עד 32 תווים. כך שאם נצהיר על משתנה עם 42 תווים המהדר יתעלם מעשרת התווים האחרונים.

הערה: הקומפיילר של c רגיש לשינויים בגודל האות כך שמשתנה ששמו name, Name, NAME - הם למעשה שלושה משתנים ולא אחד ולכן יש להקפיד על סגנון כתיבת המשתנים .

בלוק - סדרת פקודות המופיעות בתוך סוגריים מסולסלים {a1;a2; ….,an;} כאשר a1,a2,…,an פקודות בשפה.

מקום הגדרת המשתנים

ניתן להגדיר משתנים מחוץ לפונקציות או בתחילתו של בלוק כאשר מצהירים על משתנים. בבלוק ההצהרה חייבת להתבצע בתחילת הבלוק ולפני כל הוראה אחרת כלומר אם קיימת פקודה כמו ()clrscr לפניי הצהרת המשתנים המהדר יתריע על קיומה של טעות . כמו כן טווח ההכרה של משתנים אלו הוא בבלוק בלבד.

משתנים נחלקים לשני סוגים:
משתנים גלובליים ומשתנים לוקאליים.

משתנים גלובליים: משתנים המוצהרים מחוץ לפונקציה, מהווים משתנים גלובליים ביחס לפונקציה זו (מכיוון שעדיין לא דיברנו על פונקציות ב- c, משתנים גלובליים לעת עתה בעבורנו הם משתנים שהצהרתם היא מחוץ ל main() ). כל הפונקציות שבאות אחרי ההצהרה מכירות את המשתנים הללו, כלומר משתנה המוצהר מחוץ לפונקציה והוא מוכר על ידי הפונקציות המוגדרות לאחר הצהרתו ועד סוף התוכנית.

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

במקום להראות מימוש של משתנים דרך פונקציות נוכל להמחיש זאת על ידי שימוש בבלוקים.

התייחסותם של המשתנים כלפי פונקציות זהה לגבי בלוקים כלומר משתנה המוצהר מחוץ לבלוק מהווה משתנה גלובלי ביחס אליו, לעומת זאת משתנה המוצהר בתוך הבלוק מהווה משתנה לוקאלי ביחס אליו.

כדי להציג את ערך המשתנים על גבי המסך יש צורך בהמרה כלומר בתוך המחרוזת לא נרשום את שם המשתנה (לדוגמא int a=7שם המשתנה הוא a וערכו 7).

סוגי משתנים

char - משתנה לאחסון תווים או סמלים , תופס בית אחד בזיכרון ,ניתן לאחסן בו ערכים מספריים שלמים מ -128 עד +127 תווים וסימנים הם כל האותיות, סימני פיסוק או סימונים אחרים שניתן להפיק ל ידי המחשב.

int - משתנה לאחסון מספר שלם.תופס שני בתים בזיכרון ניתן לאחסן בו ערכים שלמים מ -32768 עד +32767.

float - משתנה של מספרים ממשיים עד 6 ספרות דיוק (מאוחסנים בשיטת נקודה צפה) המשנה תופס ארבעה בתים בזיכרון

double - משמש לאחסון ערכים ממשים בתחומים גדולים יותר, עד 10 ספרות דיוק ,תופס שמונה בתים בזיכרון.

long - ניתן לאחסן בו ערכים שלמים בטווח גדול יותר מ int תופס ארבעה בתים בזיכרון.

sing/unsing- כל משתנה מספרי ניתן להגדיר כ sing (עם סימן +/-( או unsing(ללא סימן) כאשר sing מציין אחסון של מספרים שלילים וחיוביים ואילו unsing מציין אחסונם של מספריים אי שליליים ,כתוצאה מהגדרת משתנה כ unsing טווח החיוביים שלו גדל .
לדוגמא sing char ניתן לאחסן ערכים מהטווח (-128 +127) לעומת זאת אם הגדרנו את המשתנה כ unsing char ניתן לאחסן בו ערכים מהטווח (0 255).
ברירת המחדל מגדירה משתנה אוטומטית כ sing.

שמות חוקיים למשתנים

יש להקנות שם ייחודי לכל משתנה ובכך אנו למעשה מאפשרים לאחסן בתא מסוים בזיכרון ערך וגם נוכל לפנות אל תא זה על מנת לקרוא ממנו את הערך.
לא ניתן לקרוא למשתנה בכל אופן שעולה על רוחנו אלא ישנם חוקים לשמות משתנים הללו חייבים להתחיל באות או בקו תחתי (אך מומלץ להשתמש האותיות בלבד) כמו כן לא נוכל להקנות שמות שמוגדרים כמילים שמורות כמו else if int וכו.
שאר תווי שם המשתנה יכולים להיות מספרים, אותיות וקו תחתי אך יש להקפיד לא לכלול סימנים נוספים כגון נקודה, פסיק ורווח.

טבלת הטיפוסים

טיפוס	מספר בתים	תחום המספרים
char, signed char	1	128 - 127+
unsigned char	1	0 - 255+
int ,sign int	2	32767+ 32768-
unsign int	2	65535+ 0
long,long int,signed long int	4	2147483647+ 2147483648-
unsigned long,unsigned long int	4	4294967295+ 0
float (7 ספרות דיוק)	4	3.4e+38 3.4e-38
double (15 ספרות דיוק)	8	1.7e+308 1.7e+308
long double (19 ספרות דיוק)	10	3.4e+4932 3.4e4932

הערה: בהצהרה על משתנה יש לרשום את טיפוס המשתנה ואחר כך את שמו כאשר חייב להיות רווח אחד לפחות בניהם (ניתן לכתוב מספר רווחים אך אין בכך הבדל).
כאשר ישנם מספר משתנים בעלי אותו טיפוס ניתן להצהיר עליהם באשר נכתוב בראשית את סוג הטיפוס ואחר כך כשפסיקים מפרידים נכתוב את שמות המשתנים לדוגמא:
int sum, age, num_of_students.
אם מעוניים ששמות המשתנים יהיו מטיפוס sing אין צורך להצהיר בתוספת המילה השמורה sing מכיוון שזהו ברירת המחדל.(ולכן אם נרצה שהמשתנה יהי unsing יש להצהיר על כך).

השמת ערכים ואתחול משתנים

כאשר מצהירים על משתנה חדש ערכו לא ידוע. הוא יכול להכיל ערך שנקבע לו בתוכנית הקודמת או אפס או כל ערך אחר ולכן כדי לבצע השמה של ערך במשתנה משתמשים באופרטור השוויון. לדוגמא - אם נרצה לתת למשתנה ששמו grade את הערך 100 נרשום:
;grade = 100

דוגמא 1:

#include <stdio.h>

void main()
{
}

העבר את העכבר מעל הדוגמא כדי לראות הסבר מפורט

מפני שהפקודה תקרא את שם המשתנה כתו ולא תציג את ערכו, הוחלט על תבניות המרה המאפשרות הדפסת משתנים והן:

%d להצגת integer
%f להצגת float
%ld להצגת long
%c להצגת char
%s להצגת string
%lf להצגת double

יש לציין שניתן לקבוע את רוחב השדה, מס' הספרות אחרי הנקודה העשרונית, ישור לימין, לשמאל וכו'.
עד עתה כאשר רצינו להדפיס מספר השתמשנו ב d%. נוסיף את הפרמטרים לקביעת רוחב השדה, ישור ומספר ספרות אחרי הנקודה כדלהלן: כאשר נהיה מעוניינים להדפיס מספר ברוחב 3 ספרות וישור לשמאל נרשום: %d3 אם נהיה מעוניינים בישור לימין (רוחב של 3 ספרות) נרשום - %d3.
כשאר מדובר במספרים ממשיים אזי כדי להדפיס לדוגמא מספר ממשי ברוחב של 12 תווים מתוכם 2 תווים לאחר הנקודה העשרונית נרשום כך: %lf12.2.

תבניות אלה נכתבות בין המרכאות של הפונקציה ()printf אך שמות המשתנים נכתבים מחוץ למרכאות ומופרדים על ידי פסיקים כדלהלן:

: נצהיר על שני משתנים
int a = 1;
int b = 2;
: כעת נדפיס אותם
printf (“Print: a = %d , b = %d”, a,b);

הערה: ניתן להצהיר על מספר משתנים מאותו טיפוס כך:
int/float… a,b,c;
כלומר כתיבת שם הטיפוס ואחר כך כתיבת שמות המשתנים ובניהם פסיקים לדוגמא:
int a, b, c;
המחשת ההבדל בין משתנים לוקאליים לגלובלים.

דוגמא 2:

#include <stdio.h>

void main()
{
    int a = 2;
    int b = 3;
    int sum = a+b;

    printf ("The value of sum is: %d \n\r", sum);
    printf("The value of a+b is: %d \n\r", a+b);

    {
        int local = 4;
        printf("The value of local is: %d \n\r", local);
        printf("The value of sum is: %d \n\r", sum);
        printf("sum is a global variable ");
    }
    printf("But here the variable local is not known");
}

Casting- זוהי המרה יזומה ,כלומר כשאנו מעוניינים לשנות טיפוס יש לרשום את הטיפוס אליו מעוניינים לשנות בסוגריים בדוגמא שלנו (int) ,כמובן שלא ניתן לבצע המרה לטיפוס מסוג אחד לסוג אחר באופן הנ"ל:

int integer = 8;
char c = 'c';
inreger = (float)c;

וזאת מכיוון שהמשתנה integer הוא מטיפוס שלם ולא ניתן להציב בו ערך אחר משלם .
אומנם ניתן להציב את הערך המומר למשתנה אחר מאותו טיפוס.

לדוגמא:

float f ;
f = (float)c;

כאשר נדון באופרטורים נפרט יותר על המרת טיפוסים.

דוגמא 3:

#include <stdio.h>
#include <math.h>

void main()
{
    int a = 2;
    float b = 3.0;

    printf ("The value of a is: %d\n\r", a);
    printf("The value of a+b is: %f\n\r", a+b);
    printf ("The value of b/a is: %f\n\r", b/a); }

העבר את העכבר מעל הדוגמא כדי לראות הסבר מפורט

כעת נרצה לקלוט ערכי משתנים מהמשתמש , הפונקציה לקבלת קלט מהמשתמש היא ()scanf אשר בדומה לפונקציה ()printf היא מקבלת בתוך המירכאות תבניות המרה , ושמות משתנים עם הסימן & לפני (נדון בסימן זה בהרחבה בפרק על מצביעים).

לדוגמא:

int a;
float b;
printf("Enter values for a and b");
scanf("%d %f", &a, &b);

דוגמא 4:

#include <stdio.h>

void main()
{
    int a;
    float b;

    printf("Enter values for a and b: \n\r");
    printf ("The value of a is: %d\n\r", a);
    printf("The value of b is: %f\n\r", b);
    printf("Change the value of a \n\r");
    printf("The new value of a is:%d", a);
}

העבר את העכבר מעל הדוגמא כדי לראות הסבר מפורט

הגדלה עצמית והקטנה עצמית של משתנים

++x :פירושה הגדל את ערך המשתנה x ב -1 ,ועדכן את (x = x+1) x.
--x :פירושה הקטן את ערך המשתנה x ב -1 ,ועדכן את (x = x-1) x.
אך קיימות גם הפעולות x++ ו x-- .

נסביר את ההבדל בין ++x ל x++ על ידי דוגמא:
y=x++ : פירושה y מקבל את הערך הראשוני של x ואח"כ x גדל ב1.
y=++x : פירושה x גדל ב 1 ואח"כ y מקבל את ערכו של x .

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

דוגמאות :

1.

int x,y;
x = 10;
y = x++;
:בסיום קטע הקוד נקבל
x = 9, y = 8.

int x, y, z;
z = 10;
x = z++;
y = ++z;
:בסיום קטע הקוד נקבל
x = 10, y = 12.

דוגמא 5:

#include <stdio.h>

void main()
{
    int a = 10;
    int b = 5;
    int result;

    result = a + b;
    printf("The value of result is: %d\n\r",result);
    result = ++a + b;
    printf("The value of result is: %d\n\r",result);
    result = a + b--;
    printf("The value of result is: %d\n\r",result);
    result = a-- + b;
    printf("The value of result is: %d\n\r",result);
    result = a + --b;
    printf("The value of result is: %d\n\r",result);
    result = ++a + ++b;
    printf("The value of result is: %d\n\r",result);
}

מקרו

מקרו מהווה קטע קוד שאשר במהלך התוכנית אם נקרא למקרו, קטע הקוד שהוגדר כמאקרו "יושתל" בקריאה למקרו.
מגדירים מקרו בהוראה define#.
תבנית למקרו:
#define macro definition
לדוגמא:
#define LENG 10

לפני הידור התוכנית, המהדר יחליף את LENG בכל מקום בתוכנית בערך 10 ואז יהדר את התוכנית.
(נראה שימוש לכך כשנדון במערכים).

הספרייה conio.h

ספריה זו מטפלת במסך - נכיר 2 פונקציות עיקריות.

()clrscr - פונקציה זו תגרום לניקויי של המסך (כאשר מריצים תוכנית המסך נותר עם הפלט של התוכנית ואם נריץ תוכנית נוספת ללא ניקויי של המסך נראה את הפלט של התוכנית הקודמת בריצתה של התוכנית החדשה ולכן לפני הרצת תוכנית נשתמש לרב בפונקציה זו).

gotoxy (x,y) - המסך מחולק ל 80 עמודות ו 25 שורות, פונקציה זו מאפשרת להעברת הסמן לכל מקום על פני המסך.

דוגמא 6:

#include <conio.h>
#include <stdio.h>

void main()
{
    clrscr();
    gotoxy(35, 15);
    cprintf(" * ");
    gotoxy(35, 16);
    cprintf(" *** ");
    gotoxy(35, 17);
    cprintf(" ****** ");
    gotoxy(35, 18);
    cprintf("******** ");
}

מבחן