C PROGRAMMING AND DATA STRUCTURES

----------------------------------------------PART-II--------------------------------------------------

UNIT - I
Introduction to Computers – Computer Systems, Computing Environments, Computer
Languages,Creating and running programs, Software Development.

Computer Systems:
A computer system consists of hardware and software components that work
together to perform tasks. In the context of C Programming and Data Structures,
understanding the computer system is crucial for efficient programming and
memory management.

 Hardware: The physical parts of the computer system (e.g., CPU, memory,
input/output devices).
 Software: The programs and applications that run on the computer (e.g.,
operating systems, compilers, application software).

CPU executes instructions and processes data.

memory stores data and instructions for quick access

input/output devices allow communication between the computer and the

external world (e.g., keyboard, mouse, screen).

An operating system manages hardware and software resources

compiler translates high-level code into machine code

 application software performs specific tasks for users, like word processing
or browsing the web.

Computing Environments:

A computing environment refers to the collection of hardware,

software, and network resources that support computing activities. It
includes the physical components (like servers, desktops, and mobile
devices), the operating systems and applications that run on them, and
the network infrastructure that connects them. Different computing
environments can vary based on their scale (e.g., personal, enterprise, or
cloud), purpose (e.g., development, production, or testing), and
configuration (e.g., single-user systems, multi-user systems, or
distributed systems). Key examples include personal computing
environments, client-server environments, and cloud computing
environments. Each provides a unique context for how users interact
with and manage resources.
Types of Computing Environments:
Computer Languages:
To write a program for a computer, we must use a computer language. Over the
years computer languages have evolved from machine languages to natural
languages.
1940’s ----Machine level Languages .
1950’s---- Symbolic Languages .
1960’s---- High-Level Languages.
Machine Languages In the earliest days of computers, the only programming
languages available were machine languages. Each computer has its own machine
language, which is made of streams of 0’s and 1’s. Instructions in machine
language must be in streams of 0’s and 1’s because the internal circuits of a
computer are made of switches transistors and other electronic devices that can
be in one of two states: off or on. The off state is represented by 0 , the on state is
represented by 1. The only language understood by computer hardware is
machine language.
Symbolic Languages: In early 1950’s Admiral Grace Hopper, A mathematician and
naval officer developed the concept of a special computer program that would
convert programs into machine language The early programming languages
simply mirror to the machine languages using symbols of mnemonics to represent
the various machine language instructions because they used symbols, these
languages were known as symbolic languages. Computer does not understand
symbolic language it must be translated to the machine language. A special
program called assembler translates symbolic code into machine language.
Because symbolic languages had to be assembled into machine language they
soon became known as assembly languages. Symbolic language uses symbols or
mnemonics to represent the various ,machine language instructions.
High Level Languages: Symbolic languages greatly improved programming
effificiency; they still required programmers to concentrate on the hardware that
they were using. Working with symbolic languages was also very tedious because
each machine instruction has to be individually coded. The desire to improve
programmer efficiency and to change the focus from the computer to the
problem being solved led to the development of high-level language. High level
languages are portable to many different computers, allowing the programmer to
concentrate on the application problem at hand rather than the intricacies of the
computer. High-level languages are designed to relieve the programmer from the
details of the assembly language. High level languages share one thing with
symbolic languages, They must be converted into machine language. The process
of converting them is known as compilation. The first widely used high-level
languages, FORTRAN (FORmula TRANslation)was created by John Backus and an
IBM team in 1957;it is still widely used today in scientific and engineering
applications. After FORTRAN was COBOL(Common Business-Oriented Language).
Admiral Hopper was played a key role in the development of the COBOL Business
language. C is a high-level language used for system software and new application
code.

Creating and Running Programs

1. Writing the Code

The first step in creating a program is to write the source code. This is the set of
instructions that tell the computer what to do.

Steps:

 Choose a Programming Language: Select a language based on the task.

Popular languages include Python, C, Java, JavaScript, and many more.
 Write Code in a Text Editor or IDE:
o A Text Editor (e.g., Sublime Text, Notepad++) allows you to write
code in plain text.
o An Integrated Development Environment (IDE) (e.g., Visual
Studio, Eclipse, PyCharm) is a software that provides tools like syntax
highlighting, debugging, and project management for writing and
managing code.

Example (Python):
print("Hello, World!")

2. Saving the Program

After writing the code, save the file with the correct file extension corresponding
to the language you're using.

 For Python, save the file as filename.py.

 For Java, save it as filename.java.
  For C, save it as filename.c.

