توثيق لغة البرمجة C

if (شرط) {
    // الكود الذي سيتم تنفيذه إذا كان الشرط صحيحاً
}

#include <stdio.h>

int main() {
    int num = 10;
    
    if (num > 0) {
        printf("العدد موجب.\n");
    }
    
    return 0;
}

if (شرط) {
    // الكود الذي سيتم تنفيذه إذا كان الشرط صحيحاً
} else {
    // الكود الذي سيتم تنفيذه إذا كان الشرط خاطئاً
}

#include <stdio.h>

int main() {
    int num = -5;
    
    if (num >= 0) {
        printf("العدد موجب أو صفر.\n");
    } else {
        printf("العدد سالب.\n");
    }
    
    return 0;
}

if (شرط1) {
    // الكود الذي سيتم تنفيذه إذا كان الشرط1 صحيحاً
} else if (شرط2) {
    // الكود الذي سيتم تنفيذه إذا كان الشرط1 خاطئاً والشرط2 صحيحاً
} else {
    // الكود الذي سيتم تنفيذه إذا كانت جميع الشروط السابقة خاطئة
}

#include <stdio.h>

int main() {
    int score = 85;
    
    if (score >= 90) {
        printf("تقدير: ممتاز\n");
    } else if (score >= 80) {
        printf("تقدير: جيد جداً\n");
    } else if (score >= 70) {
        printf("تقدير: جيد\n");
    } else if (score >= 60) {
        printf("تقدير: مقبول\n");
    } else {
        printf("تقدير: راسب\n");
    }
    
    return 0;
}

النتيجة = (شرط) ? قيمة_إذا_صحيح : قيمة_إذا_خاطئ;

#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int max;
    
    // استخدام العبارة الشرطية
    max = (a > b) ? a : b;
    
    printf("الرقم الأكبر هو: %d\n", max);
    
    return 0;
}

for (التهيئة; الشرط; التحديث) {
    // الكود الذي سيتم تكراره
}

#include <stdio.h>

int main() {
    int i;
    
    // طباعة الأرقام من 1 إلى 5
    for (i = 1; i <= 5; i++) {
        printf("%d ", i);
    }
    printf("\n");
    
    return 0;
}

while (شرط) {
    // الكود الذي سيتم تكراره
}

#include <stdio.h>

int main() {
    int num = 1;
    
    // طباعة الأرقام من 1 إلى 5
    while (num <= 5) {
        printf("%d ", num);
        num++;
    }
    printf("\n");
    
    return 0;
}

do {
    // الكود الذي سيتم تكراره
} while (شرط);

#include <stdio.h>

int main() {
    int num = 1;
    
    // طباعة الأرقام من 1 إلى 5
    do {
        printf("%d ", num);
        num++;
    } while (num <= 5);
    printf("\n");
    
    return 0;
}

switch (التعبير) {
    case قيمة1:
        // الكود الذي سيتم تنفيذه إذا كان التعبير = قيمة1
        break;
    case قيمة2:
        // الكود الذي سيتم تنفيذه إذا كان التعبير = قيمة2
        break;
    // يمكن إضافة المزيد من الحالات
    default:
        // الكود الذي سيتم تنفيذه إذا لم تتطابق أي من الحالات السابقة
}

#include <stdio.h>

int main() {
    char grade = 'B';
    
    switch (grade) {
        case 'A':
            printf("ممتاز!\n");
            break;
        case 'B':
            printf("جيد جداً!\n");
            break;
        case 'C':
            printf("جيد!\n");
            break;
        case 'D':
            printf("مقبول!\n");
            break;
        case 'F':
            printf("راسب!\n");
            break;
        default:
            printf("تقدير غير صالح!\n");
    }
    
    return 0;
}

نوع_الإرجاع اسم_الدالة(قائمة_المعاملات) {
    // جسم الدالة
    return قيمة_الإرجاع;  // إذا كان نوع الإرجاع ليس void
}

// نموذج الدالة
نوع_الإرجاع اسم_الدالة(قائمة_أنواع_المعاملات);

#include <stdio.h>

// نماذج الدوال
int add(int, int);
void printResult(int);

int main() {
    int result = add(5, 3);
    printResult(result);
    
    return 0;
}

