C

C Programming

Master the fundamentals of C programming with comprehensive tutorials, examples, and hands-on exercises

Start Learning Try Online Compiler
C Programming Tutorial
Getting Started
Fundamentals
Control Flow
Functions
Arrays & Strings
Pointers
Advanced Topics

Pointer Arithmetic in C

Pointer arithmetic allows you to perform mathematical operations on pointers. This is particularly useful when working with arrays and dynamic memory allocation.

Basic Pointer Arithmetic Operations

Increment and Decrement 
#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    
    printf("Original pointer address: %p\n", ptr);
    printf("Value at pointer: %d\n", *ptr);
    
    // Increment pointer
    ptr++;
    printf("After increment: %p\n", ptr);
    printf("Value at pointer: %d\n", *ptr);
    
    // Increment by 2
    ptr += 2;
    printf("After adding 2: %p\n", ptr);
    printf("Value at pointer: %d\n", *ptr);
    
    // Decrement pointer
    ptr--;
    printf("After decrement: %p\n", ptr);
    printf("Value at pointer: %d\n", *ptr);
    
    return 0;
}

Pointer Subtraction

Distance Between Pointers 
#include <stdio.h>

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int *start = &arr[2];  // Points to arr[2]
    int *end = &arr[7];    // Points to arr[7]
    
    printf("Start pointer points to: %d\n", *start);
    printf("End pointer points to: %d\n", *end);
    
    // Calculate distance
    int distance = end - start;
    printf("Distance between pointers: %d elements\n", distance);
    
    // Verify by accessing elements
    printf("Elements between start and end: ");
    for (int *p = start; p <= end; p++) {
        printf("%d ", *p);
    }
    printf("\n");
    
    return 0;
}

Pointer Comparison

Comparing Pointers 
#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr1 = &arr[1];
    int *ptr2 = &arr[3];
    int *ptr3 = &arr[1];
    
    printf("ptr1 points to: %d\n", *ptr1);
    printf("ptr2 points to: %d\n", *ptr2);
    printf("ptr3 points to: %d\n", *ptr3);
    
    // Pointer comparisons
    if (ptr1 == ptr3) {
        printf("ptr1 and ptr3 point to the same location\n");
    }
    
    if (ptr1 < ptr2) {
        printf("ptr1 comes before ptr2 in memory\n");
    }
    
    if (ptr2 > ptr1) {
        printf("ptr2 comes after ptr1 in memory\n");
    }
    
    return 0;
}

Practical Example: Array Traversal

Efficient Array Processing 
#include <stdio.h>

int findElement(int *arr, int size, int target) {
    int *end = arr + size;  // Pointer to end of array
    
    for (int *ptr = arr; ptr < end; ptr++) {
        if (*ptr == target) {
            return ptr - arr;  // Return index
        }
    }
    return -1;  // Not found
}

void reverseArray(int *arr, int size) {
    int *start = arr;
    int *end = arr + size - 1;
    
    while (start < end) {
        // Swap elements
        int temp = *start;
        *start = *end;
        *end = temp;
        
        start++;
        end--;
    }
}

int main() {
    int numbers[] = {10, 25, 30, 45, 50};
    int size = 5;
    
    printf("Original array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // Find element
    int index = findElement(numbers, size, 30);
    if (index != -1) {
        printf("Element 30 found at index: %d\n", index);
    }
    
    // Reverse array
    reverseArray(numbers, size);
    printf("Reversed array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    return 0;
}
Key Points:
  • Pointer arithmetic is scaled by the size of the data type
  • Adding 1 to an int pointer moves it by sizeof(int) bytes
  • Pointer subtraction gives the number of elements between pointers
  • Only pointers to the same array should be compared or subtracted
← Pointers Dynamic Memory →

Frequently Asked Questions

C is a powerful, general-purpose programming language that's been around since the 1970s. It's the foundation for many modern languages and is essential for system programming, embedded systems, and understanding how computers work at a low level. Learning C gives you a solid foundation in programming fundamentals.

No prior programming experience is required! Our C programming tutorial is designed for complete beginners. We start with the basics and gradually progress to more advanced topics. However, having some basic computer literacy and logical thinking skills will be helpful.

You need a C compiler to run C programs. For beginners, we recommend using our online C compiler which requires no installation. For local development, you can use GCC (GNU Compiler Collection) which is available on Windows (via MinGW), macOS (via Xcode), and Linux. IDEs like Code::Blocks, Dev-C++, or Visual Studio Code are also helpful.

The time to learn C depends on your dedication and prior experience. With consistent practice (1-2 hours daily), you can grasp the basics in 2-4 weeks and become proficient in 2-3 months. Mastering advanced concepts like pointers, memory management, and data structures may take 6-12 months of regular practice.

C programming skills open doors to various career paths including system programming, embedded systems development, operating system development, device driver programming, game development, and firmware development. Many companies in automotive, aerospace, telecommunications, and IoT sectors actively seek C programmers.

Absolutely! C remains highly relevant and is consistently ranked among the top programming languages. It's essential for system programming, embedded systems, IoT devices, and performance-critical applications. Many modern languages are built on C, and understanding C helps you become a better programmer overall.