3. Compiling the Program (For Compiled Languages)

If you are using a compiled language (e.g., C, C++, Java), you will need to
compile the source code into machine code before it can be executed. Compilation
translates human-readable code into an executable file that can be run by the
operating system.

Steps:

 Compiler: Use a compiler to convert the source code into a machine-

readable file.
o C/C++: gcc filename.c -o filename (For C) or g++ filename.cpp
-o filename (For C++).
o Java: javac filename.java (compiles to bytecode, saved as
filename.class).
 Error Checking: During compilation, errors or warnings may appear,
indicating issues in the code (e.g., syntax errors, missing files). You’ll need
to fix these before proceeding.

4. Interpreting the Program (For Interpreted Languages)

For interpreted languages (e.g., Python, JavaScript), the code is not compiled into
an executable first. Instead, an interpreter reads and executes the code directly.

 Python: You don't need to compile the code. Just use the python command
to run it:
 python filename.py

5. Running the Program

Once your program is compiled or interpreted, you can run it to see the results.

Steps:

 For Compiled Languages: After compiling, run the resulting executable.

o C/C++: On Unix-like systems (Linux/Mac), use:
o ./filename # Run the compiled executable

On Windows, just type filename in the Command Prompt.

 o Java: After compiling with javac, run the bytecode with the Java
Virtual Machine (JVM):
o java filename # Do not use the `.class` extension
 For Interpreted Languages: Use the interpreter to directly run the script, as
shown above for Python.

6. Debugging the Program

If the program does not behave as expected, you’ll need to debug it. Common
errors might include syntax errors, logical errors, or runtime errors.

Debugging Tools:

 Print Statements: Use print() (or similar) to trace variable values or the
flow of execution.
 Debugger: Most IDEs come with a built-in debugger that allows you to step
through code, inspect variables, and set breakpoints.
 Error Messages: Read the error message carefully; they often indicate the
source of the problem (e.g., syntax error, file not found).

7. Optimizing the Program

Once the program is running, you may want to optimize it for performance or
readability.

Optimization Tips:

 Refactor Code: Simplify complex code, split large functions, or remove

redundant code.
 Efficient Algorithms: Use more efficient algorithms or data structures if
necessary.
 Memory Usage: Check for memory leaks or inefficient memory usage.

8. Running the Program in Different Environments

Programs may behave differently depending on the environment (e.g., operating

system, hardware, or software configurations). Ensure your program is tested and
runs correctly across environments:

 Cross-platform Languages: Languages like Python, JavaScript, and Java

can be run on multiple platforms without modification.
  Platform-Specific Issues: For compiled languages like C or C++, ensure
your program compiles and runs correctly on different operating systems
(e.g., Windows vs. Linux).

9. Packaging the Program

If you plan to distribute the program to others or deploy it to production, you may
need to package it:

 Executable Files: For compiled programs, package the executable files

along with any necessary libraries.
 Installers: Use tools like Inno Setup (Windows) or pkg (macOS) to create
installers.
 Web Deployment: For web-based programs, you’ll need to host the
application on a web server and ensure the client-side and server-side parts
are working together.

Summary of Steps

1. Write the Code: Using a text editor or IDE.

2. Save the Code: With the appropriate file extension.
3. Compile (If Required): For languages like C, C++, or Java.
4. Interpret (If Required): For languages like Python or JavaScript.
5. Run the Program: Using the command line or IDE.
6. Debug: Fix errors as they arise.
7. Optimize: Improve the program for performance and readability.
8. Test in Different Environments: Ensure the program works on multiple platforms.
9. Package and Distribute: If needed, package the program for others to run.

This is a general process, and specific steps may vary depending on the programming language,
tools, and development environment you are using.
Here’s a flowchart representation of the process for creating and running a program:

Write the Code

Save the File

Compile the Program?

Compile the Code

Run the Program

Debug the Program

Debug the Code

Optimize the Code?

Test in Different

Test on Platforms

Package & Deploy?

Package/Deploy

