Introduction to C Programming:

C is a powerful general-purpose programming language developed in the early 1970s by Dennis Ritchie at
Bell Laboratories. Known for its efficiency, simplicity, and flexibility, C is widely used in various fields,
from operating systems to embedded systems. It is considered a foundational language in computer science,
providing a stepping stone for learning other programming languages and understanding computer
architecture.

C allows for low-level memory manipulation, making it suitable for developing operating systems and
complex software. Its portability enables programs written in C to be compiled and run on different types of
computer systems with little to no modification.

Key Features of C Language:

Efficiency: C is known for its speed and efficiency, making it ideal for performance-intensive applications.

Portability: C code can be compiled and executed on various computer architectures.

Modularity: C supports modular programming through functions, which helps in organizing code and
reusing functionality.

Flexibility: C allows for both high-level programming constructs and low-level access to memory.

Rich Library: The C Standard Library offers numerous built-in functions for common tasks.

History of C Language:

The C language was developed as an enhancement to the B programming language. Dennis Ritchie and
Brian Kernighan improved on B by adding structures, data types, and richer functionality. This resulted in
the C language, which became popular with the development of the Unix operating system, as C was used to
implement much of Unix. The language was later standardized by ANSI in 1989, creating ANSI C, which
became widely adopted.

Over the years, various standards for C have been introduced, such as C90, C99, C11, and C18, each
bringing improvements in language features, performance, and support for new programming paradigms.

Basic Structure of a C Program:

A C program consists of one or more functions, with the main() function serving as the entry point. The
structure of a simple C program includes:

#include <stdio.h>

int main() {

printf(“Hello, World!”);

return 0;

}
Explanation:

#include <stdio.h>: This line includes the standard input-output library, which provides the printf function.

int main(): The main function is where execution begins.

printf(“Hello, World!”);: This line outputs “Hello, World!” to the screen.

return 0;: This line indicates that the program has executed successfully.

Variables and Data Types:

Variables in C are placeholders for storing data. Each variable has a data type that defines the kind of data it
can hold, such as integers, floating-point numbers, or characters.

Common Data Types in C:

Int: Used for integer values (e.g., int age = 25;).

Float: Used for single-precision floating-point numbers (e.g., float price = 9.99;).

Double: Used for double-precision floating-point numbers.

Char: Used for characters (e.g., char initial = ‘A’;).

Declaring and Initializing Variables:

Variables must be declared before they are used. Initialization assigns an initial value to a variable. E.g.

int age = 25;

float salary = 50000.00;

char grade = ‘A’;

Operators in C:

C supports various operators for performing arithmetic, logical, relational, and assignment operations.
Operators are essential for manipulating data and performing calculations in a program.

Types of Operators:

1. Arithmetic Operators: +, -, *, /, %
2. Relational Operators: ==, !=, >, <, >=, <=
3. Logical Operators: && (AND), || (OR), ! (NOT)
4. Assignment Operators: =, +=, -=, *=, /=

Example:

int a = 10;

int b = 20;

int sum = a + b;
Control Structures:

Control structures allow for the flow of execution to change based on certain conditions. The main types of
control structures are if statements, for loops, while loops, and do-while loops.

Example: If Statement

int age = 20;

