Study Notes BE Computer System Engineering At Dawood University is a rewarding experience that will open doors to numerous career opportunities in the field of technolog.Dawood University of Engineering and Technology is a prestigious institution known for its quality education and research facilities in the field of engineering. The faculty members are experts in their respective fields and provide hands-on training to prepare students for real-world challenges.

Study Notes BE Computer System Engineering At Dawood University.

CSE-1501: Computing Fundamentals – Comprehensive Study Notes

These notes provide a complete framework for Computing Fundamentals, covering the foundational concepts of computer systems, hardware, software, data representation, programming basics, and computational thinking. This course is typically designed for students from diverse academic backgrounds who need a solid grounding in computing principles before advancing to more specialized courses.

Part 1: Introduction to Computing

1.1 What is a Computer?

A computer is an electronic device that accepts data (input), processes it according to stored instructions, produces information (output), and stores results for future use. Modern computers are characterized by their speed, accuracy, diligence, versatility, and storage capacity.

1.2 Characteristics of Computers

1.3 Limitations of Computers

Despite their power, computers have inherent limitations:

• No intelligence: They follow instructions blindly; they cannot think or reason independently

• No emotional intelligence: Cannot understand feelings or make value judgments

• Garbage In, Garbage Out (GIGO) : Output quality depends entirely on input quality

• Dependency on power and programming: Cannot function without electricity or instructions

Part 2: Computer Hardware

2.1 Basic Hardware Components

Every computer system requires hardware—the physical, touchable components that make up the machine. The basic model follows the input-processing-output-storage paradigm:

Input Devices → System Unit (Processing) → Output Devices
                     ↓
                Storage Devices

2.2 Input Devices

Input devices allow users to enter data and commands into a computer.

2.3 Output Devices

Output devices display or present processed information to users.

2.4 The System Unit

The system unit houses the main electronic components of a computer. Understanding these components is crucial for grasping how computers operate at a fundamental level.

Major Components Inside the System Unit:

2.5 The Central Processing Unit (CPU)

The CPU is the “brain” of the computer—it performs all calculations and executes instructions. A typical introductory computing course covers CPU fundamentals including its components, the fetch-execute cycle, and factors affecting performance .

CPU Components:

• Control Unit (CU) : Directs the flow of instructions

• Arithmetic Logic Unit (ALU) : Performs mathematical and logical operations

• Registers: High-speed temporary storage within the CPU

• Cache Memory: Very fast memory for frequently used data

The Fetch-Execute Cycle:

1. Fetch: The control unit retrieves the next instruction from memory

2. Decode: The instruction is interpreted to determine what operation to perform

3. Execute: The ALU performs the operation

4. Store: Results are written back to memory or registers

CPU Performance Factors:

• Clock speed (GHz) – number of cycles per second

• Number of cores – multiple processing units within one CPU

• Cache size – larger cache means faster access to frequent data

• Instruction set architecture (32-bit vs. 64-bit)

2.6 Memory and Storage

Understanding the memory hierarchy is crucial for comprehending computer performance.

RAM vs. ROM:

• RAM: Temporary, loses data when power off, read/write capability

• ROM: Permanent, retains data without power, primarily read-only

2.7 Storage Devices and Media

Storage devices hold data permanently or semi-permanently.

Magnetic Storage:

• Hard Disk Drives (HDDs) – Large capacity, lower cost, mechanical parts

Solid-State Storage:

• SSDs, USB flash drives, memory cards – Faster, no moving parts, more durable

Optical Storage:

• CDs (700 MB), DVDs (4.7-8.5 GB), Blu-ray (25-50 GB) – Read/write with lasers

Cloud Storage:

• Google Drive, OneDrive, Dropbox – Internet-based storage accessible from anywhere

Part 3: Computer Software

3.1 System Software vs. Application Software

Software is the set of instructions that tells hardware what to do. Computer Science I courses typically introduce the distinction between system software and application software, along with fundamental programming concepts .

3.2 Operating Systems

