Course Overview

Advanced C programming course skims through the basics of C and soon jumps over to the core of C programming language which looks simple but difficult to master. Our C Training will make the participant learn deep C secrets and develop a fairly advanced level of C programming expertise which is essential to write complex mission-critical systems and application software.

Course Highlight

Advanced C Programming course will be delivered by our Founder/Director who is an Expert with 17+ years of experience in Linux Kernel and SAN software development. The C training flow will be an assignment driven model so that participants can develop an expert level C programming skills.
Participants will be writing lots of C programs dealing with operator precedence, conditional constructs, strings, pointers, arrays, arrays & pointers, double pointers, function pointers, pointers to arrays, internal storage for various data-types, creating in memory data-structures, bit-field operators, recursions, function call and stack formation, standard file I/O library, buffered IO, etc.

Course Delivery

Lectures, Classroom Discussions, and C Programming Lab Exercises
30% Theory, 70% Lab
Location: ITRONIX SOLUTION, Mohali , India

Pre-Requisites

Basic knowledge of C with a deep desire to learn C programming in depth.

Target Audience

IT Professionals and/or Students who want to become a serious Developer.
Experienced professionals preparing for Technical C-Round Interviews in Top IT Product MNCs.

Advanced C Training Course Outline

The C Language

1. C Program Compilation
2. Execution Process
3. Tokens of C Program
4. C Instructions
5. Constants, Variables
6. Identifiers and Keywords
7. Primitive Data Types
8. Structures – The Definitionv
9. Structures – Declaration & Type
10. Accessing Elements of Structure
11. Range of Signed/Unsigned Data-types
12. Efficient way of Printing Pointer
13. Compiler Memory Allocation for Data-types
14. Compiler Memory Allocation for Structures
15. Data-type Alignments
16. Compiler Memory Allocation for Unions
17. Union – Data Corruption
18. Practical Usage of Unions
19. Practical Usage of Bitfields
20. Bitfields Overflow
21. Printing every byte of an Integer
22. Enumeration
23. Typedef Statements
24. Practical example of Typedef Usage
25. typedef’ing a Function Pointer
26. Bit-Fields in Structure
27. Practical examples of Bitfield Usage
28. Structure Padding & Pitfalls
29. Programming Model & Memory Sizes
30. Why Sizeof Int and Long is 4 or 8?
31. Use of long long in 32-bit Architecture
32. Practical Example of long long
33. IA-32, IA-64, ILP-32, LP64, x86-64
34. Array – Representation
35. Array – Memory Allocation
36. Array – Declaration & Initialization
37. Two Dimensional Arrays

Pointers

1. Accessing a Variable Through Pointer
2. Pointer – Memory Allocation
3. Pointer – Declaration & Initialization
4. Pointer – Dereferencing
5. Pointers & Arrays
6. Character Arrays using Pointers
7. Array of Character Pointers
8. Memory Diagram – Array of Char Pointers
9. Arrays as Pointers – a[i] == i[a]?
10. Constant Pointers
11. Pointer Arithmetic
12. String Handling Functions
13. String Conversion Functions
14. Efficient usage of sscanf()/sprintf()

Computing Basic

1. Binary & Octal Systems
2. Decimal & Hexadecimal Systems
3. Signed Representations in Memory
4. Binary Shifts – Right & Left
5. Sign Bits and Bit-Shift Operations
6. Right Shift – Logical Vs Arithmetic Shift
7. Bit-Shift Overflow
8. ASCII Representations
9. Endian-ness – Little Vs Big
10. Endian-ness – Portability Issues
11. Operators
12. Bitwise Operations
13. Logical Operators – Short Circuit
14. Bitwise Vs Logical Operations
15. sizeof() operator
16. Pitfalls/Issues with sizeof() usage
17. Pointer Increment & Scaling
18. Operator Precedence
19. Operator Associativity
20. True meaning of Associativity
21. Examples of Precedence & Associativity
22. Ternary Operator Associativity Rule
23. Data-type Conversion Rules
24. Float to Int to Float Conversions
25. Variadic functions & default promotion rules
26. Printf Idiosynchracies
27. Pointer Format Specifiers
28. Signed Vs Unsigned – Pitfalls
29. Evaluation of i = ++i + ++i
30. Evaluation of i = ++i + ++i + ++i
31. Concept of Sequence Points
32. Example of Sequence Points

