Certainly!

Here's a crash course preparation material for Computer Science XII, based on the
reduced syllabus you provided. This material is designed to be concise and cover the most
important points for exam preparation.

Computer Science XII - Crash Course

(2024-25)
This crash course is designed to quickly revise the key concepts from your reduced syllabus for
Computer Science XII. Focus on understanding the core ideas and practicing examples.

1. Introduction and History of C Language

●​ History:
○​ Developed by Dennis Ritchie at Bell Labs in the early 1970s.
○​ Primarily designed for system programming (like operating systems).
○​ Evolved from languages like BCPL and B.
●​ Key Features of C:
○​ Mid-level Language: Bridges the gap between high-level and low-level
languages.
○​ Structured Programming Language: Encourages modular and organized code.
○​ Procedural Language: Focuses on procedures (functions) to solve problems.
○​ Portable: C programs can be run on different machines with minimal changes.
○​ Powerful and Efficient: Allows direct memory manipulation, resulting in fast
execution.
●​ Importance:
○​ Foundation for many modern programming languages (C++, Java, Python, etc.).
○​ Widely used in operating system development (e.g., Linux kernel).
○​ Used in embedded systems, game development, and high-performance
applications.

2. Basic Structure/Block Structure of C Program

●​ Preprocessor Directives:
○​ Start with # symbol.
○​ Processed before compilation.
○​ #include <header_file>: Includes header files (e.g., stdio.h for input/output,
conio.h for console I/O) which contain predefined function declarations.
○​ #define SYMBOL value: Defines symbolic constants for easier code readability
and modification.
●​ main() Function:
○​ Entry point of every C program. Execution begins here.
○​ Return type int: Indicates that the function returns an integer value to the
operating system (typically 0 for successful execution).
●​ Braces {}:
○​ Used to define code blocks.
○​ Enclose the body of the main() function and other functions.

Basic Structure:​
#include <stdio.h> // Preprocessor directive (e.g., for input/output)

// Global declarations (optional - variables declared outside functions)

int main() { // main function - execution starts here

// Local declarations (variables declared inside main function)
 // Statements (instructions to be executed)

return 0; // Return statement (indicates successful execution)

}​
​

●​ Source Code:
○​ C program files have a .c extension (e.g., myprogram.c).
○​ Compilation Process: Source code (.c) is compiled into machine code
(executable).

3. Variables, Identifiers, Tokens, Constants

●​ Variables:
○​ Named memory locations used to store data values.
○​ Declaration: Specifies the variable name and data type (e.g., int age;).
○​ Initialization: Assigning an initial value to a variable (e.g., int age = 20;).
●​ Identifiers:
○​ Names given to variables, functions, labels, etc.
○​ Rules for naming:
■​ Can contain letters (a-z, A-Z), digits (0-9), and underscores (_).
■​ Must start with a letter or underscore.
■​ Cannot be a reserved keyword (e.g., int, if, for).
■​ Case-sensitive (e.g., age and Age are different).
●​ Tokens:
○​ Smallest individual units in a C program.
○​ Types of Tokens:
■​ Keywords: Reserved words with special meaning (e.g., int, float, if, else,
for, while, return).
■​ Identifiers: User-defined names (as explained above).
■​ Constants: Fixed values that do not change during program execution.
■​ Strings: Sequence of characters enclosed in double quotes (e.g.,
"Hello").
■​ Special Symbols: Symbols with specific meaning (e.g., +, -, *, /, ;, {, }, (),
[]).
■​ Operators: Symbols that perform operations (e.g., +, -, =, ==, &&).
●​ Constants:
○​ Fixed values.
○​ Types of Constants:
■​ Integer Constants: Whole numbers (e.g., 10, -5, 0).
■​ Floating-Point Constants (Float): Numbers with decimal points (e.g.,
3.14, -2.5).
■​ Character Constants: Single characters enclosed in single quotes (e.g.,
'A', '7', ' ' - space).
■​ String Constants: Sequences of characters in double quotes (e.g.,
"Computer Science").

4. Data Types with Sizes