The operating system (OS) is the most important system software. Introductory courses often use programming in a modern high-level language to illustrate how software interacts with the OS .

Functions of an Operating System:

1. Process Management: Manages running programs

2. Memory Management: Allocates RAM to programs

3. File System Management: Organizes data on storage devices

4. Device Management: Controls hardware through drivers

5. User Interface: Provides way for users to interact (GUI or command-line)

6. Security: Manages user accounts and permissions

Common Operating Systems:

3.3 Programming Languages

Programming languages are the tools used to create software. Computing fundamentals courses often introduce the concepts of algorithm development, stepwise refinement, and elementary programming constructs .

Levels of Programming Languages:

Programming Paradigms:

3.4 Programming Fundamentals

Key Programming Concepts:

• Variables: Named storage locations for data with specific data types

• Data Types: Classification of data (integers, floats, characters, strings, booleans)

• Control Structures: Mechanisms for controlling program flow (sequence, selection, iteration)

• Functions/Procedures: Reusable blocks of code that perform specific tasks

• Input/Output: Reading data from and writing data to external sources

Control Structures:

• Sequence: Instructions executed in order

• Selection (Branching) : Decision-making using if, else, switch

• Iteration (Loops) : Repetition using for, while, do-while

Part 4: Data Representation

4.1 Number Systems

Computers use the binary number system (base-2) because they operate using two states: on (1) and off (0).

4.2 Converting Between Number Systems

Binary to Decimal:
Multiply each binary digit by 2 raised to its position power (from right, starting at 0).

Example: 10112=(1×23)+(0×22)+(1×21)+(1×20)=8+0+2+1=111010112​=(1×23)+(0×22)+(1×21)+(1×20)=8+0+2+1=1110​

Decimal to Binary:
Repeatedly divide by 2, recording remainders from bottom to top.

Example: 1310=110121310​=11012​

Binary to Hexadecimal:
Group binary into sets of 4 bits (nibbles), convert each group to hex digit.

Example: 110111102=(1101)(1110)=DE16110111102​=(1101)(1110)=DE16​

4.3 Data Storage Units

4.4 Binary Representation of Negative Numbers

Two’s Complement is the most common method for representing signed integers in computers.

For 8-bit representation of -5:

1. 5 in binary: 00000101

2. Invert all bits (one’s complement): 11111010

3. Add 1: 11111011 (-5)

Two’s complement advantage: Allows addition and subtraction using the same hardware as unsigned numbers, with a single representation for zero.

4.5 Character Encoding

ASCII (American Standard Code for Information Interchange) :

• 7-bit code (extended to 8-bit) for representing characters

• 128 standard characters (0-127)

Unicode: Extended character encoding supporting over 140,000 characters from all world languages, emojis, and symbols.

Part 5: Computer Networks

5.1 What is a Computer Network?

A computer network is two or more computers connected to share resources and communicate.

Benefits of Networking:

• Resource sharing (printers, scanners, storage)

• Communication (email, messaging, video calls)

• Centralized data management

• Collaboration tools

• Internet access sharing

5.2 Types of Networks

5.3 The Internet and World Wide Web

Internet vs. World Wide Web:

5.4 Basic Internet Protocols

5.5 Network Hardware

Part 6: Computational Thinking and Algorithms

6.1 What is an Algorithm?

An algorithm is a finite sequence of well-defined, unambiguous instructions for solving a specific problem. Algorithm development is a core component of computing fundamentals courses, emphasizing problem-solving approaches before implementation .

Properties of Algorithms:

6.2 Computational Thinking

Computational thinking is the problem-solving approach that involves:

1. Decomposition: Breaking a complex problem into smaller, manageable parts

2. Pattern Recognition: Identifying similarities within and across problems

3. Abstraction: Focusing on essential information while ignoring irrelevant details

4. Algorithm Design: Developing step-by-step solutions

6.3 Algorithm Representation

Flowcharts: Visual representation of algorithms using standardized symbols

Pseudocode: Informal, human-readable algorithm description using natural language and programming conventions

