Learn in 10 minutes

Learn in 10 minutes

10 मिनट में C सीखें

Programming Language

C एक शक्तिशाली, सामान्य-उद्देश्य प्रोग्रामिंग भाषा है जो अपनी दक्षता और हार्डवेयर के करीब क्षमताओं के लिए जानी जाती है। यह ट्यूटोरियल C प्रोग्रामिंग के मूल सिद्धांतों को कवर करता है, जो आपको भाषा को जल्दी से समझने में मदद करेगा।

1. अपना पहला C प्रोग्राम लिखना

आइए क्लासिक “Hello, World!” प्रोग्राम से शुरू करते हैं। hello.c नाम की एक फ़ाइल बनाएं और निम्नलिखित कोड दर्ज करें:

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

फ़ाइल को सेव करें और GCC जैसे C कंपाइलर का उपयोग करके इसे कंपाइल करें:

gcc hello.c -o hello
./hello

आउटपुट होगा:

Hello, World!

यह सरल प्रोग्राम C की बुनियादी संरचना प्रदर्शित करता है:

  • #include <stdio.h> स्टैंडर्ड इनपुट/आउटपुट लाइब्रेरी शामिल करता है
  • int main() प्रोग्राम का एंट्री पॉइंट है
  • printf() टेक्स्ट आउटपुट प्रदर्शित करता है
  • return 0 सफल निष्पादन को इंगित करता है

2. बेसिक सिंटैक्स

C स्टेटमेंट्स को समाप्त करने के लिए सेमीकोलन और कोड ब्लॉक्स को परिभाषित करने के लिए कर्ली ब्रेसिज {} के साथ एक संरचित सिंटैक्स का उपयोग करता है।

// यह एक सिंगल-लाइन कमेंट है
/* यह एक मल्टी-लाइन कमेंट है */

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

C में बेसिक सिंटैक्स नियम:

  • सेमीकोलन: हर स्टेटमेंट सेमीकोलन ; के साथ समाप्त होना चाहिए
  • कमेंट्स: सिंगल-लाइन कमेंट्स // का उपयोग करते हैं, मल्टी-लाइन कमेंट्स /* */ का उपयोग करते हैं
  • कोड ब्लॉक्स: कर्ली ब्रेसिज {} द्वारा परिभाषित
  • केस सेंसिटिविटी: C केस-सेंसिटिव है (main बनाम Main)

3. वेरिएबल्स और डेटा टाइप्स

C एक स्टैटिकली टाइप्ड भाषा है, जिसका अर्थ है कि आपको उपयोग से पहले वेरिएबल टाइप्स घोषित करने होंगे।

बेसिक वेरिएबल नेमिंग नियम:

  • वेरिएबल नामों में अक्षर, संख्याएं और अंडरस्कोर हो सकते हैं
  • वेरिएबल नाम संख्या से शुरू नहीं हो सकते
  • वेरिएबल नाम केस-सेंसिटिव होते हैं
  • C कीवर्ड्स का उपयोग वेरिएबल नामों के रूप में नहीं किया जा सकता

C के मुख्य डेटा टाइप्स:

  • int: पूर्णांक संख्याएं (जैसे, 42, -10)
  • float: फ्लोटिंग-पॉइंट संख्याएं (जैसे, 3.14, -2.5)
  • double: डबल-प्रिसिजन फ्लोटिंग-पॉइंट संख्याएं
  • char: सिंगल करैक्टर्स (जैसे, 'A', 'z')
  • void: कोई टाइप नहीं
int age = 25;
float temperature = 36.5;
double pi = 3.14159265359;
char grade = 'A';

3.1 इंटीजर टाइप्स

C विभिन्न आकारों के साथ कई इंटीजर टाइप्स प्रदान करता है:

char small_number = 100;        // आमतौर पर 1 बाइट
short medium_number = 32000;    // आमतौर पर 2 बाइट्स
int regular_number = 1000000;   // आमतौर पर 4 बाइट्स
long large_number = 1000000000; // आमतौर पर 4 या 8 बाइट्स

3.2 फ्लोटिंग-पॉइंट टाइप्स

float single_precision = 3.14f;
double double_precision = 3.14159265359;
long double extended_precision = 3.14159265358979323846L;

3.3 करैक्टर टाइप

करैक्टर्स ASCII एन्कोडिंग का उपयोग करके इंटीजर्स के रूप में संग्रहीत होते हैं:

char letter = 'A';
char digit = '7';
char newline = '\n';
char tab = '\t';

4. कॉन्स्टेंट्स

कॉन्स्टेंट्स फिक्स्ड वैल्यूज होती हैं जिन्हें प्रोग्राम निष्पादन के दौरान बदला नहीं जा सकता:

const int MAX_SIZE = 100;
const float PI = 3.14159;
const char NEWLINE = '\n';

#define MAX_USERS 1000
#define PI 3.14159

5. इनपुट और आउटपुट

C इनपुट और आउटपुट ऑपरेशन्स के लिए stdio.h से फंक्शन्स का उपयोग करता है।

5.1 printf() के साथ आउटपुट

#include <stdio.h>

int main() {
    int age = 25;
    float height = 1.75;
    char name[] = "John";

    printf("Hello, %s!\n", name);
    printf("You are %d years old\n", age);
    printf("Your height is %.2f meters\n", height);

    return 0;
}

कॉमन फॉर्मेट स्पेसिफायर्स:

  • %d - इंटीजर
  • %f - फ्लोट/डबल
  • %c - करैक्टर
  • %s - स्ट्रिंग
  • %p - पॉइंटर

5.2 scanf() के साथ इनपुट

#include <stdio.h>

int main() {
    int age;
    float height;
    char name[50];

    printf("Enter your name: ");
    scanf("%s", name);

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Enter your height: ");
    scanf("%f", &height);

    printf("Hello %s, you are %d years old and %.2f meters tall\n",
           name, age, height);

    return 0;
}

6. ऑपरेटर्स

C विभिन्न कंप्यूटेशन्स के लिए ऑपरेटर्स का एक समृद्ध सेट प्रदान करता है।

6.1 अरिथमेटिक ऑपरेटर्स

int a = 10, b = 3;

printf("Addition: %d\n", a + b);      // 13
printf("Subtraction: %d\n", a - b);   // 7
printf("Multiplication: %d\n", a * b); // 30
printf("Division: %d\n", a / b);      // 3
printf("Modulus: %d\n", a % b);       // 1

6.2 कम्पेरिजन ऑपरेटर्स

int x = 5, y = 10;

printf("Equal: %d\n", x == y);     // 0 (false)
printf("Not equal: %d\n", x != y); // 1 (true)
printf("Greater than: %d\n", x > y);  // 0
printf("Less than: %d\n", x < y);  // 1

6.3 लॉजिकल ऑपरेटर्स

int a = 1, b = 0;

printf("AND: %d\n", a && b);  // 0
printf("OR: %d\n", a || b);   // 1
printf("NOT: %d\n", !a);      // 0

6.4 बिटवाइज ऑपरेटर्स

unsigned int a = 5;  // बाइनरी में 0101
unsigned int b = 3;  // बाइनरी में 0011

printf("AND: %d\n", a & b);   // 1 (0001)
printf("OR: %d\n", a | b);    // 7 (0111)
printf("XOR: %d\n", a ^ b);   // 6 (0110)
printf("NOT: %d\n", ~a);      // सिस्टम पर निर्भर करता है
printf("Left shift: %d\n", a << 1);  // 10 (1010)
printf("Right shift: %d\n", a >> 1); // 2 (0010)

7. कंट्रोल फ्लो

C प्रोग्राम निष्पादन को प्रबंधित करने के लिए कई कंट्रोल फ्लो स्टेटमेंट्स प्रदान करता है।

7.1 if स्टेटमेंट्स

int age = 20;

if (age >= 18) {
    printf("Adult\n");
} else if (age >= 13) {
    printf("Teen\n");
} else {
    printf("Child\n");
}

7.2 switch स्टेटमेंट्स

int day = 3;

switch (day) {
    case 1:
        printf("Monday\n");
        break;
    case 2:
        printf("Tuesday\n");
        break;
    case 3:
        printf("Wednesday\n");
        break;
    default:
        printf("Other day\n");
}

7.3 for लूप्स

for (int i = 0; i < 5; i++) {
    printf("i = %d\n", i);
}

7.4 while लूप्स

int count = 0;
while (count < 5) {
    printf("Count: %d\n", count);
    count++;
}

7.5 do-while लूप्स

int count = 0;
do {
    printf("Count: %d\n", count);
    count++;
} while (count < 5);