●​ Primary Data Types (Fundamental Data Types):
○​ int (Integer): Stores whole numbers (e.g., -10, 0, 25).
■​ Size: Typically 2 bytes (16 bits) or 4 bytes (32 bits), depending on the
compiler and system architecture.
○​ float (Floating-point): Stores single-precision floating-point numbers (numbers
with decimal points).
■​ Size: 4 bytes (32 bits).
○​ char (Character): Stores single characters.
 ■​ Size: 1 byte (8 bits).
○​ double (Double-precision floating-point): Stores double-precision
floating-point numbers (higher precision than float).
■​ Size: 8 bytes (64 bits).
○​ void: Represents the absence of data type. Commonly used for functions that do
not return a value.
●​ Sizes and Range:
○​ The size of a data type determines the range of values it can store. Larger size
= wider range.
○​ sizeof() operator: Used to determine the size (in bytes) of a variable or data type
(e.g., sizeof(int), sizeof(age)).

5. Operators and their Usages

●​ Arithmetic Operators:
○​ + (Addition)
○​ - (Subtraction)
○​ * (Multiplication)
○​ / (Division) - Integer division truncates decimal part (e.g., 5/2 = 2). Floating-point
division gives decimal result (e.g., 5.0/2.0 = 2.5).
○​ % (Modulo/Remainder) - Gives the remainder of integer division (e.g., 5%2 = 1).
●​ Relational Operators:
○​ == (Equal to) - Checks if two operands are equal. Returns 1 (true) or 0 (false).
○​ != (Not equal to) - Checks if two operands are not equal. Returns 1 (true) or 0
(false).
○​ > (Greater than)
○​ < (Less than)
○​ >= (Greater than or equal to)
○​ <= (Less than or equal to)
●​ Logical Operators:
○​ && (Logical AND) - Returns true (1) if both operands are true (non-zero).
○​ || (Logical OR) - Returns true (1) if at least one operand is true (non-zero).
○​ ! (Logical NOT) - Inverts the logical state of its operand (true becomes false, false
becomes true).
●​ Assignment Operators:
○​ = (Assignment) - Assigns the value on the right to the variable on the left (e.g., x
= 10;).
○​ Shorthand Assignment Operators:
■​ += (Add and assign, e.g., x += 5; is equivalent to x = x + 5;)
■​ -= (Subtract and assign)
■​ *= (Multiply and assign)
■​ /= (Divide and assign)
■​ %= (Modulo and assign)
●​ Increment and Decrement Operators:
○​ ++ (Increment) - Increases the value of a variable by 1.
■​ Prefix ++x: Increment before using the value.
■​ Postfix x++: Increment after using the value.
○​ -- (Decrement) - Decreases the value of a variable by 1.
■​ Prefix --x: Decrement before using the value.
■​ Postfix x--: Decrement after using the value.
●​ Conditional Operator (Ternary Operator):
○​ condition ? expression_if_true : expression_if_false;
○​ Evaluates condition. If true, returns expression_if_true; otherwise, returns
expression_if_false.
●​ Bitwise Operators (Brief Introduction - may not be heavily emphasized in exams):
○​ Operate on individual bits of integer data.
○​ & (Bitwise AND)
○​ | (Bitwise OR)
 ○​ ^ (Bitwise XOR)
○​ ~ (Bitwise NOT)
○​ << (Left Shift)
○​ >> (Right Shift)
●​ Operator Precedence and Associativity:
○​ Precedence: Determines the order of operations (e.g., * and / have higher
precedence than + and -).
○​ Associativity: Determines the direction of evaluation when operators of the
same precedence are present (e.g., most arithmetic operators are left-to-right
associative). Use parentheses () to explicitly control the order of evaluation.

6. Control Structures
●​ Selection (Conditional) Control Structures:

if statement: Executes a block of code if a condition is true.​

if (condition) {
// Code to execute if condition is true
}​
​

if-else statement: Executes one block of code if the condition is true, and another block if false.​
if (condition) {
// Code if condition is true
} else {
// Code if condition is false
}​
​

else-if ladder: Checks multiple conditions in sequence.​

if (condition1) {
// Code if condition1 is true
} else if (condition2) {
// Code if condition2 is true
} else if (condition3) {
// Code if condition3 is true
} else {
// Code if none of the above conditions are true
}​
​

switch-case statement: Multi-way selection based on the value of an expression.​

switch (expression) {
case constant1:
// Code to execute if expression == constant1
break; // Exit switch after this case
case constant2:
// Code to execute if expression == constant2
break;
// ... more cases ...
default: // Optional default case
// Code to execute if no case matches
break;
}​
​