End (Program Ready

Software Development:
In today's fast-paced digital world, software development is a critical driver of
innovation and business success. From small startups to large enterprises, software
systems are at the heart of nearly every business operation, providing functionality,
efficiency, and scalability.

The journey of software development spans a variety of stages, from gathering

initial requirements and designing the architecture, to coding, testing, and
deployment. Each of these phases is essential for creating reliable, secure, and
user-friendly software that meets the needs of end-users and stakeholders.

The choice of software development methodology—whether Agile, Waterfall,

DevOps, or others—greatly influences the way teams approach problem-solving,
collaboration, and adaptability. Agile methodologies such as Scrum and Kanban
offer flexibility, frequent iteration, and continuous feedback, allowing developers
to quickly adapt to changing requirements. On the other hand, more structured
approaches like Waterfall can be effective for projects with clear, unchanging
goals.

----------------------------------------------PART-II--------------------------------------------------
Introduction to C Language – Background, Simple C programs, Identifiers, Basic data
types,Variables, Constants, Input / Output

INTRODUCTION TO ‘C’ LANGUAGE:

C is a general-purpose, high-level programming language that was developed by
Dennis Ritchie in the early 1970s at Bell Labs. Known for its simplicity and
efficiency, C has become one of the most widely used languages in software
development. It is particularly popular for system programming, such as creating
operating systems, compilers, and embedded systems.
C is considered a procedural programming language, meaning it follows a series
of steps or procedures in a linear sequence. Its syntax is straightforward and allows
direct access to memory through pointers, which makes it powerful but also
requires careful management to avoid errors like memory leaks.
Although low-level compared to modern languages like Python or Java, C gives
programmers fine control over system resources, making it ideal for performance-
critical applications. Many modern programming languages, such as C++, Java,
and Python, are based on or influenced by C. It remains a fundamental language
for learning programming concepts.

Background of C Language

The C programming language was created in the early 1970s by Dennis Ritchie
at Bell Labs, as part of the development of the Unix operating system. Before C,
the Unix system was written in assembly language, which made it difficult to
maintain and modify. Ritchie and his colleague Brian Kernighan wanted a
language that could combine the efficiency of assembly with the simplicity and
readability of higher-level languages.
C was designed to be a portable, system-level language, allowing Unix to run on
different hardware platforms. It was inspired by earlier languages like BCPL and
B (which was also developed at Bell Labs by Ken Thompson), but C offered
improved features such as structured programming, data abstraction, and low-level
memory access.
In 1978, Kernighan and Ritchie published the influential book "The C
Programming Language", which popularized the language and set the foundation
for its widespread adoption. Over time, C became a standard for system
programming and has influenced the development of many other languages,
including C++, Java, C#, and Objective-C.
C's portability and efficiency remain central to its enduring relevance, especially
in contexts like operating systems, embedded systems, hardware drivers, and
compilers.

Simple C programs:

2. Addition of Two Numbers

3. Find the Largest of Three Numbers

Sample Input: Enter three numbers: 15 25 10

Expected Output: The largest number is: 25

4.Find the Factorial of a Number

Sample Input: Enter a number: 5

Expected Output: Factorial of 5 is 120

Fibonacci Sequence (First N Terms)

Sample Input: Enter the number of terms: 6

Expected Output: Fibonacci Sequence: 0 1 1 2 3 5

IDENTIFIERS :
What is an Identifier?
An identifier is a name given to a program element. It helps in identifying a
variable, function, or other components in the program. For example, in the code
int age = 25;, age is an identifier representing a variable.

Rules for Creating Identifiers in C:

1. Starting Character:
o An identifier must start with a letter (either lowercase a-z or uppercase
A-Z) or an underscore (_).
o It cannot start with a digit (e.g., 1value is invalid).
Valid Examples:
o age, _count, num1
Invalid Examples:
o 1total, @value
2. Subsequent Characters:
o After the first character, an identifier can include letters, digits (0-9),
and underscores (_).
Valid Examples:
o total_Amount, var123, sum_2
Invalid Example:
o total@amount
3. No Reserved Keywords:
o You cannot use reserved keywords (also called keywords) as
identifiers. These are words that have a special meaning in C, such as
int, return, for, etc.
Invalid Examples:
o int, while, return
4. Case Sensitivity:
o C is a case-sensitive language. This means age, Age, and AGE are
considered three different identifiers.
Valid Examples:
o age, Age, AGE (all are distinct identifiers)
5. Length of Identifiers:
 o While there’s no strict limit on the length of an identifier, most C
compilers support identifiers with up to 31 characters (as per the
ANSI C standard). However, it's always better to keep identifiers
meaningful but concise for readability.

Tips for Naming Identifiers:

1. Descriptive Names:
o Choose meaningful names for variables and functions so that anyone
reading the code can understand what they represent. For example:
 totalAmount is better than t or a.
 calculateAverage is better than calcAvg.
2. Use CamelCase for Variables and Functions:
o In CamelCase, the first word starts with a lowercase letter, and each
subsequent word starts with an uppercase letter. This is commonly
used in C for variables and functions.
 Example: totalAmount, calculateSum
3. Use Uppercase for Constants:
o Constants and macros are usually written in uppercase letters to
distinguish them from regular variables. Use underscores to separate
words in constants.
 Example: MAX_SIZE, PI
4. Avoid Using Single-Character Identifiers:
o Unless necessary (e.g., loop variables like i or j), avoid using single-
character identifiers, as they don’t describe the purpose of the
variable. This helps with code readability.
Better Examples:
o totalAmount instead of t
o userName instead of n

Examples of Identifiers:
1. Variables:
int age = 25; // 'age' is an identifier representing an integer variable
float salary = 50000.50; // 'salary' is an identifier representing a floating-point
variable
2. Functions:
void displayMessage() { // 'displayMessage' is an identifier for a function
printf("Hello, World!\n");
}
3. Arrays:
int numbers[10]; // 'numbers' is an identifier for an array of integers
4. Structures:
struct Person { // 'Person' is an identifier for a structure
char name[50];
int age;
};

Invalid Identifier Examples in C:

Invalid Identifier Reason
int 123value; Starts with a number (invalid).
float return; Uses a keyword (return) as an identifier (invalid).
int * pointer@value; Contains an invalid character @ (invalid).
int sum-amount; Contains a hyphen (-), which is not allowed (invalid).

Conclusion:
In C programming, identifiers are the building blocks for naming variables,
functions, and other program components. Following the rules for naming
identifiers ensures that your code is error-free, readable, and maintainable.
Using descriptive names and adhering to common conventions like CamelCase
and uppercase constants can make your code much clearer for others (and
yourself) to understand.
By carefully choosing your identifiers, you can avoid errors, improve readability,
and ensure that your C programs are well-structured and easy to debug.

Data Types
In C programming, data types are used to define the type of data that a variable
can hold. Understanding data types is fundamental because they define how much
memory is allocated for a variable and what kind of operations can be performed
on it. C provides several built-in or basic data types that are used to represent
different types of data.

Types of Basic Data Types in C

C supports a variety of data types, primarily classified into:
1. Primitive Data Types (Built-in Types):
o These are the most common data types provided by C, such as
integers, floating-point numbers, characters, etc.
2. Derived Data Types:
o These are types derived from basic data types, such as arrays,
pointers, structures, etc.
 3. Enumeration and Void:
o C also has enumeration types (enums) and the void type, which have
specific purposes.

1. Integer Data Types

Integer types are used to store whole numbers (positive or negative) without
decimal points.
 int: Represents a basic integer type.
o Size: Typically 4 bytes on modern systems.
o Range: Depends on the system, but typically -32,768 to 32,767 for a
16-bit system, and -2,147,483,648 to 2,147,483,647 for a 32-bit
system.
Example: int age = 25;
 short int (or just short): A smaller integer type, usually 2 bytes.
o Range: Typically -32,768 to 32,767 for 16-bit systems.
Example: short int score = 100;
 long int (or just long): A larger integer type, typically 4 or 8 bytes,
depending on the system.
o Range: Typically -2,147,483,648 to 2,147,483,647 (for 32-bit) or -
9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 (for 64-bit
systems).
Example: long int population = 7600000000;
 long long int (or just long long): A 64-bit integer type.
o Range: Typically -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807.
Example: long long int distance = 123456789012345LL;

2. Floating-Point Data Types

Floating-point types are used to store real numbers (i.e., numbers with decimal
points). These types are primarily used for scientific calculations, measurements,
and more.
 float: A single-precision floating-point type.
o Size: Typically 4 bytes.
o Range: Approximately 1.5 × 10^−45 to 3.4 × 10^38 with 6-7 digits of
precision.
Example: float temperature = 36.5;
 double: A double-precision floating-point type, which offers more precision
than float.
o Size: Typically 8 bytes.
 o Range: Approximately 5.0 × 10^−324 to 1.7 × 10^308 with 15-16
digits of precision.
Example: double pi = 3.14159265358979;
 long double: An extended precision floating-point type (depends on the
system, usually 10-12 bytes).
o Range: Larger than double, with more precision.
Example: long double scientificValue = 1.23456789L;

3. Character Data Type

Character types are used to store individual characters (letters, digits, symbols,
etc.).
 char: Used to store a single character.
o Size: Typically 1 byte (8 bits).
o Range: Can store values from -128 to 127 (signed) or 0 to 255
(unsigned).
Example: char grade = 'A';
o Note: In C, char is often treated as an integer type because it can store
numeric values between -128 and 127 or 0 to 255 (depending on
whether it's signed or unsigned).

4. Void Data Type

The void type is a special data type that represents no type. It is used in the
following situations:
 Function Return Type: When a function does not return any value, its
return type is declared as void.
Example:
void printMessage() {
printf("Hello, World!\n");
}
 Pointer Type: A pointer of type void* can hold the address of any data type.
Example: void* ptr; (a pointer that can point to any type of data).

5. Size of Data Types

The size of the basic data types may vary depending on the machine architecture
(32-bit or 64-bit systems). However, here is a general idea:
Data Size
Range
Type (bytes)
char 1 -128 to 127 (signed) or 0 to 255 (unsigned)
int 4 -2,147,483,648 to 2,147,483,647
short 2 -32,768 to 32,767
 Data Size
Range
Type (bytes)
-2,147,483,648 to 2,147,483,647 (32-bit) or -9.2 × 10^18 to
long 4 or 8
9.2 × 10^18 (64-bit)
long long 8 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
float 4 1.5 × 10^−45 to 3.4 × 10^38 (6-7 digits precision)
double 8 5.0 × 10^−324 to 1.7 × 10^308 (15-16 digits precision)
long
10–12 Larger than double (platform-dependent)
double

Summary of Basic Data Types in C:

Data Type Description
char Used for storing single characters (1 byte)
int Used for storing integers (4 bytes)
float Used for storing floating-point numbers (4 bytes)
double Used for storing double-precision floating-point numbers (8 bytes)
long Used for storing larger integers (4 or 8 bytes)
long long Used for storing even larger integers (8 bytes)
void Represents no data type or absence of return value

Conclusion:
In C programming, choosing the appropriate data type is essential for efficient
memory use and performance. By selecting the right data type (such as int for
whole numbers, float for decimal numbers, or char for characters), you ensure that
your program runs effectively and uses memory appropriately. C’s basic data types
allow you to handle a wide variety of tasks, from simple calculations to complex
systems programming.

Operators in C Programming(NOT IN SYLLABUS)

Operators in C Programming
In C, operators are special symbols that perform specific operations on one, two,
or more operands. They are used to manipulate data and variables. Operators are
fundamental to programming and allow you to carry out various operations such as
mathematical calculations, comparisons, and logical evaluations.

Types of Operators in C
Operators in C are classified into the following categories:
1. Arithmetic Operators
2. Relational (Comparison) Operators
3. Logical Operators
4. Bitwise Operators
5. Assignment Operators
6. Increment and Decrement Operators
7. Conditional (Ternary) Operator
8. Special Operators (Sizeof, Comma, Pointer Operators)

1. Arithmetic Operators
These operators perform basic mathematical operations.
Operator Operation Example
+ Addition a + b (sum of a and b)
- Subtraction a - b (difference between a and b)
* Multiplication a * b (product of a and b)
/ Division a / b (quotient of a and b)
% Modulus (Remainder) a % b (remainder of a divided by b)
Example:
int a = 10, b = 5;
int sum = a + b; // sum = 15
int product = a * b; // product = 50

2. Relational (Comparison) Operators

Relational operators are used to compare two values or expressions. These
operators return a boolean result (true or false), which is typically represented by 1
(true) and 0 (false).
Operator Operation Example
== Equal to a == b (True if a equals b)
!= Not equal to a != b (True if a is not equal to b)
> Greater than a > b (True if a is greater than b)
< Less than a < b (True if a is less than b)
>= Greater than or equal to a >= b (True if a is greater than or equal to b)
Operator Operation Example
<= Less than or equal to a <= b (True if a is less than or equal to b)
Example:
int a = 10, b = 5;
int result = (a > b); // result = 1 (True)

3. Logical Operators
Logical operators are used to perform logical operations, often in conditional
expressions (like if statements).
Operator Operation Example
&& Logical AND a && b (True if both a and b are true)
` `
! Logical NOT !a (True if a is false)
Example:
int a = 1, b = 0;
int result = (a && b); // result = 0 (False)

4. Bitwise Operators
Bitwise operators perform bit-level operations. These operators are used to
manipulate individual bits of variables.
Operator Operation Example
& Bitwise AND a&b
` ` Bitwise OR
^ Bitwise XOR a^b
~ Bitwise NOT (Complement) ~a
<< Left Shift a << n (shift a left by n positions)
>> Right Shift a >> n (shift a right by n positions)
Example:
int a = 5; // 0101 in binary
int b = 3; // 0011 in binary
int result = a & b; // result = 1 (0001 in binary)

5. Assignment Operators
Assignment operators are used to assign values to variables.
Operator Operation Example
= Simple assignment a = 5
+= Add and assign a += 5 (equivalent to a = a + 5)
-= Subtract and assign a -= 5 (equivalent to a = a - 5)
*= Multiply and assign a *= 5 (equivalent to a = a * 5)
Operator Operation Example
/= Divide and assign a /= 5 (equivalent to a = a / 5)
%= Modulus and assign a %= 5 (equivalent to a = a % 5)
Example:
int a = 10;
a += 5; // a = a + 5 -> a = 15

6. Increment and Decrement Operators

These operators are used to increase or decrease the value of a variable by 1.
Operator Operation Example
++ Increment (increase by 1) a++ (post-increment)
-- Decrement (decrease by 1) a-- (post-decrement)
Example:
int a = 5;
a++; // a = 6 (post-increment)

7. Conditional (Ternary) Operator

The ternary operator is a shorthand way of performing a simple if-else statement.
Operator Operation Example
?: Conditional (ternary) condition ? expr1 : expr2
Example:
int a = 5, b = 10;
int max = (a > b) ? a : b; // max = 10, as b is greater than a

8. Special Operators
These are a few additional operators that are commonly used in C.
 sizeof: Used to get the size of a data type or variable in bytes.
Example:
int a = 10;
printf("Size of a: %zu bytes", sizeof(a)); // Output: Size of a: 4 bytes (on
most systems)
 Comma Operator: Allows multiple expressions to be evaluated in a single
statement.
Example:
int a = 5, b = 10;
int result = (a = a + 5, b = b - 2); // Evaluates both expressions, result = b =
8
 Pointer Operators:
o &: Address-of operator, used to get the memory address of a variable.
 o *: Dereference operator, used to access the value at a given address
(pointer).
Example:
int a = 5;
int *ptr = &a; // ptr holds the address of a
printf("Value at ptr: %d", *ptr); // Output: 5

Conclusion
Operators are one of the core components in C programming. They allow you to
perform mathematical, logical, relational, and bitwise operations. By
understanding the different types of operators and how to use them, you can
manipulate data effectively and write powerful, efficient C programs.

Variables:
Variables in C: Short Note
In C programming, variables are used to store data that can be manipulated during
the execution of a program. A variable is essentially a container that holds data
values. The value of a variable can change throughout the execution of the
program, which is why they are called "variables."

Definition of a Variable:
A variable in C is a symbolic name for a memory location that stores data. Each
variable has a data type that determines the kind of data it can hold, such as
integers, floating-point numbers, or characters.

Syntax to Declare a Variable:

The basic syntax for declaring a variable in C is:
data_type variable_name;
 data_type: Specifies the type of data the variable will store (e.g., int, float,
char).
 variable_name: The name of the variable, which follows the rules for
identifiers in C.
Example:
int age; // Declares an integer variable 'age'
float salary; // Declares a floating-point variable 'salary'
char grade; // Declares a character variable 'grade'

Rules for Naming Variables:

 1. The name must start with a letter (A-Z, a-z) or an underscore (_).
2. The remaining characters can be letters, digits (0-9), or underscores.
3. C is case-sensitive, so age, Age, and AGE are different variables.
4. A variable cannot have the same name as a reserved keyword (e.g., int, for,
if).
5. It's a good practice to give variables meaningful names that reflect the data
they hold.

Variable Initialization:
A variable can be initialized at the time of declaration, meaning it is assigned a
value when it is declared.
Example:
int age = 25; // Declares and initializes 'age' with the value 25
float salary = 50000.5; // Declares and initializes 'salary' with the value 50000.5
If a variable is not initialized, it may contain a garbage value (an unknown value),
which can lead to unpredictable behavior.

Types of Variables in C:
1. Local Variables:
o Defined inside a function or block.
o They can only be accessed within that function/block.
o They are created when the function is called and destroyed when the
function exits.
2. Global Variables:
o Defined outside all functions, usually at the top of the program.
o They can be accessed from any function within the same program.
o Global variables have a program-wide scope.
3. Static Variables:
o Defined with the static keyword, and they retain their value between
function calls.
o They are only initialized once and preserve their value for the duration
of the program.
4. External Variables:
o Defined in another file and linked to the current program using the
extern keyword.

Example of Variables in a Program:

#include <stdio.h>

int globalVar = 100; // Global variable

void exampleFunction() {
int localVar = 50; // Local variable
static int staticVar = 10; // Static variable

printf("Local Variable: %d\n", localVar);

printf("Static Variable: %d\n", staticVar);
staticVar++; // Static variable retains its value between calls
}

int main() {
int age = 30; // Local variable in main
float salary = 45000.50;

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

printf("Salary: %.2f\n", salary);

exampleFunction(); // Call the function that uses static variable

exampleFunction(); // Call again to see the change in staticVar

return 0;
}
Output:
Age: 30
Salary: 45000.50
Local Variable: 50
Static Variable: 10
Local Variable: 50
Static Variable: 11

Conclusion:
Variables in C are essential to store and manipulate data in a program. By
understanding how to declare, initialize, and use variables correctly, you can write
programs that are efficient, organized, and easy to understand. Always choose
descriptive variable names and be mindful of the scope and lifetime of your
variables to avoid errors and improve code clarity.

Constants:
Constants in C: Short Note
In C programming, a constant is a value that cannot be modified during the
execution of the program. Once a constant is assigned a value, it remains
unchanged throughout the program. Constants are used when we need to refer to a
fixed value multiple times without the risk of accidentally altering it.

Types of Constants in C:
1. Integer Constants
2. Floating-Point Constants
3. Character Constants
4. String Constants
5. Enumerated Constants
6. Symbolic Constants (using #define or const)

1. Integer Constants
An integer constant is a whole number, either positive or negative, without any
decimal point.
Example:
int a = 10; // 10 is an integer constant
Types:
 Decimal: 10, 255
 Octal: 075, 012 (prefixed with 0)
 Hexadecimal: 0x1A, 0xFF (prefixed with 0x)

2. Floating-Point Constants
A floating-point constant represents numbers with decimal points.
Example:
float pi = 3.14159; // 3.14159 is a floating-point constant
Floating-point constants can be written in scientific notation:
Example:
float e = 1.23e4; // Equivalent to 1.23 * 10^4

3. Character Constants
A character constant is a single character enclosed in single quotes.
Example:
char ch = 'A'; // 'A' is a character constant
Note: Character constants are treated as integers in C, where the character is stored
as its corresponding ASCII value.

4. String Constants
A string constant is a sequence of characters enclosed in double quotes.
Example:
char str[] = "Hello, World!"; // "Hello, World!" is a string constant

5. Enumerated Constants
Enumerated constants are defined using the enum keyword. They are useful for
defining a set of named integer constants.
Example:
enum week { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday,
Saturday };
By default, the first constant (Sunday) is assigned the value 0, and the others are
incremented by 1 (Monday = 1, Tuesday = 2, etc.).

6. Symbolic Constants (Using #define or const)

There are two common ways to define symbolic constants in C: using the #define
preprocessor directive or the const keyword.
a. #define Preprocessor Directive
The #define directive is used to define symbolic constants. These constants are
replaced by their value by the preprocessor before compilation.
Example:
#define PI 3.14159
#define MAX_SIZE 100
b. const Keyword
The const keyword can be used to define a variable whose value cannot be
changed.
Example:
const int MAX_AGE = 120;
const float PI = 3.14159;
The const method provides type safety, whereas #define is more flexible but lacks
type checking.

Advantages of Using Constants:

1. Prevents Modification: Constants cannot be accidentally modified during
program execution, which improves reliability.
2. Improves Readability: Named constants like PI or MAX_SIZE are more
readable than using hardcoded values.
3. Easy Maintenance: If a constant value needs to change, you only need to
modify it in one place (e.g., the #define or const statement), rather than
everywhere it appears in the code.
4. Type Safety (for const): Using const ensures that the variable has a defined
type, providing more control over the program.
Example of Constants in C:
#include <stdio.h>

#define PI 3.14159 // Symbolic constant using #define

const int MAX_AGE = 100; // Constant using const

int main() {
int age = 25;
printf("Value of PI: %.5f\n", PI);
printf("Max allowed age: %d\n", MAX_AGE);

// Uncommenting the following lines will cause errors, as constants can't be

changed
// PI = 3.14; // Error: PI is a constant
// MAX_AGE = 120; // Error: MAX_AGE is a constant

return 0;
}
Output:
Value of PI: 3.14159
Max allowed age: 100

Conclusion:
Constants are an essential feature of C programming, providing a way to store
values that cannot be changed. They improve the readability, maintainability, and
reliability of code by allowing fixed values to be used consistently throughout the
program without the risk of accidental modification. Constants can be defined
using literals (integer, floating-point, character), symbolic constants (via #define or
const), or enumerated types, depending on the use case.
Input/Output :
In C programming, Input/Output (I/O) refers to the process of reading data from
the user or a file (input) and displaying data to the user or writing data to a file
(output). C provides standard functions and libraries to handle I/O operations.

Standard I/O Functions

The most common functions for handling input and output in C are part of the
stdio.h (standard input-output) library.
1. printf(): Used to display output (send data to the screen).
2. scanf(): Used to read input (from the keyboard).
1. printf() Function (Output)
The printf() function is used to print data on the screen. It can print variables,
literals, and formatted strings.
Syntax:
printf("format_specifier", arguments);
 "format_specifier": Specifies the format in which the data should be printed
(e.g., %d for integers, %f for floating-point numbers, %s for strings).
 arguments: The data to be printed.
Example:
#include <stdio.h>

int main() {
int num = 10;
float pi = 3.14;
char grade = 'A';

printf("Number: %d\n", num); // Prints integer value

printf("Pi value: %.2f\n", pi); // Prints float with two decimal places
printf("Grade: %c\n", grade); // Prints character

return 0;
}
Output:
Number: 10
Pi value: 3.14
Grade: A

2. scanf() Function (Input)

The scanf() function is used to read input from the user. It reads data from standard
input (usually the keyboard) and stores it in variables.
Syntax:
scanf("format_specifier", &variable);
 "format_specifier": Specifies the format of the input data (e.g., %d for
integers, %f for floating-point numbers, %s for strings).
 &variable: The address of the variable where the input data will be stored.
Example:
#include <stdio.h>

int main() {
 int age;
float salary;
char name[30];

// Taking input from user

printf("Enter your age: ");
scanf("%d", &age); // Reads an integer
printf("Enter your salary: ");
scanf("%f", &salary); // Reads a float
printf("Enter your name: ");
scanf("%s", name); // Reads a string

// Displaying input data

printf("Age: %d\n", age);
printf("Salary: %.2f\n", salary);
printf("Name: %s\n", name);

return 0;
}
Example Output:
Enter your age: 25
Enter your salary: 55000.50
Enter your name: John
Age: 25
Salary: 55000.50
Name: John

Format Specifiers in C
For both printf() and scanf(), format specifiers are used to indicate the type of data
being input or output.
Specifier Data Type Example
%d Integer scanf("%d", &num)
%f Float scanf("%f", &num)
%c Character scanf("%c", &ch)
%s String scanf("%s", str)
%lf Double (long float) scanf("%lf", &num)
%x Hexadecimal Integer scanf("%x", &num)

Important Notes:
 1. scanf() and Buffer Issues:
o scanf() can sometimes behave unpredictably when reading strings or
characters after reading numeric values, because it leaves newline
characters in the input buffer. To avoid this, use getchar() or getch() to
consume the newline if necessary.
o To handle strings with spaces, use fgets() instead of scanf().
2. Input Validation:
o Always validate the input received via scanf(). If the input is not of
the expected type, it can lead to unexpected behavior.
Example:
if(scanf("%d", &num) != 1) {
printf("Invalid input!\n");
}

Other I/O Functions

 getchar(): Reads a single character from standard input.
 char c = getchar(); // Reads one character
 putchar(): Outputs a single character to the console.
 putchar('A'); // Prints the character 'A'
 gets() (not recommended): Reads a string from standard input until a
newline is encountered.
 char str[100];
 gets(str); // Dangerous, avoid using it due to buffer overflow risks
 fgets(): Safer alternative to gets(), allows reading strings with spaces.
 fgets(str, sizeof(str), stdin);

Conclusion:
Input and output operations are crucial in C programming for interacting with users
and processing data. Functions like printf() and scanf() are used to output and input
data, respectively, while format specifiers help control the data types. It’s essential
to handle user input carefully, especially when working with functions like scanf()
and gets(), to avoid errors and security vulnerabilities like buffer overflows.
Always validate and sanitize input for better program robustness.