7.6 break और continue

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;  // लूप से बाहर निकलें
    }
    if (i % 2 == 0) {
        continue;  // इवन नंबर्स को स्किप करें
    }
    printf("i = %d\n", i);  // आउटपुट: 1, 3
}

8. ऐरेज़

ऐरेज़ एक ही टाइप के कई वैल्यूज को स्टोर करते हैं।

8.1 वन-डायमेंशनल ऐरेज़

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

// एलिमेंट्स तक पहुंचना
printf("First element: %d\n", numbers[0]);
printf("Last element: %d\n", numbers[4]);

// एलिमेंट्स को मॉडिफाई करना
numbers[0] = 10;

// ऐरे के माध्यम से लूपिंग
for (int i = 0; i < 5; i++) {
    printf("numbers[%d] = %d\n", i, numbers[i]);
}

8.2 मल्टी-डायमेंशनल ऐरेज़

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

// एलिमेंट्स तक पहुंचना
printf("matrix[1][2] = %d\n", matrix[1][2]);  // 6

// 2D ऐरे के माध्यम से लूपिंग
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", matrix[i][j]);
    }
    printf("\n");
}

9. स्ट्रिंग्स

C में, स्ट्रिंग्स करैक्टर्स के ऐरे होते हैं जो एक नल करैक्टर \0 द्वारा समाप्त होते हैं।

char greeting[] = "Hello";  // ऑटोमैटिकली नल टर्मिनेटर शामिल करता है
char name[20] = "John";

// string.h से स्ट्रिंग फंक्शन्स
#include <string.h>

char str1[20] = "Hello";
char str2[20] = "World";

printf("Length: %lu\n", strlen(str1));  // 5
strcpy(str1, str2);  // str2 को str1 में कॉपी करें
printf("After copy: %s\n", str1);  // World

if (strcmp(str1, str2) == 0) {
    printf("Strings are equal\n");
}

10. फंक्शन्स

फंक्शन्स पुन: प्रयोज्य कोड ब्लॉक्स होते हैं जो विशिष्ट कार्य करते हैं।

10.1 फंक्शन डेफिनिशन और कॉलिंग

#include <stdio.h>

// फंक्शन डिक्लेरेशन
int add(int a, int b);

int main() {
    int result = add(5, 3);
    printf("5 + 3 = %d\n", result);
    return 0;
}

// फंक्शन डेफिनिशन
int add(int a, int b) {
    return a + b;
}

10.2 नो रिटर्न वैल्यू वाले फंक्शन

void greet(char name[]) {
    printf("Hello, %s!\n", name);
}

int main() {
    greet("Alice");
    return 0;
}

10.3 रिकर्सिव फंक्शन्स

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

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

11. पॉइंटर्स

पॉइंटर्स वेरिएबल्स होते हैं जो मेमोरी एड्रेस स्टोर करते हैं।

11.1 बेसिक पॉइंटर यूज़ेज

int number = 42;
int *ptr = &number;  // ptr number का एड्रेस स्टोर करता है

printf("Value: %d\n", number);     // 42
printf("Address: %p\n", &number);  // मेमोरी एड्रेस
printf("Pointer value: %d\n", *ptr); // 42 (डेरिफरेंसिंग)

// पॉइंटर के माध्यम से वैल्यू मॉडिफाई करना
*ptr = 100;
printf("New value: %d\n", number);  // 100

11.2 पॉइंटर्स और ऐरेज़

int numbers[] = {1, 2, 3, 4, 5};
int *ptr = numbers;  // पहले एलिमेंट को पॉइंट करता है

printf("First element: %d\n", *ptr);        // 1
printf("Second element: %d\n", *(ptr + 1)); // 2

// ऐरे नाम अनिवार्य रूप से पहले एलिमेंट का पॉइंटर है
for (int i = 0; i < 5; i++) {
    printf("numbers[%d] = %d\n", i, *(numbers + i));
}

11.3 पॉइंटर्स और फंक्शन्स

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x=%d, y=%d\n", x, y);
    swap(&x, &y);
    printf("After swap: x=%d, y=%d\n", x, y);
    return 0;
}

12. स्ट्रक्चर्स

स्ट्रक्चर्स आपको संबंधित वेरिएबल्स को एक साथ समूहित करने की अनुमति देते हैं।

12.1 स्ट्रक्चर्स को डिफाइन और यूज़ करना

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

// स्ट्रक्चर डेफिनिशन
struct Student {
    char name[50];
    int age;
    float gpa;
};