■​ break statement: Essential to exit the switch block after a case is

matched. Without break, execution falls through to the next case.
 ■​ default case: Optional; executed if none of the case constants match the
expression.
●​ Iteration (Looping) Control Structures:

for loop: Used when you know in advance how many times you need to repeat a block of code.​
for (initialization; condition; increment/decrement) {
// Code to be repeated
}​
​

■​ initialization: Executed once at the beginning of the loop.

■​ condition: Checked before each iteration. Loop continues as long as the
condition is true.
■​ increment/decrement: Executed after each iteration.

while loop: Repeats a block of code as long as a condition is true. Condition is checked before
each iteration.​
while (condition) {
// Code to be repeated as long as condition is true
// Make sure to update variables in the condition to avoid infinite loop
}​
​

do-while loop: Similar to while loop, but the condition is checked after each iteration.
Guarantees at least one execution of the loop body.​
do {
// Code to be repeated at least once
// Condition is checked after the first execution and then after each iteration
} while (condition);​
​

●​ Unconditional Control Statements:

goto statement: Unconditionally jumps to a labeled statement in the program. Generally

discouraged as it can make code harder to read and debug.​
goto label_name;
// ... code ...
label_name:
// ... code ...​
​

○​ return statement: Exits the current function and returns control to the calling
function. Can also return a value from a function.
○​ break statement:
■​ Used to exit a loop ( for, while, do-while) prematurely.
■​ Used to exit a switch statement after a case is matched.
○​ continue statement: Skips the rest of the current iteration of a loop and
proceeds to the next iteration.

7. Functions
●​ System-defined/Predefined Functions (Library Functions):
1.​ Functions provided by the C standard library.
2.​ Perform common tasks (input/output, math operations, string manipulation, etc.).
3.​ Examples: printf() (formatted output), scanf() (formatted input), sqrt() (square
root), pow() (power), strlen() (string length).
 4.​ Header Files: Function declarations for library functions are found in header files
(e.g., stdio.h, math.h, string.h). You must #include the appropriate header file to
use library functions.
●​ User-defined Functions:
1.​ Functions created by the programmer to perform specific tasks in their program.
2.​ Modular Programming: Functions promote code reusability, organization, and
readability.
3.​ Function Components:

Function Declaration (Prototype): Tells the compiler about the function's return type, name,
and parameters before it is used. Usually placed at the beginning of the program or in header
files.​
return_type function_name(parameter_list); // e.g., int add(int num1, int num2);​
​

Function Definition: Contains the actual code (statements) that the function executes.​
return_type function_name(parameter_list) {
// Function body - code to perform the task
// ...
return return_value; // If return_type is not void
}​
​

Function Calling: Invokes the function to execute its code.​

result = function_name(argument_list); // e.g., sum = add(5, 3);​
​

●​ Four Methods of User-defined Functions (Based on arguments and return value):

No Arguments, No Return Value: Function performs a task but doesn't receive input or send
back a result.​
void print_message() {
printf("Hello!\n");
}​
​

No Arguments, Return Value: Function performs a task and returns a value, but doesn't
receive input arguments.​
int get_random_number() {
return rand(); // Example (requires srand() for proper use)
}​
​

Arguments, No Return Value: Function receives input arguments to perform a task but doesn't
return a value.​
void print_sum(int a, int b) {
printf("Sum: %d\n", a + b);
}​
​

Arguments, Return Value: Function receives input arguments, performs a task, and returns a
result.​
int add(int num1, int num2) {
return num1 + num2;
}​
​
8. Arrays and Strings
●​ Arrays:
○​ Definition: **Collection of elements of the same data type stored in contiguous
memory locations.

Declaration: Specifies the array name, data type, and size (number of elements).​
data_type array_name[size]; // e.g., int numbers[5];​
​

○​ Initialization: Assigning initial values to array elements.

■​ At declaration: int numbers[5] = {10, 20, 30, 40, 50};

Element-wise:​
int numbers[5];
numbers[0] = 10;
numbers[1] = 20;
// ... and so on​
​

Accessing Elements: Using index (subscript) - 0-based indexing (first element is at index 0).​
int first_element = numbers[0]; // Accessing the first element​
​