Storage Classes

1. Storage Class Specifiers
2. Scope of a Variable
3. Register, Auto, Static, Extern
4. Why Register Class and Practical Examples
5. Automatic Variables and Stack
6. Static Variables and Functions
7. True meaning of Extern
8. How to Use extern across Multiple Files with Examples
9. Best Practices for Extern Usage
10. Local/Block/Global Scope
11. Nesting of Scope
12. Lifetime of a Variable
13. Linkage of a Variable
14. What is Const?
15. Practical Examples of Const Qualifier
16. Usage of Constant in library functions (libc)
17. What is Volatile?
18. Practical Examples of Volatile Qualifier
19. Const Volatile Together?
20. Register Vs Volatile Performance?
21. Practical Examples of Const Volatile
22. Pointer Aliasing
23. What is Restrict Qualifier?
24. Restrict Keyword and Compiler Optimization
25. Examples of Restrict Qualifier

Memory

1. Dynamic Memory Allocations
2. malloc, calloc, realloc, free
3. malloc Vs calloc
4. Heap Memory
5. Stack Memory – Pitfalls
6. Dangling Pointers
7. DMA – Errors
8. Best Practices for malloc() & free()
9. DMA – Unspecified Behaviour

Functions & Pointers

1. Invoking Functions
2. Passing Arguments to Functions
3. Call by Value & Reference
4. Is C call by Value?
5. Is C call by Reference?
6. Array as Function Argument
7. Rules for Array Argument Passing
8. Multi-dimensional Array Argument Passing
9. Structure as Function Argument
10. Static Vs Dynamic Runtime Environment
11. Function Call and Runtime Stack
12. Rules for Evaluation of Function Arguments
13. Memory Organization
14. Code Segment
15. Data Segment
16. Heap Segment
17. Stack Segment
18. free space
19. register space
20. Stack Frames
21. Calling Sequence
22. View of Runtime Stack with Example
23. Access to Local Variable in Stack
24. Local Temporaries
25. Function Pointers
26. Declaration and Usage of Function Pointers
27. Function Pointers as Function Parameters
28. Practical Example of Function Pointers
29. Pointer to an Integer Array
30. C Pointers Complexity Chart
31. int **p
32. int (*p)()
33. int (*p)[] int *p()
34. int *(*p[])()
35. int *(**p)[]

Preprocessor

1. Preprocessor – #include statements
2. Multiple Inclusion of a Header File?
3. Preprocessor – #define statements
4. Preprocessor – Conditional Compilation
5. Preprocessor – Nested Macros
6. Preprocessor – Multiline Macros
7. Preprocessor – Stringizer
8. Preprocessor – Token Concatenation
9. Preprocessor – Useful Directives
10. Conditional Directives for Debugging
11. Where Macros are Heavily Used
12. Practical Examples of Macros
13. Macros Pitfalls
14. Macros Vs Enums
15. Inline Functions
16. Macros Vs Inline
17. Inline Recursive Functions

Command Line Argument

1. Environment Variables in C Programs
2. Recursion Example
3. Recursion Vs Iteration
4. Code/Space/Time Complexity

Standard I/O Library

1. Files & Streams
2. Streams Buffers
3. IO Buffers – Line Vs Full Vs No-Buffers
4. Setting & Flushing Buffers
5. File Access
6. File Access Modes
7. Sequential Vs Random Access
8. Concept of File Offsets
9. File Operation Errors
10. End-of-File Condition?
11. Return Values and Error Values
12. Character Based File I/O
13. Line Based File I/O
14. Formatted File I/O
15. Block File I/O
16. Dangerous – gets() Vs fgets()
17. File Random Access Methods