דף נוסחאות מורחב - מבוא לתכנות C

0. הקדמה (Preprocessor)

פקודות המתחילות ב-# מטופלות לפני הקומפילציה.

#include <stdio.h> // ייבוא ספריית הקלט/פלט הסטנדרטית
#include <stdlib.h> // הקצאות זיכרון, רנדום וכו'

// #define: החלפה טקסטואלית ("העתק-הדבק") לפני הריצה
#define SIZE 10     // בכל מקום שכתוב SIZE, המחשב יראה 10
#define PI 3.14

int main() {
    int arr[SIZE];  // הקומפיילר רואה: int arr[10];
    return 0;
}

1. יסודות, פלט (printf) וקלט

תיאור	Specifier (%)	סימן מקדים (scanf)	הערה
שלם (int)	%d	&
תו (char)	%c	&
עשרוני (float)	%f	&	הדפסה: %.2f
עשרוני בגודל כפול (double)	%lf	&	הדפסה: %.2lf
מחרוזת	%s	ללא	חובה לציין גודל!
כתובת	%p	-

\n	ירידת שורה (New Line)
\t	טאב (Tab)
\"	הדפסת גרשיים
\\	הדפסת לוכסן
%%	הדפסת אחוז

i++, ++i	הגדלה ב-1 (פוסט/פרה)	x += 5	x = x + 5
i--, --i	הקטנה ב-1 (פוסט/פרה)	x *= 2	x = x * 2
x %= 3	שארית	x /= 2	x = x / 2

דוגמת הדפסה (printf):

int age = 20; float avg = 95.5;
// שימוש ב-\n ודיוק עשרוני:
printf("Age: %d\nAverage: %.1f%%\n", age, avg);
// פלט:
// Age: 20
// Average: 95.5%

קליטה בטוחה (Visual Studio):

int x; char str[20];
scanf_s("%d", &x);
// במחרוזת חובה לציין גודל:
scanf_s("%s", str, (unsigned)sizeof(str));

Casting & Arithmetic:

int a = 5, b = 2;
float r1 = a / b;          // = 2.0 (טעות!)
float r2 = (float)a / b;  // = 2.5 (תקין)
int mod = 10 % 3;          // = 1 (שארית)

2. תנאים (Conditions)

אופרטורים לוגיים:

&&

וגם (AND)

||

או (OR)

!=

שלילה

משתנה בוליאני (stdbool.h):

#include <stdbool.h>
bool flag = true;
if (flag == false) { ... }

מבנה if-else:

if (x > 0 && x < 10) { /* תנאי */ } 
else if (x == 0) { /* אחרת... */ } 
else { /* ברירת מחדל */ }

3. לולאות (Loops)

// For:
for (int i=0; i<10; i++) {
    if (i==5) continue;
    if (i==8) break;
}

// While: עם פעולה בתוך התנאי
int num;
// קולט מספר כל עוד הקלט הצליח
while (scanf_s("%d", &num) == 1) {
    printf("Read: %d\n", num);
}

// Do-While (נקודה פסיק בסוף!)
do {
    scanf_s("%d", &num);
} while (num < 0);

4. פונקציות ומצביעים

מילון מצביעים:

פקודה	משמעות
int *p;	הצהרה (p יכיל כתובת)
p = &x;	הכנסת הכתובת של x לתוך p
*p = 10;	שינוי הערך בתא המוצבע
printf("%p", p);	מדפיס את הכתובת ש-p מכיל
printf("%p", &p);	מדפיס את הכתובת של p עצמו
printf("%d", *p);	מדפיס את הערך (Dereference)

העברה By Ref:

void func2(int *x) { *x = 10; } // משנה מקור
int main() { int num=5; func2(&num); }

מצביע לפונקציה (Pointer to Function):

// 1. הגדרת פונקציה רגילה
int add(int a, int b) { return a + b; }
// 2. הגדרת מצביע לפונקציה
int (*func_ptr)(int, int);
// 3. השמה ושימוש
func_ptr = add; 
int res = func_ptr(5, 3); // הפעלה דרך המצביע

החזרת ערכים (דוגמת calc):

void calc(int a, int *sum, int *diff) {
    *sum = a + 5;  // כתיבה לכתובת
    *diff = a - 5;
}

5. מערכים ומחרוזות (Safe)

char str[100];
printf("Enter sentence: ");

// (לאן לקלוט, גודל מקסימלי, מאיפה - stdin)
fgets(str, sizeof(str), stdin);

// fgets קולטת גם את האנטר (\n). כך מסירים אותו:
str[strcspn(str, "\n")] = 0;

