C PROGRAMMING

A data type is an attribute that specifies the kind of data a variable can hold,
determining its possible values, the operations that can be performed on it,
and its memory requirements.
Data types, such as
• integers (whole numbers),
• strings (text), and
• booleans (true/false),
are fundamental in computer science and programming for correctly
interpreting, processing, and storing data, preventing errors, and optimizing
performance.
Data types in C classify the type of values a variable can hold and
determine the operations that can be performed on them.
They are broadly categorized into three main types:

• Primary (or Basic) Data Types:

These are the fundamental building blocks.

• int: Stores whole numbers (integers),

e.g., 5, -100. Can be modified with short, long, signed,
and unsigned.

• char: Stores single characters,

e.g., 'a', '7', '$'. Can be signed or unsigned.

• float: Stores single-precision floating-point numbers (numbers

with decimal points),
e.g., 3.14, -0.5.
 • double: Stores double-precision floating-point numbers,
offering greater precision than float.

• void: A special type indicating the absence of a value, often used

as a function return type or for generic pointers.

Derived Data Types:

These are built upon the primary data types.
• Arrays: Collections of elements of the same data type, accessed by
an index,

• An array is a collection of elements of the same data type stored in

contiguous memory locations.

e.g., int numbers[5].

• Pointers: A pointer is a variable that stores the memory address of

another variable.
• Functions: Blocks of code designed to perform a specific task,
which can also be considered a type in C.
• A function pointer is a pointer that stores the memory address of a
function. This allows functions to be passed as arguments to other
functions, stored in data structures, or invoked dynamically.

1.Arrays and Pointers:

int numbers[] = {10, 20, 30};
int *ptr = numbers; // ptr points to the first element of numbers
printf("First element using array index: %d\n", numbers[0]);
printf("First element using pointer: %d\n", *ptr);
printf("Second element using pointer arithmetic: %d\n", *(ptr +
1));

2. Arrays and Functions

void printArray(int *arr, int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}

int main() {
int myArr[] = {1, 2, 3, 4, 5};
printArray(myArr, 5); // Pass the array (as a pointer) and its size
return 0;
}

3. Function Pointers:
int add(int a, int b) {
return a + b;
}

int subtract(int a, int b) {

return a - b;
}

int main() {
int (*operation)(int, int); // Declare a function pointer

operation = add; // Assign the address of the add function

printf("Addition: %d\n", operation(10, 5));
 operation = subtract; // Assign the address of the subtract
function
printf("Subtraction: %d\n", operation(10, 5));
return 0;
}

User-Defined Data Types:

• These are created by the programmer to define custom data
structures.
• Structures (struct): Allow grouping of different data types under a
single name, creating complex data structures.
• Unions (union): Similar to structures but allow different members
to share the same memory location.
• Enumerations (enum): Define a set of named integer constants,
improving code readability.
Understanding these data types is crucial for effective
programming in C, as they dictate how data is stored,
manipulated, and interpreted by the compiler.

struct Student {
char name[50];
int roll_number;
float marks;
};
 ******
#include <stdio.h>

int main() {
// Declare and initialize variables
int integerVar = 10;
char charVar = 'A';
float floatVar = 3.14f; // 'f' suffix indicates a float literal
double doubleVar = 1.23456789;

// Print the values

printf("Integer variable: %d\n", integerVar);
printf("Character variable: %c\n", charVar);
printf("Float variable: %f\n", floatVar);
printf("Double variable: %lf\n", doubleVar); // Use %lf for double

return 0;
}

*#include <stdio.h>

int main() {
printf("Size of int: %zu bytes\n", sizeof(int));
printf("Size of char: %zu byte\n", sizeof(char));
 printf("Size of float: %zu bytes\n", sizeof(float));
printf("Size of double: %zu bytes\n", sizeof(double));

return 0;
}
*#include <stdio.h>
In main() {
int num;
char grade;
float price;
double amount;

printf("Enter an integer: ");

scanf("%d", &num);

printf("Enter a character: ");

scanf(" %c", &grade); // Space before %c to consume leftover newline

printf("Enter a float price: ");

scanf("%f", &price);

printf("Enter a double amount: ");

scanf("%lf", &amount); // Use %lf for double input

printf("\nYou entered:\n");
printf("Integer: %d\n", num);
 printf("Character: %c\n", grade);
printf("Price: %.2f\n", price); // .2f for 2 decimal places
printf("Amount: %.4lf\n", amount); // .4lf for 4 decimal places

return 0;
}

