C היא אחת משפות התכנות הישנות יותר. הוא פותח בשנות ה -70, אך הוא עדיין חזק מאוד הודות לרמתו הנמוכה. לימוד C היא דרך מצוינת להכיר את עצמך גם לשפות מורכבות יותר, והידע שתצבור יהיה שימושי כמעט בכל שפת תכנות ויכול לעזור לך להיכנס לפיתוח אפליקציות. כדי ללמוד כיצד להתחיל לתכנת ב- C, ראה שלב 1 להלן.
צעדים
חלק 1 מתוך 6: הכנה
שלב 1. הורד והתקן מהדר
צריך לגבש קוד C על ידי תוכנית שמפרשת את הקוד לאותות שהמכונה יכולה להבין. המהדרים בדרך כלל בחינם, ומהדרים שונים זמינים עבור מערכות הפעלה שונות.
- עבור Windows, נסה את Microsoft Visual Studio Express או MinGW.
- עבור Mac, XCode הוא אחד ממהדרי ה- C הטובים ביותר.
- עבור לינוקס, gcc היא אחת האפשרויות הפופולריות ביותר.
שלב 2. להבין את היסודות
C היא אחת משפות התכנות הישנות יותר, ויכולה להיות חזקה מאוד. הוא תוכנן עבור מערכות הפעלה Unix, אך הועבר והורחב כמעט לכל מערכות ההפעלה. הגרסה המודרנית של C היא C ++.
C מורכב בעצם מפונקציות, ובפונקציות אלה אתה יכול להשתמש במשתנים, הצהרות מותנות, לולאות לאחסון ולתפעל של נתונים
שלב 3. בחן קוד בסיסי כלשהו
תסתכל על התוכנית הבסיסית (מאוד) להלן כדי לקבל מושג טוב כיצד כמה מההיבטים השונים של השפה פועלים יחד, וכדי לקבל מושג כיצד תוכניות פועלות.
#include int main () {printf ("שלום, עולם! / n"); getchar (); החזר 0; }
- הפקודה #include מתרחשת לפני תחילת התוכנית, וטוענת ספריות המכילות את הפונקציות הדרושות לכם. בדוגמה זו, stdio.h מאפשר לנו להשתמש בפונקציות printf () ו- getchar ().
- הפקודה int main () אומרת למהדר שהתוכנית מריצה את הפונקציה שנקראת "main" ושהיא תחזיר מספר שלם בסיומה. כל תוכניות C מפעילות פונקציה "ראשית".
- ה {} מציינים שכל מה שבתוכם הוא חלק מהפונקציה. במקרה זה, הם מציינים כי כל מה שבפנים הוא חלק מהפונקציה "הראשית".
- הפונקציה printf () מציגה את תוכן הסוגריים על מסך המשתמש. הציטוטים מבטיחים שהמחרוזת בפנים תודפס מילולית. רצף / n אומר למהדר להעביר את הסמן לשורה הבאה.
- ה; מציין את סוף השורה. רוב שורות קוד C צריכות להסתיים בפסיק.
- הפקודה getchar () אומרת למהדר לחכות לקלט הקשה לפני שהוא ממשיך הלאה. זה שימושי מכיוון שמהדרים רבים יפעילו את התוכנית ויסגרו מיד את החלון. זה מונע מהתוכנית לסיים עד ללחיצה על מקש.
- הפקודה return 0 מציינת את סיום הפונקציה. שימו לב כיצד הפונקציה "הראשית" היא פונקציית int. המשמעות היא שהיא תצטרך להחזיר מספר שלם לאחר סיום התוכנית. "0" מציין שהתוכנית ביצעה נכון; כל מספר אחר אומר שהתוכנית נתקלה בשגיאה.
שלב 4. נסה לאסוף את התוכנית
הזן את הקוד בעורך הקוד ושמור אותו כקובץ "*.c". הידור אותו במהדר שלך, בדרך כלל על ידי לחיצה על הלחצן Build or Run.
שלב 5. תמיד הגיב על הקוד שלך
הערות הן חלק מהקוד שאינו נערך, אך מאפשר לך להסביר מה קורה. זה שימושי כדי להזכיר לעצמך למה נועד הקוד שלך ולעזור למפתחים אחרים שעשויים להסתכל על הקוד שלך.
- להגיב במקום C / * בתחילת ההערה ו * / בסוף.
- הגיבו על כל החלקים הבסיסיים ביותר בקוד שלכם למעט החלקים הבסיסיים ביותר.
- ניתן להשתמש בהערות להסרת חלקים מהקוד שלך במהירות מבלי למחוק אותם. כל שעליך לעשות הוא לצרף את הקוד שברצונך לא לכלול בתגי הערה ולאחר מכן הידור. אם אתה רוצה להוסיף את הקוד בחזרה, הסר את התגים.
חלק 2 מתוך 6: שימוש במשתנים
שלב 1. להבין את הפונקציה של משתנים
משתנים מאפשרים לך לאחסן נתונים, בין אם מדובר בחישובים בתוכנית או מתוך קלט משתמשים. יש להגדיר משתנים לפני שתוכל להשתמש בהם, וישנם מספר סוגים לבחירה.
כמה מסוגי המשתנים הנפוצים יותר כוללים int, char ו- float. כל אחת מאחסנת נתונים מסוג אחר
שלב 2. למד כיצד הכרזת משתנים
צריך להקים משתנים, או "להכריז עליהם", לפני שהתוכנית תוכל להשתמש בהם. אתה מצהיר על משתנה על ידי הזנת סוג הנתונים ואחריו שם המשתנה. לדוגמה, להלן הצהרות משתנות תקפות:
לצוף x; שם צ'ארה; int a, b, c, d;
- שים לב שאתה יכול להכריז על מספר משתנים באותה שורה, כל עוד הם מאותו סוג. כל שעליך לעשות הוא להפריד בין שמות המשתנים באמצעות פסיקים.
- כמו שורות רבות ב- C, כל שורת הצהרה משתנה צריכה להסתיים בפסיק.
שלב 3. דע היכן להכריז על משתנים
יש להכריז על משתנים בתחילת כל בלוק קוד (החלקים בקוד שלך המופיעים בתוך {} סוגריים). אם תנסה להכריז על משתנה בהמשך הבלוק, התוכנית לא תפעל כראוי.
שלב 4. השתמש במשתנים לאחסון קלט המשתמש
עכשיו שאתה יודע את היסודות של אופן הפעולה של משתנים, אתה יכול לכתוב תוכנית פשוטה שתאחסן את קלט המשתמש. אתה תשתמש בפונקציה אחרת בתוכנית, הנקראת scanf. פונקציה זו מחפשת את הקלט המסופק לערכים ספציפיים.
#include int main () {int x; printf ("הזן מספר:"); scanf ("%d", & x); printf ("הזנת %d", x); getchar (); החזר 0; }
- מחרוזת "%d" אומרת ל- scanf לחפש מספרים שלמים בקלט המשתמש.
- המשתנה & לפני המשתנה x אומר ל- scanf היכן למצוא את המשתנה כדי לשנות אותו, ומאחסן את המספר השלם במשתנה.
- הפקודה printf האחרונה קוראת את המספר השלם של הקלט למשתמש.
שלב 5. מניפולציה של המשתנים שלך
אתה יכול להשתמש בביטויים מתמטיים כדי לתפעל את הנתונים ששמרת במשתנים שלך. ההבחנה החשובה ביותר שיש לזכור לביטויים מתמטיים היא כי סינגל = קובע את ערך המשתנה, בעוד == משווה את הערכים משני הצדדים כדי לראות אם הם שווים.
x = 3 * 4; / * מגדיר "x" ל -3 * 4, או 12 */ x = x + 3; / * מוסיף 3 לערך המקורי של "x", וקובע את הערך החדש כמשתנה */ x == 15; / * בודק אם "x" שווה ל 15 */ x <10; / * בודק אם הערך של "x" קטן מ- 10 */
חלק 3 מתוך 6: שימוש בהצהרות מותנות
שלב 1. להבין את היסודות של הצהרות מותנות
הצהרות מותנות הן מה שמניע את רוב התוכניות. הם הצהרות שנקבעו שהן אמיתיות או שגויות, ולאחר מכן פועלות על פי התוצאה. הבסיסית ביותר בהצהרות היא הצהרת ה- if.
TRUE ו- FALSE פועלים בצורה שונה ב- C ממה שאולי אתה רגיל אליו. הצהרות אמיתיות תמיד משתוות למספר ללא אפס. כאשר אתה מבצע השוואות, אם התוצאה היא TRUE אז הוחזר "1". אם התוצאה שגויה, מוחזר "0". הבנה זו תעזור לך לראות כיצד מעובדים הצהרות IF
שלב 2. למד את האופרטורים המותנים הבסיסיים
אמירות מותנות סובבות סביב השימוש באופרטורים מתמטיים המשווים ערכים. הרשימה הבאה מכילה את האופרטורים המותנים הנפוצים ביותר.
/* גדול מ* /< /* פחות מ* /> = /* גדול או שווה ל* /<= /* פחות או שווה ל* /== /* שווה ל* /! = /* לא שווה ל */
10> 5 TRUE 6 <15 TRUE 8> = 8 TRUE 4 <= 8 TRUE 3 == 3 TRUE 4! = 5 TRUE
שלב 3. כתוב הצהרת IF בסיסית
תוכל להשתמש בהצהרות IF כדי לקבוע מה התוכנית צריכה לעשות לאחר ההערכה של ההצהרה. תוכל לשלב אותו עם הצהרות מותנות אחרות מאוחר יותר ליצירת אפשרויות מרובות עוצמתיות, אך כתוב לעת עתה אחת פשוטה להתרגל אליהן.
#include int main () {if (3 <5) printf ("3 פחות מ -5"); getchar (); }
שלב 4. השתמש בהצהרות ELSE/ELSE IF כדי להרחיב את התנאים שלך
אתה יכול לבנות על הצהרות IF באמצעות הצהרות ELSE ו- ELSE IF כדי לטפל בתוצאות שונות. הצהרות ELSE פועלות אם הצהרת IF הינה FALSE. הצהרות ELSE IF מאפשרות לך לכלול הצהרות IF מרובות לגוש קוד אחד לטיפול במקרים שונים. עיין בתוכנית לדוגמא למטה כדי לראות כיצד הם מתקשרים.
#include int main () {int age; printf ("אנא הזן את גילך הנוכחי:"); scanf ("%d", וגיל); if (גיל <= 12) {printf ("אתה רק ילד! / n"); } אחרת אם (גיל <20) {printf ("להיות נער זה די נהדר! / n"); } אחרת אם (גיל <40) {printf ("אתה עדיין צעיר בנפשך! / n"); } else {printf ("עם הגיל מגיעה החוכמה. / n"); } החזר 0; }
התוכנית לוקחת את הקלט מהמשתמש ומעבירה אותו דרך הצהרות IF. אם המספר תואם את המשפט הראשון, הצהרת printf הראשונה תחזור. אם הוא אינו מספק את המשפט הראשון, הוא נלקח דרך כל משפט ELSE IF עד שהוא מוצא אחד שעובד. אם הוא אינו תואם לאף אחד מהם, הוא עובר בסוף הצהרת ELSE
חלק 4 מתוך 6: לולאות למידה
שלב 1. להבין כיצד לולאות עובדות
לולאות הן אחד ההיבטים החשובים ביותר בתכנות, מכיוון שהם מאפשרים לך לחזור על בלוקים של קוד עד שיתקיימו תנאים ספציפיים. זה יכול להפוך את הפעולות החוזרות לפשוטות מאוד ליישום, ומונע ממך לכתוב הצהרות מותנות חדשות בכל פעם שאתה רוצה שיקרה משהו.
ישנם שלושה סוגים עיקריים של לולאות: FOR, WHILE ו- DO… WHILE
שלב 2. השתמש בלולאת FOR
זהו סוג הלולאה הנפוץ והשימושי ביותר. היא תמשיך להריץ את הפונקציה עד שיתקיימו התנאים שהוגדרו בלולאת FOR. לולאות FOR דורשות שלושה תנאים: אתחול המשתנה, התנאי שעליו להתקיים ואופן עדכון המשתנה. אם אינך זקוק לכל התנאים הללו, עדיין תצטרך להשאיר רווח ריק עם נקודה -פסיק, אחרת הלולאה תרוץ לנצח.
#include int main () {int y; עבור (y = 0; y <15; y ++;) {printf ("%d / n", y); } getchar (); }
בתוכנית לעיל, y מוגדר ל- 0, והלולאה נמשכת כל עוד הערך של y קטן מ- 15. בכל פעם שהערך של y מודפס, 1 מתווסף לערך y והלולאה חוזרת על עצמה. ברגע y = 15, הלולאה תישבר
שלב 3. השתמש בלולאה של WHILE
בעוד לולאות פשוטות יותר מאשר לולאות. יש להם רק תנאי אחד, והלולאה פועלת כל עוד התנאי הזה נכון. אינך צריך לאתחל או לעדכן את המשתנה, אם כי תוכל לעשות זאת בגוף הראשי של הלולאה.
#include int main () {int y; בעוד (y <= 15) {printf ("%d / n", y); y ++; } getchar (); }
הפקודה y ++ מוסיפה 1 למשתנה y בכל פעם שהלולאה מבוצעת. ברגע ש- y מגיעה ל -16 (זכור, הלולאה הזו נמשכת כל עוד y קטן או שווה ל -15), הלולאה נשברת
שלב 4. השתמש ב- DO
.. בעוד לולאה.
לולאה זו שימושית מאוד עבור לולאות שברצונך להבטיח הפעלה לפחות פעם אחת. בלולאות FOR ו- WHILE המצב נבדק בתחילת הלולאה, כלומר לא יכול לעבור ולהיכשל מיד. DO… WHILE לולאות בודקות את התנאים בסוף הלולאה, ומבטיחות שהלולאה תתבצע לפחות פעם אחת.
#include int main () {int y; y = 5; לעשות {printf ("לולאה זו פועלת! / n"); } בעוד (y! = 5); getchar (); }
- לולאה זו תציג את ההודעה למרות שהתנאי הוא FALSE. המשתנה y מוגדר ל- 5 והלולאה WHILE מוגדרת לפעול כאשר y אינו שווה ל- 5, כך שהלולאה מסתיימת. ההודעה כבר הודפסה מכיוון שהתנאי לא נבדק עד הסוף.
- את הלולאה של WHILE במערכת DO… WHILE יש לסיים בפסיק. זו הפעם היחידה שבה לולאה מסתיימת בפסיק.
חלק 5 מתוך 6: שימוש בפונקציות
שלב 1. הבן את יסודות הפונקציות
פונקציות הן בלוקים של קוד עצמאי שאפשר לקרוא להם על ידי חלקים אחרים של התוכנית. הם מקלים מאוד על חזרה על הקוד והם עוזרים להפוך את התוכנית לפשוטה יותר לקריאה ולשינוי. פונקציות יכולות לכלול את כל הטכניקות שנכתבו בעבר במאמר זה, ואפילו פונקציות אחרות.
- השורה הראשית () בתחילת כל הדוגמאות שלעיל היא פונקציה, וכך גם getchar ()
- פונקציות חיוניות לקוד יעיל וקל לקריאה. השתמש היטב בפונקציות כדי לייעל את התוכנית שלך.
שלב 2. התחל עם מתאר
פונקציות נוצרות בצורה הטובה ביותר כאשר אתה מתאר את מה שאתה רוצה להשיג לפני שתתחיל את הקידוד בפועל. התחביר הבסיסי לפונקציות הוא "שם_החזר (סוג ארגומנט 1, ארגומנט 2 וכו ');". לדוגמה, כדי ליצור פונקציה המוסיפה שני מספרים:
int add (int x, int y);
פעולה זו תיצור פונקציה המוסיפה שני מספרים שלמים (x ו- y) ולאחר מכן מחזירה את הסכום כמספר שלם
שלב 3. הוסף את הפונקציה לתוכנית
אתה יכול להשתמש במתאר כדי ליצור תוכנית שלוקחת שני מספרים שלמים שהמשתמש מזין ואז מוסיפה אותם יחד. התוכנית תגדיר כיצד פועלת הפונקציה "הוסף" ותשתמש בה לתמרן את מספרי הקלט.
#include int add (int x, int y); int main () {int x; int y; printf ("הזן שני מספרים שיש להוסיף יחד:"); scanf ("%d", & x); scanf ("%d", & y); printf ("סכום המספרים שלך הוא %d / n", הוסף (x, y)); getchar (); } int add (int x, int y) {החזר x + y; }
- שים לב שהמתווה עדיין ממוקם בחלק העליון של התוכנית. זה אומר למהדר למה לצפות כאשר הפונקציה נקראת ומה היא תחזיר. זה נחוץ רק אם ברצונך להגדיר את הפונקציה בהמשך התוכנית. תוכל להגדיר add () לפני הפונקציה הראשית () והתוצאה תהיה זהה ללא המתאר.
- הפונקציונליות בפועל של הפונקציה מוגדרת בתחתית התוכנית. הפונקציה הראשית () אוספת את המספרים השלמים מהמשתמש ולאחר מכן שולחת אותם לפונקציה הוסף () לעיבוד. הפונקציה add () ואז מחזירה את התוצאות ל- main ()
- כעת הוגדר ה add (), ניתן לקרוא לה בכל מקום בתוכנית.
חלק 6 מתוך 6: המשך למידה
שלב 1. מצא כמה ספרי תכנות C
מאמר זה עוסק ביסודות, אך הוא רק מגרד את פני השטח של תכנות C ואת כל הידע הנלווה אליו. ספר עיון טוב יעזור לך לפתור בעיות ויחסוך ממך הרבה כאבי ראש בהמשך הדרך.
שלב 2. הצטרף לכמה קהילות
יש הרבה קהילות, הן באינטרנט והן בעולם האמיתי, המוקדשות לתכנות ולכל השפות הכרוכות בכך. מצאו כמה מתכנתים C דומים להחלפת קוד ורעיונות, ובקרוב תגלו את עצמכם לומדים הרבה.
השתתף בכמה פריצות אם אפשר. אלה אירועים שבהם לצוותים ולאנשים יש מגבלות זמן להמציא תוכניות ופתרונות, ולעתים קרובות לטפח הרבה יצירתיות. אתה יכול לפגוש הרבה מתכנתים טובים בדרך זו, והאק-א-טון מתרחשים באופן קבוע ברחבי העולם
שלב 3. קח כמה שיעורים
אתה לא צריך לחזור לבית הספר כדי לקבל תואר במדעי המחשב, אבל השתתפות בכמה שיעורים יכולה לעשות פלאים ללמידה שלך. שום דבר לא מנצח עזרה מעשית מאנשים הבקיאים בשפה. לעתים קרובות אתה יכול למצוא שיעורים במרכזים קהילתיים מקומיים ובמכללות זוטרות, וחלק מהאוניברסיטאות יאפשרו לך לבדוק את תוכניות מדעי המחשב שלהם מבלי להירשם.
שלב 4. שקול ללמוד C ++
ברגע שיש לך הבנה של C, לא יזיק להתחיל להסתכל על C ++. זוהי הגרסה המודרנית יותר של C, ומאפשרת הרבה יותר גמישות. C ++ מתוכנן תוך התחשבות בטיפול באובייקטים, וידיעת C ++ יכולה לאפשר לך ליצור תוכניות עוצמתיות כמעט לכל מערכת הפעלה.
טיפים
- תמיד הוסף הערות לתוכניות שלך. זה לא רק עוזר לאחרים שעשויים להסתכל על קוד המקור שלו, אלא גם שזה עוזר לך לזכור מה אתה כותב ולמה. אתה אולי יודע מה אתה עושה ברגע שאתה כותב את הקוד שלך, אבל אחרי חודשיים -שלושה לא תזכור הרבה.
- זכור תמיד לסיים משפט כגון printf (), scanf (), getch () וכו 'עם חצי נקודה (;) אך לעולם אל תכניס אותם לאחר הצהרות שליטה כמו' אם ',' בעוד 'או' עבור 'לולאות.
- כאשר אתה נתקל בשגיאת תחביר בעת הידור, אם אתה המום, חפש בגוגל (או במנוע חיפוש אחר) עם השגיאה שקיבלת. רוב הסיכויים שמישהו כבר חווה את אותה הבעיה ופרסם פתרון.
- קוד המקור שלך צריך להיות בעל סיומת *.c, כדי שהמהדר שלך יוכל להבין שמדובר בקובץ מקור C.
- זכרו תמיד שתרגול יוצר מושלם. ככל שאתה מתאמן בכתיבת תוכנית, כך אתה מצליח בזה. אז התחל עם תוכניות פשוטות וקצרות עד שתקבל את הרגל שלך, ואז ברגע שאתה בטוח שאתה יכול להמשיך למורכב יותר.
- נסה ללמוד בניית לוגיקה. זה עוזר להתמודד עם בעיות שונות בעת כתיבת קוד.
