Week 10: Programming, OOP & Computer Graphics

1. Programming Fundamentals in C

C's four storage classes are: auto (default, local scope, exists only during the function call), static (retains its value between function calls, initialised only once), extern (declares a variable defined elsewhere, often another file), and register (a hint to store the variable in a CPU register for faster access — a mere hint the compiler may ignore). A common exam trap: a static local variable inside a function keeps its value across repeated calls, unlike an ordinary local variable which resets every call.

An array name, in most expression contexts, decays to a pointer to its first element — this is why arr[i] and *(arr + i) are equivalent, and why pointer arithmetic (ptr + 1 advances by sizeof(*ptr) bytes, not 1 byte) is central to understanding both arrays and dynamic memory in C. Passing an array to a function actually passes a pointer, which is why sizeof on a function parameter that "looks like" an array gives the pointer's size, not the array's.

void counter_auto(void)  { int c = 0; c++; printf("%d\n", c); }  // always prints 1
void counter_static(void){ static int c = 0; c++; printf("%d\n", c); } // prints 1,2,3,...

Calling counter_auto() three times prints: 1 1 1
Calling counter_static() three times prints: 1 2 3

(static's initializer "= 0" runs only ONCE, the first time control reaches it)

2. Object-Oriented Programming Concepts

The four pillars: Encapsulation bundles data and the methods operating on it into one unit (a class), restricting direct access via access modifiers. Abstraction exposes only essential behaviour while hiding implementation detail (an interface or abstract class defines what, not how). Inheritance lets a derived class reuse and extend a base class's members. Polymorphism lets the same interface behave differently depending on the actual object — compile-time (function/operator overloading, resolved by the compiler using argument types) versus run-time (virtual functions/method overriding, resolved at execution using the actual object type, enabling a base-class pointer to correctly call a derived class's overridden method).

Run-time polymorphism specifically requires a virtual function mechanism (implemented via a vtable in languages like C++): without it, calling a method through a base-class pointer would always invoke the base class's version, even if the pointer actually points to a derived object — this exact scenario is one of the most frequently tested OOP questions on this paper.

3. Computer Graphics Basics

Basic graphics primitives are generated algorithmically: Bresenham's line algorithm draws lines using only integer arithmetic (no floating-point division), making it fast and exact for raster displays; Bresenham's/midpoint circle algorithm extends similar integer-only logic to circles, using 8-way symmetry to compute only one octant and mirror the rest.

2D transformations are represented as matrices applied to a point's coordinates: translation, scaling and rotation each have a standard matrix form, and homogeneous coordinates (adding a third coordinate) let translation be expressed as matrix multiplication too, so multiple transformations can be composed into a single combined matrix. Clipping (removing parts of a scene outside a viewing window) uses algorithms like Cohen-Sutherland for lines, which assigns a 4-bit region code to each endpoint to quickly accept/reject/subdivide a line against the clip window.

4. Hands-on Exercise

5. Exam-Style Practice (UGC NET Pattern)

Five NTA-pattern questions on C internals, OOP and graphics fundamentals.