Type modifiers
These keywords can be used to alter the storage size and range of basic integer
and floating-point types.
Integer modifiers
• signed and unsigned: Control whether an integer can hold both positive
and negative values (signed) or only positive values and zero (unsigned).
By default, int is signed.
• short and long: Adjust the amount of memory allocated for an integer.
o short int: Can store small integer values and often uses less
memory than int.
o long int: Can store larger integer values than int.
o long long int: Can store even larger integer values than long int.
• Floating-point modifier
long double: Provides even greater precision than double.

operators in c
Operators in C are symbols that instruct the compiler to perform specific
operations on variables and data, known as operands.
They are fundamental to manipulating data, performing calculations,
making decisions, and controlling program flow.

Here are the main categories of operators in C:

1.Arithmetic Operators:
Used for basic mathematical calculations. + (Addition), - (Subtraction), *
(Multiplication), / (Division), and % (Modulo - remainder after division).
#include <stdio.h>
int main() {
int a = 20, b = 5, result;
result = a + b; // Addition
printf("a + b = %d\n", result);
result = a - b; // Subtraction
printf("a - b = %d\n", result);
result = a * b; //
}
Multiplication
printf("a * b = %d\n", result);
result = a / b; // Division
printf("a / b = %d\n", resul t);
result = a % b; // Modulo (remainder)
printf("a %% b = %d\n", result); // Use to print the % character
return 0;

2. Relational Operators:
Used to compare two operands and return a boolean result (true or
false).
• == (Equal to)
• != (Not equal to)
• > (Greater than)
• < (Less than)
• >= (Greater than or equal to)
• <= (Less than or equal to)
• #include <stdio.h>
•
• int main() {
• int a = 10, b = 20;
•
• printf("a > b: %d\n", a > b); // Greater than
• printf("a < b: %d\n", a < b); // Less than
• printf("a >= b: %d\n", a >= b); // Greater than or equal to
• printf("a <= b: %d\n", a <= b); // Less than or equal to
• printf("a == b: %d\n", a == b); // Equal to
• printf("a != b: %d\n", a != b); // Not equal to
•
• return 0;
• }