If (age >= 18) {

printf(“You are an adult.\n”);

} else {

printf(“You are a minor.\n”);

Example: For Loop

for (int I = 0; I < 5; i++) {

printf(“Number: %d\n”, i);

Example: While Loop

int i = 0;

While (i< 5) {

printf(“Number: %d\n”, i);

i++;

Functions in C:

Functions are blocks of code designed to perform specific tasks. They help break down complex problems
into smaller, manageable parts, improve code readability, and promote reusability.

Declaring and Calling a Function:

#include <stdio.h>

// Function declaration

int add(int a, int b);

int main() {
 int sum = add(5, 3);

printf(“Sum: %d”, sum);

return 0;

// Function definition

int add(int a, int b) {

return a + b;

Arrays and Pointers:

Arrays are used to store collections of data, while pointers are variables that store the memory address of
another variable.

Declaring an Array:

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

Declaring a Pointer:

int num = 10;

int *ptr = &num;

printf(“Value: %d”, *ptr);

Memory Management:

C provides functions for dynamic memory management, which allows allocating and deallocating memory
at runtime using malloc, calloc, and free.

Example-

#include <stdlib.h>

int *arr = (int*)malloc(5 * sizeof(int));

if (arr == NULL) {

printf(“Memory allocation failed.”);

} else {

// Use memory

free(arr); // Deallocate memory

Keywords:

In C, keywords are reserved words that have special meaning to the compiler. These words cannot be used
as variable names, function names, or any other identifiers in a C program. They are predefined by the
language and perform specific functions. Here are the keywords in C:

1. Auto – Declares automatic (local) variables.

2. Break – Exits a loop or switch statement.
3. Case – Used in switch statements to mark a block of code for a specific value.
4. Char – Declares a character data type.
5. Const – Declares constant (read-only) variables.
6. Continue – Skips the current iteration of a loop and continues with the next one.
7. Default – Specifies the default block in a switch statement if no cases match.
8. Do – Begins a do…while loop, which executes at least once.
9. Double – Declares a double-precision floating-point data type.
10. Else – Provides an alternative block of code in an if statement.
11. Enum – Declares an enumeration, a set of named integer constants.
12. Extern – Declares an external variable or function.
13. Float – Declares a single-precision floating-point data type.
14. For – Begins a for loop.
15. Goto – Jumps to a labeled statement.
16. If – Begins an if conditional statement.
17. Int – Declares an integer data type.
18. Long – Declares a long integer data type.
19. Register – Suggests that the variable be stored in a CPU register for faster access.
20. Return – Exits a function and optionally returns a value.
21. Short – Declares a short integer data type.
22. Signed – Declares a signed data type, capable of holding positive and negative values.
23. Sizeof – Returns the size (in bytes) of a data type or variable.
24. Static – Declares a variable that retains its value between function calls or a function that limits its
scope to the file.
25. Struct – Declares a structure, a user-defined data type that groups different data types.
26. Switch – Begins a switch statement for multi-way branching.
27. Typedef – Defines an alias for an existing data type.
28. Union – Declares a union, a user-defined data type that allows storing different data types in the
same memory location.
29. Unsigned – Declares an unsigned data type, capable of holding only non-negative values.
30. Void – Declares a function with no return type or a pointer with no data type.
31. Volatile – Prevents the compiler from optimizing a variable’s storage.
 32. While – Begins a while loop.

These keywords form the backbone of C syntax and are essential for writing C programs.

Strings:

In C, a string is a sequence of characters terminated by a special character called the null character (‘\0’).
This null character marks the end of the string, allowing functions to determine the length of the string by
looking for ‘\0’. Unlike some other programming languages, C does not have a specific data type for strings;
instead, strings are represented as arrays of characters.

Declaring and Initializing Strings:

In C, you can declare and initialize a string in two main ways:

1. Using a character array:

char name[6] = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\0’};

Here, we explicitly define each character, ending with ‘\0’.

2. Using a string literal:

char name[] = “Hello”;

In this case, C automatically adds the null character at the end of the string.

Working with Strings:

Since strings are arrays of characters, you can manipulate them using array notation and standard C library
functions, which are defined in <string.h>. Here are some commonly used string functions:

strlen(): Finds the length of a string (excluding the null character).

E.g. int length = strlen(name);

strcpy(): Copies one string to another.

E.g. char destination[20];

strcpy(destination, name); // Copies “Hello” into destination

strcat(): Concatenates (joins) two strings.

E.g. char greeting[20] = “Hello, “;

strcat(greeting, “world!”); // Results in “Hello, world!”

strcmp(): Compares two strings lexicographically.

E.g. int result = strcmp(“apple”, “banana”); // Returns negative, zero, or positive

Example-

Here’s a simple example of using strings in a program:

#include <stdio.h>

#include <string.h>

int main() {

char greeting[20] = “Hello”;

printf(“Original Greeting: %s\n”, greeting);

strcat(greeting, “, World!”); // Concatenate strings

printf(“Updated Greeting: %s\n”, greeting);

printf(“Length of Greeting: %lu\n”, strlen(greeting)); // Get string length

return 0;

Input and output functions:

In C programming, input and output (I/O) operations allow interaction with the user or other systems, such
as reading data from the keyboard or displaying results on the screen. The most common methods for input
and output in C are through functions in the Standard Input/Output library, <stdio.h>.

Basic Input and Output Functions-

1 Printf() – Used for output (printing text or values) to the screen.

2 Scanf() – Used for input (reading values) from the user.

1. Printf() – Output Function

The printf() function is used to display text and variables on the screen. It takes a format string as its first
argument, which can include text as well as format specifiers to indicate where variable values should be
displayed.

Syntax-

Printf(“format string”, variables…);

Common Format Specifiers-

%d or %i – for integers

%f – for floating-point numbers

%c – for characters

%s – for strings

Example-

#include <stdio.h>

int main() {

int age = 25;

float height = 5.9;

char grade = ‘A’;

printf(“Age: %d\n”, age);

printf(“Height: %.1f feet\n”, height); // .1 for one decimal place

printf(“Grade: %c\n”, grade);

return 0;

2. Scanf() – Input Function

The scanf() function is used to read user input from the keyboard. Similar to printf(), scanf() uses format
specifiers to determine the type of data being read.

Important: When using scanf() with variables, you must use the address-of operator (&) to pass the memory
address of the variable, except for strings.

Syntax-

Scanf(“format string”, &variables…);

Example-

#include <stdio.h>

int main() {

int age;

float height;

char grade;
 printf(“Enter your age: “);

scanf(“%d”, &age);

printf(“Enter your height in feet: “);

scanf(“%f”, &height);

printf(“Enter your grade: “);

scanf(“ %c”, &grade); // Space before %c to skip any newline character

printf(“You entered: Age=%d, Height=%.1f, Grade=%c\n”, age, height, grade);

return 0;

Important Points:

Whitespace Handling: scanf() stops reading when it encounters whitespace (like spaces, tabs, newlines), so
be careful with multiple inputs.

Buffering: The newline (‘\n’) from previous inputs can sometimes cause issues, especially with char input.
Adding a space before %c can help avoid this.

Error Handling: scanf() returns the number of items successfully read, so you can use it to check if the input
was correct.

Example Program: Input and Output

Here’s a simple program that takes user input and displays it back to them.

#include <stdio.h>

int main() {

char name[50];

int age;

float salary;

printf(“Enter your name: “);

scanf(“%s”, name); // No & for strings

printf(“Enter your age: “);

scanf(“%d”, &age);

printf(“Enter your salary: “);

scanf(“%f”, &salary);

printf(“Name: %s\n”, name);

printf(“Age: %d\n”, age);

 printf(“Salary: $%.2f\n”, salary);

return 0;

}
Constants:

In C programming, constants are fixed values that do not change during the execution of a program. They
are defined with specific keywords or syntax, allowing programmers to use values that remain constant
throughout the code.

Types of Constants in C-

1. Literal Constants
2. Const Keyword Constants
3. #define Macro Constants
4. Enumerated Constants (using enum)

1. Literal Constants

Literal constants are direct values assigned in the code without using any variables or symbols. Examples
include:

Integer literals: 10, -42

Floating-point literals: 3.14, 0.001

Character literals: ‘A’, ‘%’

String literals: “Hello, World!”

Example:

int age = 30; // Integer literal

float pi = 3.14; // Floating-point literal

char grade = ‘A’; // Character literal

2. Constants with the const Keyword

The const keyword creates a read-only variable, meaning the value cannot be changed once it’s assigned.
This is useful when you need a variable to hold a fixed value that should not be modified.

Syntax-

const data_type variable_name = value;

Example-

const int maxStudents = 50;

const float pi = 3.14159;

In this example, maxStudents and pi are constants, so attempting to modify them later in the code will result
in a compiler error.

3. Constants with #define Macro

The #define preprocessor directive allows you to create symbolic constants, which are replaced by their
values during preprocessing before the actual compilation. #define does not consume memory for storage, as
it performs a text substitution.

Syntax-

#define CONSTANT_NAME value

Example-

#define MAX_STUDENTS 50

#define PI 3.14159

In this example, every occurrence of MAX_STUDENTS or PI in the code is replaced with 50 and 3.14159,
respectively, before the code is compiled.

4. Enumerated Constants (enum)

An enum (enumeration) is a user-defined data type in C that consists of a set of named integer constants.
Enumerations make code more readable and manageable by using names instead of numbers.

Syntax-

enum enum_name { constant1, constant2, … };

Example-

enum Days { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY

};

In this example, each day is assigned an integer value starting from 0 (i.e., MONDAY = 0, TUESDAY = 1,
etc.).