Back to Course
Official Curriculum Blueprint

C Programming Language

Foundational Software Engineering Track | 60+ Hours Practical Curriculum

Unisoft Technologies
Authorized Pearson VUE Center | Est. September 2000
Dharampeth, West High Court Road, Nagpur

01 Introduction & Fundamentals

  • History & origin of C language (Dennis Ritchie, 1972)
  • System compilation steps: Preprocessor, Compiler, Assembler, Linker
  • C Tokens structure: Identifiers, Keywords, Constant Literals, Punctuators
  • Variables rules, Constants definition, and building the first Hello World program
  • Process of code execution and basic compiler command line flags (GCC, MSVC)

02 C Data Types System

  • Primitive types: char, int, float, double and memory footprint sizes
  • Type qualifiers: signed, unsigned, short, long modifiers
  • Concept of non-primitive derived types (Arrays, Structs, Pointers)
  • Use of sizeof operator for compile-time system width queries
  • Type casting: Implicit type conversion vs Explicit type casting operators

03 Input/Output Operations

  • Formatted standard I/O services: printf() and scanf() logic
  • Precision formatting, escape codes, width flags and formatting masks
  • Unformatted I/O commands: getchar(), putchar(), gets(), puts()
  • Character I/O operations and buffering mechanics (fflush() operation)
  • Preventing input buffer overflow scenarios during nested inputs

04 Operators & Expressions

  • Arithmetic, Relational, and Logical Operators (&&, ||, !)
  • Bitwise operators: AND, OR, XOR, NOT, Left Shift, Right Shift
  • Ternary/Conditional operator expression evaluations
  • Pre/post increment (++, --) execution sequence details
  • Operator precedence and associativity rules hierarchy

05 Decision Control Structures

  • One-way branching using standard if conditions
  • Two-way branching: if-else conditional execution
  • Nested if-else statements logic mapping
  • Multi-way branch conditions: Else-If ladders
  • Conditional statements optimization and boolean evaluations

06 Looping Control structures

  • Entry-controlled looping structures: for loop syntax
  • While looping mechanics and boolean termination guards
  • Exit-controlled looping structures: do-while loop features
  • Nested loops for multidimensional data and arrays
  • Preventing infinite loops and stack boundaries control

07 Case Structure & Jumps

  • Switch-Case syntax and integer/char expression matching rules
  • Break statement role, default labels, and fall-through behavior
  • Continue keyword inside looping constructs
  • Comparing Switch structures vs nested else-if structures performance
  • Goto jumps warnings and nested loops break techniques

08 Modular Functions

  • Functions prototypes, function declarations and declarations rules
  • Parameter passing mechanisms: Call by value vs Call by reference
  • Scope rules for local variable scopes and stack allocations
  • Recursive functions syntax, call stacks, and base cases
  • Functions returning memory addresses and structures

09 Arrays in C

  • One-dimensional arrays layout, indexing, base address, array size
  • Two-dimensional arrays mapping: Row-major order contiguous memory
  • Initialization patterns: compile-time vs iterative loop assignment
  • Passing array index elements vs passing entire array arguments
  • Static size constraints and dynamic stack array considerations

10 Storage Classes

  • Automatic (auto) storage variables scope and lifetimes
  • Static storage variables persistent lifetimes within functions
  • External variables (extern keyword) for multi-file linkage
  • Register variables allocations for loop speed improvement
  • Linker scope control (Internal vs External variables scopes)

11 Preprocessor Directives

  • File inclusion (#include) directories search behaviors
  • Macro definitions (#define) values vs parameterized macros
  • Conditional compilation switches: #ifdef, #ifndef, #else, #endif
  • Prevention of duplicate linkage using header compilation guards
  • Stringizing (#) and token-pasting (##) preprocessor features

12 Pointers & Memory Addresses

  • Memory addresses system, pointer variables declarations
  • Pointer operators: Address of (&) and indirection dereference (*)
  • Pointer arithmetic rules (scaling offsets based on underlying type)
  • Double pointers (pointers to pointers) and multi-level indirection
  • Dangling, NULL, Void, and Wild pointer configurations

13 Strings Handling

  • Strings declarations: null-terminated character array system
  • String constants stored in read-only segment vs array space
  • Standard string operations: strlen, strcpy, strcat, strcmp
  • Advanced string search tools: strstr, strchr, and string splitting strtok
  • Buffer safety rules: avoiding gets() and using safer fgets() inputs

14 Structures & Unions

  • User-defined composite types, structure declarations
  • Access operators: dot (.) operator vs structure pointer arrow (->)
  • Memory structure packing, padding, and alignment dynamics
  • Unions definition and shared memory allocations rules
  • Bitfields declaration for systems hardware registers matching

15 Dynamic Memory Allocation

  • Dynamic heap memory allocation vs static stack allocation
  • Heap allocation API: malloc() function size allocations
  • calloc() function multi-element zero-initialized spaces
  • realloc() memory resizing and memory relocation rules
  • Memory leaks prevention: free() allocations and tracking pointers

16 High-Level File Handling

  • Persistent storage streams: fopen() file stream allocations
  • Standard stream permissions modes: r, w, a, r+, w+, a+
  • Text modes files I/O operations (fgets, fputs, fscanf, fprintf)
  • Binary modes block files I/O operations (fread, fwrite)
  • Cursor positions seeking controls: fseek(), ftell(), and rewind()

Unisoft Technologies Nagpur is a registered trademark since 2000. Syllabus structure aligns with IEEE computer training guidelines and MNC placement exams guidelines.

https://www.unisoftindia.org • 095030 05060 • Dharampeth, Nagpur