6.4 Basic Algorithms

Search Algorithms:

Sorting Algorithms:

Part 7: Ethics and Security

7.1 Computer Ethics

Digital Citizenship: Using technology responsibly, ethically, and safely.

Key Ethical Issues:

• Privacy: Protection of personal information

• Intellectual Property: Respect for copyright and software licensing

• Cyberbullying: Using digital devices to harass others

• Digital Divide: Gap between those with and without technology access

7.2 Information Security

The CIA Triad (three core principles of information security):

7.3 Common Cyber Threats

Malware Types:

Protection Measures:

• Strong, unique passwords for each account

• Two-factor authentication (2FA)

• Antivirus/Antimalware software

• Regular software updates

• Data backups (3-2-1 rule)

• Email caution (don’t click suspicious links)

Part 8: Key Formulas and Concepts Summary

Part 9: Study Tips for CSE-1501

1. Understand the hardware-software relationship – Software tells hardware what to do; hardware provides the physical platform for software execution.

2. Master binary and hexadecimal – Practice converting between number systems. This is fundamental to understanding how computers represent data.

3. Learn the fetch-execute cycle – The CPU’s operation cycle (Fetch → Decode → Execute → Store) is the foundation of computer operation.

4. Practice algorithm design – Before writing code, practice creating flowcharts and pseudocode. This develops computational thinking skills emphasized in introductory CS courses .

5. Know the difference between memory and storage – RAM is temporary (volatile) and fast; storage drives are permanent (non-volatile) and slower.

6. Understand basic programming concepts – Variables, data types, control structures (sequence, selection, iteration), and functions form the building blocks of all programs.

7. Connect to real-world applications – Relate each concept to practical applications (e.g., networks to internet browsing, security to online banking).

8. Create a glossary of terms – Computing has extensive terminology; maintaining a glossary helps with retention.

Part 10: Recommended Resources

These notes provide a comprehensive framework for CSE-1501: Computing Fundamentals. Success requires understanding hardware components (CPU, memory, storage, input/output), mastering data representation (binary, hexadecimal, character encoding), learning basic programming concepts (algorithms, control structures, data types), and developing computational thinking skills (decomposition, pattern recognition, abstraction, algorithm design). This course builds the foundation for all subsequent computing and programming courses .

CSE-1101: Basic Electronics & Circuits

Here are detailed study notes for CSE-1101: Basic Electronics & Circuits, written from a Computer Science/Engineering perspective. These notes cover the fundamental principles of electronics and circuits—basic electrical quantities, circuit analysis, passive components, semiconductor devices, diodes, transistors, operational amplifiers, and digital logic fundamentals. The emphasis is on understanding how electronic circuits work and how they form the foundation of modern computing systems.

1. Introduction to Electronics

1.1. What is Electronics?

Electronics is the branch of physics and engineering that deals with the behavior, control, and movement of electrons in semiconductors, vacuum tubes, and other devices. Unlike electrical engineering (which focuses on power generation and distribution), electronics focuses on signal processing, amplification, switching, and computation.

The Core Question: How do we control the flow of electrons in semiconductors to create amplifiers, switches, logic gates, and complex integrated circuits?

1.2. Electronics in Computer Science

1.3. Basic Electrical Quantities

2. Basic Circuit Analysis

2.1. Ohm’s Law

The fundamental relationship between voltage, current, and resistance:

$$V=IR$$I=VRI=RV​R=VIR=IV​

2.2. Kirchhoff’s Laws

Kirchhoff’s Current Law (KCL):
The algebraic sum of currents entering a node is zero.

∑Iin=∑Iout∑Iin​=∑Iout​

Kirchhoff’s Voltage Law (KVL):
The algebraic sum of voltages around any closed loop is zero.

$$\sum V=0$$

2.3. Series Circuits

R1 ── R2 ── R3

2.4. Parallel Circuits

    ┌─ R1 ─┐
    ├─ R2 ─┤
    └─ R3 ─┘