int main() {
    // स्ट्रक्चर वेरिएबल्स बनाना
    struct Student student1;

    // वैल्यूज असाइन करना
    strcpy(student1.name, "Alice");
    student1.age = 20;
    student1.gpa = 3.8;

    // स्ट्रक्चर मेंबर्स तक पहुंचना
    printf("Name: %s\n", student1.name);
    printf("Age: %d\n", student1.age);
    printf("GPA: %.2f\n", student1.gpa);

    return 0;
}

12.2 पॉइंटर्स के साथ स्ट्रक्चर

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p1 = {10, 20};
    struct Point *ptr = &p1;

    printf("Coordinates: (%d, %d)\n", ptr->x, ptr->y);

    return 0;
}

13. डायनामिक मेमोरी एलोकेशन

C डायनामिक मेमोरी मैनेजमेंट के लिए फंक्शन्स प्रदान करता है।

13.1 malloc, calloc, realloc, free

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

int main() {
    // 5 इंटीजर्स के लिए मेमोरी एलोकेट करें
    int *numbers = (int*)malloc(5 * sizeof(int));

    if (numbers == NULL) {
        printf("Memory allocation failed!\n");
    return 1;
    }

    // ऐरे इनिशियलाइज़ करें
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * 10;
    }

    // ऐरे प्रिंट करें
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    // एलोकेटेड मेमोरी फ्री करें
    free(numbers);

    return 0;
}

13.2 डायनामिक स्ट्रिंग एलोकेशन

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

int main() {
    char *name = (char*)malloc(50 * sizeof(char));

    if (name != NULL) {
        strcpy(name, "Dynamic string");
        printf("Name: %s\n", name);
        free(name);
    }

    return 0;
}

14. फाइल ऑपरेशन्स

C फाइलों से पढ़ने और फाइलों में लिखने के लिए फंक्शन्स प्रदान करता है।

14.1 फाइल में लिखना

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");

    if (file == NULL) {
        printf("Error opening file!\n");
        return 1;
    }

    fprintf(file, "Hello, File!\n");
    fprintf(file, "This is a test.\n");

    fclose(file);
    printf("File written successfully.\n");

    return 0;
}

14.2 फाइल से पढ़ना

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "r");

    if (file == NULL) {
        printf("Error opening file!\n");
        return 1;
    }

    char buffer[100];

    while (fgets(buffer, sizeof(buffer), file) != NULL) {
        printf("%s", buffer);
    }

    fclose(file);

    return 0;
}

15. प्रीप्रोसेसर डायरेक्टिव्स

प्रीप्रोसेसर डायरेक्टिव्स कंपाइलेशन से पहले प्रोसेस किए जाते हैं।

15.1 #include

#include <stdio.h>    // सिस्टम हेडर फाइल
#include "myheader.h" // यूजर हेडर फाइल

15.2 #define

#define PI 3.14159
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    double area = PI * 5 * 5;
    int larger = MAX(10, 20);

    printf("Area: %.2f\n", area);
    printf("Larger number: %d\n", larger);

    return 0;
}

15.3 कंडीशनल कंपाइलेशन

#define DEBUG 1

int main() {
    #ifdef DEBUG
        printf("Debug mode enabled\n");
    #endif

    #if DEBUG == 1
        printf("Debug level 1\n");
    #elif DEBUG == 2
        printf("Debug level 2\n");
    #else
        printf("No debug\n");
    #endif

    return 0;
}

16. एरर हैंडलिंग

C में बिल्ट-इन एक्सेप्शन हैंडलिंग नहीं है, इसलिए हम रिटर्न वैल्यूज और एरर कोड्स का उपयोग करते हैं।

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

int main() {
    FILE *file = fopen("nonexistent.txt", "r");

    if (file == NULL) {
        printf("Error opening file: %s\n", strerror(errno));
        return 1;
    }

    fclose(file);
    return 0;
}

यह व्यापक C ट्यूटोरियल C में प्रोग्रामिंग शुरू करने के लिए आवश्यक आवश्यक अवधारणाओं को कवर करता है। इन उदाहरणों का अभ्यास करें और जैसे-जैसे आप भाषा के साथ अधिक सहज होते जाते हैं, लिंक्ड लिस्ट्स, फंक्शन पॉइंटर्स और मल्टी-फाइल प्रोग्राम्स जैसे अधिक उन्नत विषयों का पता लगाएं।