○​ 2D Arrays (Two-Dimensional Arrays): Arrays of arrays, representing tables or

matrices.
■​ Declaration: data_type array_name[rows][columns]; (e.g., int matrix[3][4];
- 3 rows, 4 columns)

Initialization:​
int matrix[2][2] = { {1, 2}, {3, 4} };​
​

■​ Accessing Elements: Using row and column indices:

matrix[row_index][column_index].
●​ Strings:
○​ Definition: Array of characters terminated by a null character \0. The null
character marks the end of the string.
○​ Declaration: char string_name[size]; (e.g., char name[20]; - can store a string up
to 19 characters + null terminator).
○​ Initialization:
■​ char name[] = "John"; (Null terminator \0 is automatically added)
■​ char name[5] = {'J', 'o', 'h', 'n', '\0'}; (Explicitly including null terminator)
○​ String Functions (from string.h header file - you need to #include
<string.h>):
■​ gets(string): Reads a line of text from standard input into a string ( Note:
gets() is considered unsafe due to buffer overflow risks. fgets() is a safer
alternative, but might not be emphasized at this level).
■​ getc(): Reads a single character from standard input (more general
character input, not string-specific).
■​ puts(string): Prints a string to standard output followed by a newline
character.
■​ putc(char): Prints a single character to standard output (more general
character output, not string-specific).
■​ strlen(string): Returns the length of a string (excluding the null
terminator).
 ■​ strcpy(destination_string, source_string): Copies the source_string to
destination_string.
■​ strcmp(string1, string2): Compares two strings lexicographically
(dictionary order). Returns 0 if strings are equal, negative if string1 comes
before string2, positive if string1 comes after string2.
■​ strcat(destination_string, source_string): Concatenates (appends)
source_string to the end of destination_string.

9. Pointers
●​ Definition: A pointer is a variable that stores the memory address of another
variable.
●​ Purpose:
○​ Direct Memory Access: Pointers allow you to directly manipulate memory
locations.
○​ Dynamic Memory Allocation: Used for allocating memory during program
execution (not covered in this syllabus, but important concept related to pointers).
○​ Function Arguments (Pass by Reference): Pointers enable functions to modify
the original variables passed as arguments.
○​ Data Structures: Essential for building complex data structures like linked lists,
trees, etc.

Declaration:​
data_type *pointer_name; // e.g., int *ptr; - ptr is a pointer to an integer​
​

○​ data_type: Specifies the data type of the variable that the pointer will point to.
○​ * (asterisk): Indicates that pointer_name is a pointer variable.
●​ Initialization:

Assigning the address of a variable to a pointer using the address-of operator &:​
int num = 25;
int *ptr;
ptr = # // ptr now stores the address of num​
​

○​ & (Address-of operator): Returns the memory address of a variable.

●​ Dereferencing:

Accessing the value stored at the memory address pointed to by a pointer using the
dereference operator *:​
int value = *ptr; // value now holds the value of num (which is 25) ​
​

○​ * (Dereference operator/Value-at-address operator): When used with a pointer, it

accesses the value stored at the memory location pointed to by the pointer.

Example:​
#include <stdio.h>

int main() {
int num = 10;
int *ptr;

ptr = # // ptr points to the address of num

printf("Address of num: %p\n", &num); // Print address of num (using &)

 printf("Value of ptr: %p\n", ptr); // Print value of ptr (which is address of num)
printf("Value of num: %d\n", num); // Print value of num (direct access)
printf("Value at address pointed by ptr: %d\n", *ptr); // Print value at address using *ptr
(dereferencing)

*ptr = 20; // Modify the value of num through the pointer

printf("Modified value of num: %d\n", num); // num is now 20

return 0;
}​
​

Key Tips for Exam Preparation:

●​ Understand Concepts: Focus on understanding the underlying principles rather than

just memorizing syntax.
●​ Practice Programs: Write and run simple C programs for each topic to solidify your
understanding.
●​ Trace Code: Practice tracing code execution to predict output.
●​ Review Examples: Go through examples in your textbook and class notes.
●​ Focus on Reduced Syllabus: Prioritize the topics included in the reduced syllabus.
●​ Past Papers: If available, review past exam papers to understand the exam pattern and
question types.

Good luck with your Computer Science XII exam!