2.5. Power in Circuits

P=VI=I2R=V2RP=VI=I2R=RV2​

Units: 1 Watt = 1 Joule/second

Energy:

$$E=P\times t\text{(Joules or Watt-seconds)}$$

2.6. Circuit Analysis Methods

Mesh Analysis (Loop Current Method):

1. Identify independent loops

2. Assign mesh currents

3. Apply KVL to each mesh

4. Solve simultaneous equations

Nodal Analysis (Node Voltage Method):

1. Identify nodes (choose reference node)

2. Assign node voltages

3. Apply KCL at each node

4. Solve simultaneous equations

3. Passive Components

3.1. Resistors

Resistors oppose current flow and dissipate energy as heat.

Resistor Color Code:

Example: Red-Red-Brown-Gold = 22 × 10 = 220Ω ±5%

Resistor Types:

3.2. Capacitors

Capacitors store energy in an electric field.

C=QVC=VQ​

Capacitance Formula (Parallel Plate):

C=εAdC=εdA​

Current-Voltage Relationship:

iC=CdvCdtiC​=CdtdvC​​vC=1C∫iCdt+vC(0)vC​=C1​∫iC​dt+vC​(0)

Energy Stored:

E=12CV2=12Q2CE=21​CV2=21​CQ2​

Capacitor Types:

Capacitors in Series:

1CT=1C1+1C2+1C3CT​1​=C1​1​+C2​1​+C3​1​

Capacitors in Parallel:

CT=C1+C2+C3CT​=C1​+C2​+C3​

3.3. Inductors

Inductors store energy in a magnetic field.

L=N2μAlL=lN2μA​

Voltage-Current Relationship:

vL=LdiLdtvL​=LdtdiL​​iL=1L∫vLdt+iL(0)iL​=L1​∫vL​dt+iL​(0)

Energy Stored:

E=12LI2E=21​LI2

Inductor Types:

Inductors in Series:

LT=L1+L2+L3LT​=L1​+L2​+L3​

Inductors in Parallel:

1LT=1L1+1L2+1L3LT​1​=L1​1​+L2​1​+L3​1​

3.4. Transformers

Transformers transfer energy between circuits through magnetic induction.

Ideal Transformer Equations:

VpVs=NpNs=aVs​Vp​​=Ns​Np​​=aIpIs=NsNp=1aIs​Ip​​=Np​Ns​​=a1​VpIp=VsIs(power in = power out)Vp​Ip​=Vs​Is​(power in = power out)

4. RC and RL Circuits (Time Response)

4.1. RC Circuits

Charging a Capacitor (RC circuit with DC source):

vC(t)=V(1−e−t/RC)vC​(t)=V(1−e−t/RC)i(t)=VRe−t/RCi(t)=RV​e−t/RC

Time Constant: $\tau =RC$ (seconds)

• At $t=\tau$: 63.2% charged

• At $t=3\tau$: 95% charged

• At $t=5\tau$: 99.3% charged (steady state)

Discharging a Capacitor:

vC(t)=V0e−t/RCvC​(t)=V0​e−t/RCi(t)=−V0Re−t/RCi(t)=−RV0​​e−t/RC

4.2. RL Circuits

Current build-up in inductor:

iL(t)=VR(1−e−Rt/L)iL​(t)=RV​(1−e−Rt/L)vL(t)=Ve−Rt/LvL​(t)=Ve−Rt/L

Time Constant: $\tau =L/R$ (seconds)

Current decay:

iL(t)=I0e−Rt/LiL​(t)=I0​e−Rt/LvL(t)=−I0Re−Rt/LvL​(t)=−I0​Re−Rt/L

5. Semiconductor Physics

5.1. Intrinsic Semiconductors

Silicon (Si): 4 valence electrons (Group IV)

• Crystal structure: Diamond cubic

• Band gap (Si): 1.12 eV

• Band gap (Ge): 0.67 eV

Electron-Hole Pair Generation:

• At absolute zero: insulator (no free electrons)