3. Logical Operators:
Used to combine or negate conditional expressions.
• && (Logical AND)
• || (Logical OR)
• ! (Logical NOT)
• #include <stdio.h>
•
• int main() {
• int a = 1, b = 0, c = 1;
•
• // Logical AND (&&): True if both operands are true
• printf("(a && c): %d\n", a && c);
•
• // Logical OR (||): True if at least one operand is true
• printf("(a || b): %d\n", a || b);
•
• // Logical NOT (!): Reverses the logical state
• printf("!b: %d\n", !b);
•
• return 0;
• }
Bitwise operators
These operators perform operations on individual bits of an integer.
c
#include <stdio.h>
 int main() {

int a = 60; // 60 = 0011 1100 in binary

int b = 13; // 13 = 0000 1101 in binary
int result = 0;
result = a & b; // Bitwise AND -> 0000 1100
printf("a & b = %d\n", result
result = a | b; // Bitwise OR -> 0011 1101
printf("a | b = %d\n", result);
result = a ^ b; // Bitwise XOR -> 0011 0001
printf("a ^ b = %d\n", result);
result = ~a; // Bitwise NOT (complement)
printf("~a = %d\n", result);
result = a << 2; // Left shift
printf("a << 2 = %d\n", result);
result = a >> 2; // Right shift
printf("a >> 2 = %d\n", result);
return 0;
}

Assignment operators
Assignment operators are used to assign a value to a variable. The
compound assignment operators combine an arithmetic or bitwise
operation with an assignment.
c
#include <stdio.h>
 int main() {
int a = 10, b = 5;
// Simple assignment
int c = a;
printf("c = a: %d\n", c);
// Add and assign (c = c + b)
c += b;
printf("c += b: %d\n", c);
// Subtract and assign (c = c - b)
c -= b;
printf("c -= b: %d\n", c);
// Multiply and assign (c = c * b)
c *= b;
printf("c *= b: %d\n", c);
// Divide and assign (c = c / b)
c /= b;
printf("c /= b: %d\n", c);
return 0;
}

Increment and decrement operators

These are unary operators that increase or decrease the value of a
variable by one.
c
#include <stdio.h>
 int main() {
int a = 5;
int result_pre, result_post;
// Pre-increment: increments the value before using it
result_pre = ++a;
printf("Pre-increment: ++a -> result: %d, a: %d\n", result_pre, a);
// Reset a
a = 5;
// Post-increment: uses the value, then increments it
result_post = a++;
printf("Post-increment: a++ -> result: %d, a: %d\n", result_post, a);
// Reset a
a = 5;
// Pre-decrement: decrements the value before using it
result_pre = --a;
printf("Pre-decrement: --a -> result: %d, a: %d\n", result_pre, a);
// Reset a
a = 5;
// Post-decrement: uses the value, then decrements it
result_post = a--;
printf("Post-decrement: a-- -> result: %d, a: %d\n", result_post, a);
return 0;
}

Conditional (ternary) operator

 This is a shorthand for an if-else statement and is the only ternary
operator in C.
c
#include <stdio.h>

int main() {
int age = 20;
char eligibility[20];

// condition ? expression_if_true : expression_if_false

age >= 18 ? strcpy(eligibility, "Eligible to vote") : strcpy(eligibility, "Not
eligible to vote");

printf("%s\n", eligibility);

return 0;
}
Use code with caution.

sizeof() operator
The sizeof() operator is a unary operator that returns the size of a data
type or variable in bytes.
c
#include <stdio.h>
int main() {
int my_int;
double my_double;
 char my_char;
printf("Size of int: %zu bytes\n", sizeof(my_int));
printf("Size of double: %zu bytes\n", sizeof(my_double));
printf("Size of char: %zu bytes\n", sizeof(my_char))
return 0;
}

4. Assignment Operators:
Used to assign values to variables.
• = (Simple assignment)
• +=, -=, *=, /=, %= (Compound assignment operators)

5. Increment/Decrement Operators:
Used to increase or decrease the value of a variable by 1. ++
(Increment) and -- (Decrement).

6. Bitwise Operators:
Used to perform operations on individual bits of an integer.
& (Bitwise AND), | (Bitwise OR), ^ (Bitwise XOR), ~ (Bitwise NOT), << (Left
shift), and >> (Right shift).

7. Conditional (Ternary) Operator:

A shorthand for an if-else statement.
• condition ? expression1 : expression2;

8. Special Operators:
sizeof (Returns the size of a variable or data type)
• & (Address-of operator)
• * (Pointer dereference operator)
• , (Comma operator)
What are the 4 types of logical operators?

The logical Boolean operators perform logical operations with bool operands.
The operators include the
unary logical negation ( ! ), binary logical AND ( & ), OR ( | ), and exclusive
OR ( ^ ), and the binary conditional logical AND ( && ) and OR ( || ).

expressions in c
In C programming, an expression is a combination of operators,
operands, and sometimes function calls, that evaluates to a single
value. Essentially, it's a piece of code that computes a result.
Key characteristics of C expressions:

• Operators: Symbols that perform operations (e.g., +, -

, *, /, %, ==, &&, ||, ++, --).

• Operands: The values or variables on which the operators act

(e.g., 5, x, (a + b)).

• Evaluation: Every expression in C evaluates to a value.

• This value can be assigned to a variable, used in another expression, or
passed as an argument to a function.

• No Semicolon: An expression by itself does not end with a semicolon.

• When an expression is followed by a semicolon, it becomes an
expression statement.

Types of Expressions in C:

• Arithmetic Expressions: Perform mathematical calculations.

int sum = a + b;
float product = x * 3.14;
 • Relational Expressions: Compare two operands and evaluate to a
boolean value (true or false, represented as 1 or 0 in C).
int is_equal = (a == b);
int is_greater = (x > y);
• Logical Expressions: Combine relational expressions using logical
operators (&& - AND, || - OR, ! - NOT).
int condition = (age > 18 && has_license);
• Assignment Expressions: Assign a value to a variable
int x = 10;
y = x + 5;
• Conditional (Ternary) Expressions: A concise way to express an if-
else condition.
int max = (a > b) ? a : b; // If a > b, max = a, else max = b
• Increment/Decrement Expressions: Modify the value of a variable by 1.
x++; // Post-increment
--y; // Pre-decrement
• Pointer Expressions: Involve operations on memory addresses using
pointers.
int *ptr = &my_var;
int value = *ptr;
Expression Evaluation:
Expressions are evaluated based on operator precedence (which operators are
evaluated first) and associativity (how operators of the same precedence are
grouped). Parentheses () can be used to override default precedence.
control structure in c
Control structures in C programming manage the flow of program execution,
enabling decision-making, repetition, and conditional execution of code
blocks. They are categorized into three main types:

1. Decision-Making (Selection) Statements:

These statements allow the program to choose which block of code to execute
based on a condition.

• if statement: Executes a block of code only if a specified condition is

true.
if (condition) {
// code to be executed if condition is true
}

• if-else statement: Executes one block of code if the condition is

true, and another block if the condition is false.
if (condition) {
// code if condition is true
} else {
// code if condition is false
}

• switch statement: Allows for multi-way branching, executing

different blocks of code based on the value of an expression.
switch (expression) {
case value1:
// code for value1
break;
case value2:
 // code for value2
break;
default:
// code if no match
}
**
#include <stdio.h>
int main() {
int num;
printf("Enter an integer: ");
scanf("%d", &num);
if (num > 0) {
printf("%d is positive.\n", num);
} else {
printf("%d is negative or zero.\n", num);
}
return 0;
}
**

switch statement.
This program prints the day of the week based on an integer input.
#include <stdio.h>

int main() {
int day;
printf("Enter a number (1-7) for the day of the week: ");
scanf("%d", &day);

switch (day) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
case 4:
printf("Thursday\n");
break;
case 5:
printf("Friday\n");
break;
case 6:
printf("Saturday\n");
break;
case 7:
printf("Sunday\n");
break;
default:
printf("Invalid day.\n");
 }
return 0;
}

2. Iteration (Looping) Statements:

These statements allow a block of code to be executed repeatedly.

• for loop: Executes a block of code a specific number of times.

for (initialization; condition; increment/decrement) {
// code to be executed repeatedly
}

• while loop: Executes a block of code as long as a specified condition

remains true.
while (condition) {
// code to be executed repeatedly
}

• do-while loop: Executes a block of code at least once, and then

repeatedly as long as a specified condition remains true.
do {
// code to be executed at least once
} while (condition);
**

#include <stdio.h>
int main() {
int i;
for (i = 1; i <= 5; i++) {
printf("%d ", i);
 }
printf("\n");
return 0;
}
while loop.
This program calculates the sum of numbers from 1 to 5 using a while loop.
#include <stdio.h>

int main() {
int i = 1, sum = 0;
while (i <= 5) {
sum += i;
i++;
}
printf("Sum of numbers from 1 to 5: %d\n", sum);
return 0;
}
do-while loop.
This program prompts the user to enter a positive number, ensuring at least
one input using a do-while loop.
#include <stdio.h>

int main() {
int num;
do {
printf("Enter a positive number: ");
scanf("%d", &num);
 } while (num <= 0);
printf("You entered: %d\n", num);
return 0;
}

3. Jump Statements:
These statements alter the normal sequential flow of execution within a loop
or function.

• break statement:
Terminates the current loop (or switch statement) and transfers control to the
statement immediately following the loop/switch.

• continue statement:
Skips the rest of the current iteration of a loop and proceeds to the next
iteration.

• goto statement:
Transfers control unconditionally to a labeled statement within the same
function. Its use is generally discouraged due to potential for creating
unstructured and hard-to-read code.
break Statement.
This program demonstrates break to exit a loop early when a specific condition
is met.
#include <stdio.h>

int main() {
int i;
for (i = 1; i <= 10; i++) {
if (i == 5) {
 break; // Exit the loop when i is 5
}
printf("%d ", i);
}
printf("\n");
return 0;
}
continue statement.
This program demonstrates continue to skip the current iteration of a loop.
#include <stdio.h>

int main() {
int i;
for (i = 1; i <= 5; i++) {
if (i == 3) {
continue; // Skip printing when i is 3
}
printf("%d ", i);
}
printf("\n");
return 0;
}