// تعريف الدوال
int add(int a, int b) {
    return a + b;
}

void printResult(int result) {
    printf("النتيجة: %d\n", result);
}

#include <stdio.h>

void modify(int num) {
    num = num * 2;  // تعديل النسخة المحلية من num
    printf("داخل الدالة: %d\n", num);
}

int main() {
    int x = 10;
    
    printf("قبل استدعاء الدالة: %d\n", x);
    modify(x);
    printf("بعد استدعاء الدالة: %d\n", x);  // قيمة x لم تتغير
    
    return 0;
}

#include <stdio.h>

void modifyRef(int *num) {
    *num = *num * 2;  // تعديل القيمة الأصلية عبر المؤشر
    printf("داخل الدالة: %d\n", *num);
}

int main() {
    int x = 10;
    
    printf("قبل استدعاء الدالة: %d\n", x);
    modifyRef(&x);  // تمرير عنوان x
    printf("بعد استدعاء الدالة: %d\n", x);  // الآن x = 20
    
    return 0;
}

#include <stdio.h>

// تعريف قيمة افتراضية باستخدام ماكرو
#define DEFAULT_MULTIPLIER 2

int multiply(int num, int multiplier) {
    return num * multiplier;
}

// دالة أخرى تستدعي الأولى مع قيمة افتراضية
int multiplyDefault(int num) {
    return multiply(num, DEFAULT_MULTIPLIER);
}

int main() {
    printf("5 * 3 = %d\n", multiply(5, 3));
    printf("5 * DEFAULT = %d\n", multiplyDefault(5));
    
    return 0;
}

#include <stdio.h>

// طريقة 1: مصفوفة بدون تحديد الحجم
void printArray(int arr[], int size) {
    int i;
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// طريقة 2: باستخدام المؤشر
void printArrayPtr(int *arr, int size) {
    int i;
    for (i = 0; i < size; i++) {
        printf("%d ", *(arr + i));  // يمكن أيضاً استخدام arr[i]
    }
    printf("\n");
}

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printArray(numbers, size);
    printArrayPtr(numbers, size);
    
    return 0;
}

#include <stdio.h>

// دالة تكرارية لحساب العدد التراكمي (Factorial)
int factorial(int n) {
    // الحالة القاعدية (Base Case)
    if (n == 0 || n == 1) {
        return 1;
    }
    // الحالة التكرارية (Recursive Case)
    else {
        return n * factorial(n - 1);
    }
}

int main() {
    int num = 5;
    printf("%d! = %d\n", num, factorial(num));  // 5! = 120
    
    return 0;
}

#include <stdio.h>

// دالة تكرارية لحساب فيبوناتشي
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

int main() {
    int i;
    printf("سلسلة فيبوناتشي للعشر أرقام الأولى: ");
    for (i = 0; i < 10; i++) {
        printf("%d ", fibonacci(i));
    }
    printf("\n");  // النتيجة: 0 1 1 2 3 5 8 13 21 34
    
    return 0;
}

// تعريف مصفوفة بدون تهيئة
int numbers[5];  // مصفوفة من 5 أعداد صحيحة

// تعريف وتهيئة مصفوفة
int scores[5] = {85, 92, 78, 90, 88};

// تعريف وتهيئة مصفوفة بدون تحديد الحجم (يحدد الحجم تلقائياً)
char vowels[] = {'a', 'e', 'i', 'o', 'u'};