• At room temperature: thermal energy excites electrons to conduction band

• Creates free electrons and holes (positive charge carriers)

5.2. Extrinsic Semiconductors (Doping)

N-type (Donor Doping):

• Add Group V elements (Phosphorus, Arsenic)

• Extra free electrons (majority carriers)

• Holes (minority carriers)

P-type (Acceptor Doping):

• Add Group III elements (Boron, Aluminum)

• Holes (majority carriers)

• Electrons (minority carriers)

5.3. Carrier Concentrations

Intrinsic carrier concentration (Si at 300K):

ni≈1.5×1010 cm−3ni​≈1.5×1010 cm−3

N-type:

nn≈ND(majority)nn​≈ND​(majority)pn≈ni2ND(minority)pn​≈ND​ni2​​(minority)

P-type:

pp≈NA(majority)pp​≈NA​(majority)np≈ni2NA(minority)np​≈NA​ni2​​(minority)

6. Diodes

6.1. PN Junction Diode

A PN junction diode allows current to flow in only one direction.

Structure:

P-type (Anode) ───┼─── N-type (Cathode)
                  │
            Depletion region

I-V Characteristic:

Current (I)
    ↑
    |        Forward bias
    |         (conducting)
    |        /
    |       /
    |      /
    |_____/_______→ Voltage (V)
    |     \
    |      \
    |       \
    |        Reverse bias (blocking)
    |

Forward Bias: P positive, N negative → current flows
Reverse Bias: P negative, N positive → no current (except leakage)

6.2. Diode Equation

I=IS(eVnVT−1)I=IS​(enVT​V​−1)

Where:

• ISIS​ = reverse saturation current

• $n$ = ideality factor (1 for ideal, 1-2 for real)

• VT=kTq≈25 mV at 300KVT​=qkT​≈25 mV at 300K (thermal voltage)

Simplified Model:

• Forward voltage drop: VF≈0.7VVF​≈0.7V (Si), $0.3V$ (Ge), $0.2V$ (Schottky)

6.3. Diode Applications

Rectifier Circuits:

Rectifier Calculations:

VDC=2Vmπ≈0.637Vm(half-wave)VDC​=π2Vm​​≈0.637Vm​(half-wave)VDC=2Vmπ≈0.637Vm(full-wave)VDC​=π2Vm​​≈0.637Vm​(full-wave)Ripple factor=Vrms,acVDC=143fRCRipple factor=VDC​Vrms,ac​​=43​fRC1​

Other Diode Applications:

• Clipper circuits: Remove portions of waveform

• Clamper circuits: Add DC offset

• Voltage multiplier: Generate high DC voltages

• Protection diodes: Prevent reverse voltage damage

6.4. Special-Purpose Diodes

Zener Diode Voltage Regulation:

Vout=VZVout​=VZ​R=Vin−VZIL+IZR=IL​+IZ​Vin​−VZ​​

7. Transistors

7.1. Bipolar Junction Transistor (BJT)

BJT is a current-controlled current amplifier.

Types:

BJT Terminals:

• Emitter (E): Heavily doped, emits carriers

• Base (B): Thin, lightly doped, controls current

• Collector (C): Collects carriers

BJT Operating Regions:

BJT Current Relationships:

IE=IB+ICIE​=IB​+IC​IC=βIB(active region)IC​=βIB​(active region)$$\beta =\text{current gain (typical 50-300)}$$IC=αIE,α=ββ+1IC​=αIE​,α=β+1β​

Common Emitter Configuration:

VCE=VCC−ICRCVCE​=VCC​−IC​RC​IB=VBB−VBERBIB​=RB​VBB​−VBE​​

Transistor as a Switch:

• Cutoff: VBE<0.7VVBE​<0.7V → transistor OFF → VCE≈VCCVCE​≈VCC​

• Saturation: IBIB​ large → transistor ON → VCE≈0.2VVCE​≈0.2V

7.2. Field Effect Transistor (FET)

FET is a voltage-controlled device.

Types:

MOSFET (Most Common in Digital Circuits):

MOSFET Regions:

MOSFET Current Equation (Saturation):

ID=12μnCoxWL(VGS−VTH)2ID​=21​μn​Cox​LW​(VGS​−VTH​)2

7.3. CMOS Technology

CMOS (Complementary MOS): Uses both NMOS and PMOS transistors.

CMOS Inverter:

VDD
 │
 ┌┴┐ PMOS (pull-up)
 └┬┘
  ┼─── Vout
 ┌┴┐ NMOS (pull-down)
 └┬┘
 │
GND

CMOS Characteristics:

• Very low static power (only leakage)

• High noise immunity

• Scalable (Moore’s Law)

• Dominant technology for digital ICs

8. Operational Amplifiers (Op-Amps)

8.1. Op-Amp Basics

An operational amplifier is a high-gain differential voltage amplifier.

Symbol:

         V+
          │
    Inverting (-) ──┤\      
                     │ \    
                     │  \─── Vout
                     │  /
    Non-inverting (+)─┤/
          │
         V-

Ideal Op-Amp Characteristics:

Golden Rules (for negative feedback):

1. Virtual short: V+=V−V+​=V−​ (input voltages equal)

2. Virtual open: No current flows into inputs (I+=I−=0I+​=I−​=0)

8.2. Basic Op-Amp Configurations

Inverting Amplifier:

Vout=−RfRinVinVout​=−Rin​Rf​​Vin​Zin=RinZin​=Rin​

Non-Inverting Amplifier:

Vout=(1+RfRin)VinVout​=(1+Rin​Rf​​)Vin​Zin=∞Zin​=∞

Voltage Follower (Buffer):

Vout=VinVout​=Vin​Zin=∞,Zout=0Zin​=∞,Zout​=0

Summing Amplifier:

Vout=−(RfR1V1+RfR2V2+RfR3V3)Vout​=−(R1​Rf​​V1​+R2​Rf​​V2​+R3​Rf​​V3​)

Differential Amplifier:

Vout=RfR1(V2−V1)(if R1=R2,Rf=Rg)Vout​=R1​Rf​​(V2​−V1​)(if R1​=R2​,Rf​=Rg​)

Integrator:

Vout(t)=−1RC∫Vin(t)dtVout​(t)=−RC1​∫Vin​(t)dt

Differentiator:

Vout(t)=−RCdVin(t)dtVout​(t)=−RCdtdVin​(t)​

8.3. Practical Op-Amp Limitations

9. Digital Logic Fundamentals

9.1. Logic Levels

9.2. Basic Logic Gates

9.3. Boolean Algebra

Basic Laws:

• Identity: $A+0=A$, $A\cdot 1=A$

• Null: $A+1=1$, $A\cdot 0=0$

• Idempotent: $A+A=A$, $A\cdot A=A$

• Complement: A+A‾=1A+A=1, A⋅A‾=0A⋅A=0

• Double negation: A‾‾=AA=A

Commutative: $A+B=B+A$, $A\cdot B=B\cdot A$
Associative: $(A+B)+C=A+(B+C)$
Distributive: $A\cdot (B+C)=A\cdot B+A\cdot C$

DeMorgan’s Theorems:

A⋅B‾=A‾+B‾A⋅B=A+BA+B‾=A‾⋅B‾A+B​=A⋅B

9.4. Logic Family Characteristics

10. Power Supplies and Regulation

10.1. Linear Voltage Regulators

Series Regulator:

Vout=Vref(1+R1R2)Vout​=Vref​(1+R2​R1​​)

Common Regulators:

10.2. Switching Regulators

Types:

• Buck (Step-down): Vout<VinVout​<Vin​

• Boost (Step-up): Vout>VinVout​>Vin​

• Buck-Boost: VoutVout​ can be higher or lower

• Inverting: VoutVout​ negative

Efficiency:

• Linear regulators: 30-50%

• Switching regulators: 80-95%

11. Summary Table: Key Equations

12. Standard Textbooks