int mat[2][3] = {{1, 2, 3}, {4, 5, 6}};

אלגוריתם מטריצה: חובה לציין עמודות!

void initMatrix(int mat[][3], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            mat[i][j] = 0;
            printf("%d ", mat[i][j]);
        }
        printf("\n");
    }
}

char src[]="Hello"; char dst[20];
strlen(src);       // אורך נטו (ללא \0)

// העתקה בטוחה: (יעד, גודל יעד, מקור)
strcpy_s(dst, sizeof(dst), src); 

strcmp(s1, s2);    // 0 אם שווים!

// שרשור בטוח:
strcat_s(dst, sizeof(dst), " World");

6. ניהול זיכרון דינמי (stdlib.h)

// 1. הקצאת מערך
int *arr = (int*)malloc(size * sizeof(int));
if (arr == NULL) exit(1);

// 2. אתחול לאפסים
int *arr2 = (int*)calloc(size, sizeof(int));

// 3. שינוי גודל (realloc)
int *tmp = (int*)realloc(arr, new_size);
if (tmp != NULL) arr = tmp;

// 4. שחרור
free(arr);

מערך דו-ממדי דינמי:

// א. הקצאת שורות
int **mat = (int**)malloc(rows * sizeof(int*));
for(int i=0; i<rows; i++) {
    // ב. הקצאת עמודות
    mat[i] = (int*)malloc(cols * sizeof(int));
}
// ג. שחרור (בסדר הפוך!)
for(int i=0; i<rows; i++) free(mat[i]);
free(mat);

7. מערך דו-ממדי כשטוח (Flattened 2D Array)

גישה למטריצה שהוקצתה ב-malloc אחד גדול:

עבור מטריצה עם rows שורות ו-cols עמודות, הגישה לתא בשורה $i$ ועמודה $j$ תתבצע כך:
arr[i * cols + j]

דוגמת קוד קצרה:

int *arr = (int *)malloc(rows * cols * sizeof(int));
// Accessing element at (i, j):
arr[i * cols + j] = 5;

8. מבנים ואיגודים (Struct & Union)

typedef struct { 
    char name[50]; 
    float avg; 
} Student;

דוגמה מעשית ל-Union בתוך Struct:

typedef union { 
    int id_num; 
    float salary; 
} Data;

typedef struct {
    int type; // 0 for ID, 1 for Salary
    Data info; // ה-Union יושב כאן
} Record;

void printRecord(Record r) {
    if (r.type == 0) printf("ID: %d", r.info.id_num);
    else printf("Salary: %.2f", r.info.salary);
}

// שימוש:
Record r1;
r1.type = 1;
r1.info.salary = 5000.5; // כתיבה ל-Union

9. קבצים (Files)

מצבי פתיחה:

מצב	תיאור
"r"	קריאה בלבד
"w"	כתיבה (דורס תוכן קיים!)
"a"	הוספה (כותב לסוף הקובץ)

פונקציות עיקריות (Safe):

פונקציה	תיאור
fopen_s	(&fp, name, mode)
fscanf_s	קריאה מקובץ (כמו scanf_s)
fgets	קריאת שורה (כולל רווחים)
fprintf	כתיבה לקובץ (כמו printf)
fclose	סגירת קובץ (חובה!)

FILE *fp;// פתיחה בטוחה
fopen_s(&fp, "file.txt", "r");
if (fp == NULL) printf("Error");

// אפשרות א': קריאה מפורמטת (כמו scanf)
int num;
while (fscanf_s(fp, " %d", &num) != EOF) {
    printf("%d\n", num);
}

// אפשרות ב': קריאת שורות (fgets)
char line[100];
// קריאה עד סוף הקובץ (NULL)
while (fgets(line, sizeof(line), fp) != NULL) {
    printf("%s", line);
}

fprintf(fp, "Result: %d", num); // כתיבה
fclose(fp); // חובה!

10. אלגוריתמים שימושיים

מיון בועות (Bubble Sort):

void bubbleSort(int arr[], int n) {
  for (int i = 0; i < n-1; i++)
    for (int j = 0; j < n-i-1; j++)
      if (arr[j] > arr[j+1]) {
         int temp = arr[j];
         arr[j] = arr[j+1];
         arr[j+1] = temp;
      }
}

חיפוש בינארי (Binary Search):

int binarySearch(int arr[], int n, int x) {
    int l = 0, r = n - 1;
    while (l <= r) {
        int m = l + (r - l) / 2;
        if (arr[m] == x) return m;
        if (arr[m] < x) l = m + 1;
        else r = m - 1;
    }
    return -1;
}