// تهيئة جزئية (العناصر المتبقية تُهيأ بالقيمة 0)
float values[5] = {1.5, 2.5};

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // الوصول إلى عنصر واحد
    printf("العنصر الثالث: %d\n", numbers[2]);  // الفهارس تبدأ من 0
    
    // تعديل قيمة عنصر
    numbers[3] = 45;
    printf("العنصر الرابع بعد التعديل: %d\n", numbers[3]);
    
    // طباعة جميع العناصر باستخدام حلقة
    int i;
    printf("جميع العناصر: ");
    for (i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>

int main() {
    int numbers[] = {10, 20, 30, 40, 50, 60};
    
    // حساب عدد العناصر في المصفوفة
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("عدد العناصر في المصفوفة: %d\n", size);
    
    return 0;
}

// تعريف مصفوفة ثنائية الأبعاد
int matrix[3][4];  // مصفوفة 3×4

// تعريف وتهيئة مصفوفة ثنائية الأبعاد
int grid[2][3] = {
    {1, 2, 3},  // الصف الأول
    {4, 5, 6}   // الصف الثاني
};

// طريقة أخرى للتهيئة
int another[2][3] = {1, 2, 3, 4, 5, 6};

#include <stdio.h>

int main() {
    int matrix[3][4] = {
        {10, 20, 30, 40},
        {50, 60, 70, 80},
        {90, 100, 110, 120}
    };
    
    // الوصول إلى عنصر واحد
    printf("العنصر في الصف 1، العمود 2: %d\n", matrix[1][2]);  // 70
    
    // تعديل قيمة عنصر
    matrix[2][3] = 125;
    printf("العنصر بعد التعديل: %d\n", matrix[2][3]);
    
    // طباعة جميع عناصر المصفوفة باستخدام حلقات متداخلة
    int i, j;
    printf("المصفوفة كاملة:\n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 4; j++) {
            printf("%4d", matrix[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

// مصفوفة ثلاثية الأبعاد (2×3×4)
int cube[2][3][4];

// الوصول إلى عنصر
cube[1][2][3] = 100;

// تهيئة مصفوفة ثلاثية الأبعاد
int cube[2][2][2] = {
    {{1, 2}, {3, 4}},    // الطبقة الأولى
    {{5, 6}, {7, 8}}     // الطبقة الثانية
};

// طريقة 1: باستخدام مصفوفة حروف
char str1[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

// طريقة 2: باستخدام النص المحاط بعلامات اقتباس
char str2[] = "Hello";  // المترجم يضيف '\0' تلقائياً

// طريقة 3: تحديد الحجم (يجب أن يكون كافياً للنص + محرف النهاية)
char str3[10] = "Hello";  // المساحة المتبقية تُملأ بـ '\0'

// مؤشر إلى سلسلة نصية ثابتة
char *str4 = "Hello";

#include <stdio.h>
#include <string.h>

int main() {
    char str1[20] = "Hello";
    char str2[] = "World";
    char str3[20];
    int len;
    
    // حساب طول السلسلة
    len = strlen(str1);
    printf("طول السلسلة str1: %d\n", len);
    
    // نسخ سلسلة
    strcpy(str3, str1);
    printf("str3 بعد النسخ: %s\n", str3);
    
    // دمج سلسلتين
    strcat(str1, str2);
    printf("str1 بعد الدمج: %s\n", str1);
    
    // مقارنة سلسلتين
    if (strcmp(str1, str3) == 0) {
        printf("السلسلتان متطابقتان\n");
    } else {
        printf("السلسلتان غير متطابقتين\n");
    }
    
    // البحث عن حرف في سلسلة
    char *ptr = strchr(str1, 'o');
    if (ptr) {
        printf("تم العثور على 'o' في الموضع: %ld\n", ptr - str1);
    }
    
    return 0;
}

// تعريف مؤشر (بدون تهيئة)
int *ptr;

// تعريف متغير ومؤشر يشير إليه
int num = 10;
int *ptr = #  // & هو عامل "عنوان" يرجع عنوان المتغير

// يمكن أيضاً تعريف المؤشر أولاً ثم إسناد العنوان لاحقاً
int *ptr;
ptr = #

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr = #
    
    printf("قيمة num: %d\n", num);
    printf("عنوان num: %p\n", &num);
    printf("قيمة ptr (أي عنوان num): %p\n", ptr);
    printf("القيمة التي يشير إليها ptr: %d\n", *ptr);  // * هو عامل "محتوى العنوان"
    
    // تغيير قيمة المتغير من خلال المؤشر
    *ptr = 20;
    printf("قيمة num بعد التعديل: %d\n", num);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = NULL;  // تهيئة مؤشر بالقيمة NULL
    
    printf("قيمة المؤشر الفارغ: %p\n", ptr);
    
    // تحقق دائماً من أن المؤشر ليس فارغاً قبل استخدامه
    if (ptr != NULL) {
        printf("القيمة التي يشير إليها ptr: %d\n", *ptr);
    } else {
        printf("المؤشر فارغ ولا يشير إلى أي عنوان صالح.\n");
    }
    
    return 0;
}

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *ptr = numbers;  // لا تحتاج لعامل &
    
    printf("عنوان المصفوفة (numbers): %p\n", numbers);
    printf("عنوان أول عنصر (&numbers[0]): %p\n", &numbers[0]);
    printf("قيمة المؤشر (ptr): %p\n\n", ptr);
    
    // الوصول إلى عناصر المصفوفة باستخدام المؤشر
    printf("العناصر باستخدام الفهارس المصفوفة: %d %d %d\n", numbers[0], numbers[1], numbers[2]);
    printf("العناصر باستخدام الفهارس المؤشر: %d %d %d\n", ptr[0], ptr[1], ptr[2]);
    printf("العناصر باستخدام عمليات المؤشر: %d %d %d\n\n", *ptr, *(ptr + 1), *(ptr + 2));
    
    // تغيير قيم المصفوفة باستخدام المؤشر
    *ptr = 15;         // تغيير العنصر الأول
    *(ptr + 2) = 35;   // تغيير العنصر الثالث
    
    printf("المصفوفة بعد التعديل: ");
    int i;
    for (i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *ptr = numbers;
    
    printf("ptr    يشير إلى العنصر: %d\n", *ptr);
    printf("ptr + 1 يشير إلى العنصر: %d\n", *(ptr + 1));
    printf("ptr + 2 يشير إلى العنصر: %d\n", *(ptr + 2));
    
    // تحريك المؤشر للأمام
    ptr++;
    printf("بعد ptr++، ptr يشير إلى العنصر: %d\n", *ptr);
    
    ptr += 2;
    printf("بعد ptr += 2، ptr يشير إلى العنصر: %d\n", *ptr);
    
    // تحريك المؤشر للخلف
    ptr--;
    printf("بعد ptr--، ptr يشير إلى العنصر: %d\n", *ptr);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n, i;
    
    printf("أدخل عدد العناصر: ");
    scanf("%d", &n);
    
    // تخصيص ذاكرة ديناميكياً
    ptr = (int*) malloc(n * sizeof(int));
    
    // التحقق من نجاح تخصيص الذاكرة
    if (ptr == NULL) {
        printf("خطأ: فشل في تخصيص الذاكرة.\n");
        return 1;
    }
    
    // إدخال العناصر
    printf("أدخل %d عدد:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &ptr[i]);
    }
    
    // عرض العناصر
    printf("العناصر المدخلة: ");
    for (i = 0; i < n; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");
    
    // تحرير الذاكرة عند الانتهاء
    free(ptr);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n, i, new_size;
    
    printf("أدخل عدد العناصر: ");
    scanf("%d", &n);
    
    // تخصيص ذاكرة وتهيئتها بالقيمة صفر
    ptr = (int*) calloc(n, sizeof(int));
    
    if (ptr == NULL) {
        printf("خطأ: فشل في تخصيص الذاكرة.\n");
        return 1;
    }
    
    // عرض العناصر (جميعها صفر بسبب calloc)
    printf("العناصر بعد calloc: ");
    for (i = 0; i < n; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");
    
    // إدخال عناصر جديدة
    printf("أدخل %d عدد:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &ptr[i]);
    }
    
    // تغيير حجم المصفوفة
    printf("أدخل الحجم الجديد: ");
    scanf("%d", &new_size);
    
    ptr = (int*) realloc(ptr, new_size * sizeof(int));
    
    if (ptr == NULL) {
        printf("خطأ: فشل في إعادة تخصيص الذاكرة.\n");
        return 1;
    }
    
    // إذا كان الحجم الجديد أكبر، أدخل العناصر الإضافية
    if (new_size > n) {
        printf("أدخل %d عدد إضافي:\n", new_size - n);
        for (i = n; i < new_size; i++) {
            scanf("%d", &ptr[i]);
        }
    }
    
    // عرض العناصر بعد التعديل
    printf("العناصر بعد realloc: ");
    for (i = 0; i < new_size; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");
    
    // تحرير الذاكرة
    free(ptr);
    
    return 0;
}

#include <stdio.h>

// تعريف تعداد للأيام
enum Day {
    SUNDAY,    // قيمة 0 (افتراضياً)
    MONDAY,    // قيمة 1
    TUESDAY,   // قيمة 2
    WEDNESDAY, // قيمة 3
    THURSDAY,  // قيمة 4
    FRIDAY,    // قيمة 5
    SATURDAY   // قيمة 6
};

// تعداد مع قيم محددة
enum Month {
    JAN = 1, FEB, MAR, APR, MAY, JUN,
    JUL, AUG, SEP, OCT, NOV, DEC
};

int main() {
    enum Day today = WEDNESDAY;
    enum Month month = JUL;
    
    printf("اليوم: %d\n", today);
    printf("الشهر: %d\n", month);
    
    // استخدام التعدادات في العبارات الشرطية
    if (today == FRIDAY || today == SATURDAY) {
        printf("عطلة نهاية الأسبوع!\n");
    } else {
        printf("يوم عمل.\n");
    }
    
    return 0;
}

#include <stdio.h>
#include <string.h>

// استخدام typedef مع الأنواع الأساسية
typedef unsigned int uint;
typedef char * string;

// استخدام typedef مع الهياكل
typedef struct {
    char name[50];
    int age;
    float salary;
} Employee;

// استخدام typedef مع المؤشرات للدوال
typedef int (*MathFunc)(int, int);

// دوال للاختبار
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    // استخدام الأنواع المعرفة بـ typedef
    uint num = 10;
    string name = "أحمد";
    
    printf("العدد: %u\n", num);
    printf("الاسم: %s\n", name);
    
    // استخدام typedef مع الهياكل
    Employee emp1;
    strcpy(emp1.name, "محمد");
    emp1.age = 30;
    emp1.salary = 5000.0;
    
    printf("الموظف: %s، العمر: %d، الراتب: %.2f\n", emp1.name, emp1.age, emp1.salary);
    
    // استخدام typedef مع مؤشرات الدوال
    MathFunc operation = add;
    printf("الجمع: %d\n", operation(5, 3));
    
    operation = subtract;
    printf("الطرح: %d\n", operation(5, 3));
    
    return 0;
}

#include <stdio.h>

int main() {
    unsigned int a = 60;  // 00111100 في الثنائي
    unsigned int b = 13;  // 00001101 في الثنائي
    int result;
    
    // عمليات AND، OR، XOR البتية
    result = a & b;  // 00001100 = 12
    printf("a & b = %d\n", result);
    
    result = a | b;  // 00111101 = 61
    printf("a | b = %d\n", result);
    
    result = a ^ b;  // 00110001 = 49
    printf("a ^ b = %d\n", result);
    
    result = ~a;     // 11000011 للبايت الأقل أهمية (قيمة سالبة للـ int)
    printf("~a = %d\n", result);
    
    // عمليات الإزاحة
    result = a << 2; // 11110000 = 240
    printf("a << 2 = %d\n", result);
    
    result = a >> 2; // 00001111 = 15
    printf("a >> 2 = %d\n", result);
    
    return 0;
}

#include <stdio.h>

// تعريف الأعلام البتية
#define FLAG_A (1 << 0)  // 00000001
#define FLAG_B (1 << 1)  // 00000010
#define FLAG_C (1 << 2)  // 00000100
#define FLAG_D (1 << 3)  // 00001000

int main() {
    unsigned char flags = 0;  // 00000000
    
    // ضبط العلم (تعيين بت إلى 1)
    flags |= FLAG_A;  // 00000001
    flags |= FLAG_C;  // 00000101
    
    printf("الأعلام بعد الضبط: %d\n", flags);
    
    // فحص العلم
    if (flags & FLAG_A) {
        printf("العلم A مضبوط.\n");
    }
    
    if (flags & FLAG_B) {
        printf("العلم B مضبوط.\n");
    } else {
        printf("العلم B غير مضبوط.\n");
    }
    
    // مسح العلم (تعيين بت إلى 0)
    flags &= ~FLAG_A;  // 00000100
    
    printf("الأعلام بعد المسح: %d\n", flags);
    
    // تبديل حالة العلم
    flags ^= FLAG_C;  // 00000000
    flags ^= FLAG_D;  // 00001000
    
    printf("الأعلام بعد التبديل: %d\n", flags);
    
    return 0;
}