13. Final Study Checklist

CSE-1502 Computer Programming Principles – Detailed Study Notes

These study notes are designed for undergraduate students taking a first course in Computer Programming. The notes cover the fundamental principles of programming, algorithms, data types, control structures, functions, arrays, pointers, and basic data structures.

1. Introduction to Computer Programming

1.1 What is Programming?

1.2 Levels of Programming Languages

1.3 The Programming Process

1. Problem Analysis → Understand requirements
2. Algorithm Design → Step-by-step solution
3. Coding → Write program in programming language
4. Compilation/Interpretation → Translate to machine code
5. Testing & Debugging → Find and fix errors
6. Maintenance → Update and improve

1.4 Types of Errors

2. Algorithms and Flowcharts

2.1 Algorithm Definition

2.2 Flowchart Symbols

2.3 Example Flowchart (Find largest of three numbers)

        ┌─────────┐
        │  Start  │
        └────┬────┘
             ↓
        ┌─────────┐
        │ Read A,B,C│
        └────┬────┘
             ↓
           ◇─────┐
        A > B?   │Yes
           │No   ↓
           ↓   ┌─────┐
           ◇   │ max=A│
        A > C? │     │
        │No  Yes│     │
        ↓     ↓     ↓
     ┌─────┐ ┌─────┐ │
     │max=B│ │max=C│ │
     └──┬──┘ └──┬──┘ │
        │       │    │
        └───────┴────┘
             ↓
        ┌─────────┐
        │ Print max│
        └────┬────┘
             ↓
        ┌─────────┐
        │  Stop   │
        └─────────┘

3. C Programming Fundamentals

3.1 Structure of a C Program

/* Header file inclusion */
#include <stdio.h>
#include <conio.h>

/* Macro definition */
#define PI 3.14159

/* Global variable declaration */
int global_var = 10;

/* Function declaration (prototype) */
int add(int a, int b);

/* Main function – program entry point */
void main()
{
    /* Variable declarations */
    int x = 5, y = 10, result;
    
    /* Function call */
    result = add(x, y);
    
    /* Output statement */
    printf("Sum = %d", result);
    
    getch(); /* Wait for key press */
}

/* Function definition */
int add(int a, int b)
{
    return a + b;
}

3.2 C Character Set

3.3 C Tokens

3.4 Data Types in C

3.5 Variable Declaration and Initialization

/* Declaration only */
int count;
float price;
char grade;

/* Declaration with initialization */
int age = 25;
float temperature = 98.6;
char initial = 'J';

/* Multiple declarations */
int a = 5, b = 10, c;

3.6 Constants

/* Integer constants */
int decimal = 100;      /* Decimal (base 10) */
int octal = 0144;       /* Octal (base 8) – prefix 0 */
int hexadecimal = 0x64; /* Hexadecimal (base 16) – prefix 0x */

/* Floating-point constants */
float f1 = 3.14;
float f2 = 3.14e-5;     /* Scientific notation */

/* Character constants */
char ch1 = 'A';
char ch2 = '\n';        /* Escape sequence */

/* String constants (character arrays) */
char str[] = "Hello";

/* Escape sequences */
/* \n = newline, \t = tab, \r = carriage return */
/* \' = single quote, \" = double quote, \\ = backslash */

3.7 Input and Output Functions

printf() Format Specifiers:

4. Operators and Expressions

4.1 Types of Operators

4.2 Operator Precedence and Associativity

4.3 Type Conversion

Implicit (Automatic) Conversion:

int a = 10;
float b = 3.14;
float c = a + b;  /* a converted to float (10.0) */

Explicit (Type Casting):

float f = 3.14;
int i = (int) f;  /* i = 3 (truncated) */

int x = 5, y = 2;
float z = (float) x / y;  /* z = 2.5 */

5. Control Structures

5.1 Decision Making (Conditional Statements)

if statement:

if (condition)
{
    /* statements executed if condition is true */
}

if-else statement:

if (condition)
{
    /* executed if true */
}
else
{
    /* executed if false */
}

else-if ladder:

if (condition1)
{
    /* block 1 */
}
else if (condition2)
{
    /* block 2 */
}
else if (condition3)
{
    /* block 3 */
}
else
{
    /* default block */
}

Nested if:

if (condition1)
{
    if (condition2)
    {
        /* nested if block */
    }
}

switch statement:

switch (expression)
{
    case constant1:
        /* statements */
        break;
    case constant2:
        /* statements */
        break;
    default:
        /* default statements */
}

Conditional (ternary) operator:

variable = (condition) ? expression1 : expression2;
/* Example: max = (a > b) ? a : b; */

5.2 Loops (Iteration)

while loop:

while (condition)
{
    /* statements */
    /* loop variable update */
}

do-while loop:

do
{
    /* statements */
} while (condition);  /* executes at least once */

for loop:

for (initialization; condition; increment/decrement)
{
    /* statements */
}

Example – Print numbers 1 to 10:

/* Using for loop */
for (int i = 1; i <= 10; i++)
{
    printf("%d ", i);
}

/* Using while loop */
int i = 1;
while (i <= 10)
{
    printf("%d ", i);
    i++;
}

/* Using do-while loop */
int i = 1;
do
{
    printf("%d ", i);
    i++;
} while (i <= 10);

5.3 Jump Statements

6. Arrays

6.1 One-Dimensional Arrays

Declaration:

data_type array_name[size];

Examples:

int numbers[10];        /* Array of 10 integers */
float scores[5];        /* Array of 5 floats */
char name[20];          /* Array of 20 characters (string) */

Initialization:

int numbers[5] = {1, 2, 3, 4, 5};      /* Full initialization */
int numbers[5] = {1, 2};                /* Partial (rest = 0) */
int numbers[] = {1, 2, 3};              /* Size inferred (3) */

Accessing Elements:

numbers[0] = 10;        /* First element (index 0) */
numbers[4] = 50;        /* Fifth element (index 4) */
int x = numbers[2];     /* Read third element */

Array Traversal:

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

6.2 Two-Dimensional Arrays

Declaration:

data_type array_name[rows][columns];

Example:

int matrix[3][4];       /* 3 rows, 4 columns */

Initialization:

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

Accessing Elements:

matrix[0][0] = 1;       /* First row, first column */
matrix[1][2] = 6;       /* Second row, third column */

Matrix Traversal:

int matrix[3][3];
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 3; j++)
    {
        matrix[i][j] = i * 3 + j + 1;
        printf("%d ", matrix[i][j]);
    }
    printf("\n");
}

6.3 Strings (Character Arrays)

Declaration and Initialization:

char str1[10] = "Hello";            /* Array of characters */
char str2[] = "World";              /* Size inferred (6) */
char str3[10] = {'H', 'e', 'l', 'l', 'o', '\0'};  /* With null terminator */

String Input/Output:

char name[50];
printf("Enter name: ");
scanf("%s", name);                  /* Reads until whitespace */
gets(name);                         /* Reads entire line (unsafe) */
fgets(name, 50, stdin);             /* Safe – reads with newline */

printf("%s", name);                 /* Print string */
puts(name);                         /* Print with newline */

Common String Functions (string.h):

7. Functions

7.1 Function Definition and Declaration

Syntax:

return_type function_name(parameter_list)
{
    /* function body */
    return value;
}

Example:

/* Function declaration (prototype) */
int add(int a, int b);

/* Function definition */
int add(int a, int b)
{
    return a + b;
}

/* Function call */
int result = add(5, 10);

7.2 Function Types

7.3 Parameter Passing

Call by Value Example:

void swap(int x, int y)  /* Does NOT swap actual arguments */
{
    int temp = x;
    x = y;
    y = temp;
}

Call by Reference Example:

void swap(int *x, int *y)  /* Swaps actual arguments */
{
    int temp = *x;
    *x = *y;
    *y = temp;
}
/* Call: swap(&a, &b); */