Advanced C Programming

Advanced C Programming, available at $24.99, has an average rating of 4.7, with 69 lectures, based on 60 reviews, and has 1073 subscribers.

You will learn about Great and very deep understanding of pointers and memory management Proficiency in using preprocessor The ability to write modular code, that is extendable, readable and maintainable Understand how to use C constructs (like structures, unions, arrays, ..) in real-life problems 5 Projects to cover most of the topics discussed through the course This course is ideal for individuals who are Students who have already taken the first steps in C programming and would like to understand what happens under the hood or Students planning to use C programming as their major language at work or study or Students interested in embedded systems, firmware design, kernels, drivers and other low-level programming domains It is particularly useful for Students who have already taken the first steps in C programming and would like to understand what happens under the hood or Students planning to use C programming as their major language at work or study or Students interested in embedded systems, firmware design, kernels, drivers and other low-level programming domains.

Enroll now: Advanced C Programming

Summary

Title: Advanced C Programming

Price: $24.99

Average Rating: 4.7

Number of Lectures: 69

Number of Published Lectures: 69

Number of Curriculum Items: 69

Number of Published Curriculum Objects: 69

Original Price: $24.99

Quality Status: approved

Status: Live

What You Will Learn

Great and very deep understanding of pointers and memory management
Proficiency in using preprocessor
The ability to write modular code, that is extendable, readable and maintainable
Understand how to use C constructs (like structures, unions, arrays, ..) in real-life problems
5 Projects to cover most of the topics discussed through the course

Who Should Attend

Students who have already taken the first steps in C programming and would like to understand what happens under the hood
Students planning to use C programming as their major language at work or study
Students interested in embedded systems, firmware design, kernels, drivers and other low-level programming domains

Target Audiences

Students who have already taken the first steps in C programming and would like to understand what happens under the hood
Students planning to use C programming as their major language at work or study
Students interested in embedded systems, firmware design, kernels, drivers and other low-level programming domains

Thank you for taking few seconds to explore my course.

If you have already started learning C programming, and now you are curious about deep understanding about what happens behind the scene, then this course is for you.

My approach in this course is to take every topic down to its roots, and using real-life example instead of naive example.

Starting with the preprocessors, we explore how does it work, and how to debug it with specific compiler flags.

Moving on to functions, we explore the execution model, and how does the CPU handles function calls, argument passing, how local variables are managed in the stack and more.

The pointers ! Probably the topic that is most known of its ambiguity. In this class, we try to simplify things by examples. We explore the dynamic memory allocation concept, and implement a dynamic memory manager as an example.

We explore structures and unions, covered with real-life example.

We take an quick overview about modular design and how to develop the code in a way that can be re-used.

At the end, we develop a sample BMP image editor, aggregating few examples that we did through the course.

Needless to say, you have 30 days money back guarantee. If you find the course not suitable for you (I promise it isn’t), you can return it back and get your money.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Preparing the environment

Lecture 2: GCC on Windows

Lecture 3: The compilation process

Lecture 4: Projects Source Files

Chapter 2: The C Preprocessor

Lecture 1: The #define directive

Lecture 2: Function-like macros

Lecture 3: CAUTION with using function-like macros

Lecture 4: Defining macros through compiler

Lecture 5: Predefined macros

Lecture 6: #include directive

Lecture 7: #if directive

Lecture 8: Some notes about #if

Chapter 3: Functions

Lecture 1: Functions explained

Lecture 2: Functions Demo

Lecture 3: Local and Global Variables

Lecture 4: Scope and Lifetime demo

Lecture 5: Function Execution Model

Lecture 6: Function Execution Model Demo

Lecture 7: Calling Convention

Lecture 8: Iterative vs Recursive Functions

Lecture 9: Functions vs Function-like macros

Lecture 10: Performance vs Code Size Trade-off

Chapter 4: Arrays

Lecture 1: Introduction to Arrays

Lecture 2: Notes on arrays

Lecture 3: How arrays are arranged in the memory

Lecture 4: Characteristics of Arrays

Lecture 5: 2D and higher dimensional arrays

Lecture 6: Real Life use cases for arrays

Lecture 7: [PROJECT]: TicTacToe Game

Lecture 8: [PROJECT]: Implementing TicTacToe Game

Lecture 9: Extending TicTacToe

Chapter 5: Pointers

Lecture 1: Introduction to Pointers

Lecture 2: Arrays and Pointers

Lecture 3: Pointer operators and Pointer casting

Chapter 6: Common Uses of Pointers

Lecture 1: [Concept] Pass by Value vs Pass by Address

Lecture 2: [Example] Pass by by Value vs Pass by Address

Lecture 3: Function output parameters

Lecture 4: Pass/Return an array to/from functions

Lecture 5: [Concept] Dynamic memory allocation

Lecture 6: [Example] Dynamic memory allocation

Lecture 7: sizeof operator

Chapter 7: Strings

Lecture 1: How strings are represented in C

Lecture 2: Strings Do's and Don'ts

Lecture 3: Standard string manipulation functions

Chapter 8: Advanced Pointers

Lecture 1: Advanced Pointer Topics

Lecture 2: Use Case: Capturing input arguments

Chapter 9: Structures and Unions

Lecture 1: Introduction to Structures

Lecture 2: Passing/Returning structures to/from functions

Lecture 3: Arrays of Structures

Lecture 4: Pointer to Structures

Lecture 5: Nested structures

Lecture 6: Packing and Padding

Lecture 7: [PROJECT] Memory Manager – Theory

Lecture 8: [PROJECT] Memory Manager – Lab

Lecture 9: [PROJECT] Input Argument Parser Library

Chapter 10: PROJECT: Menu

Lecture 1: [PROJECT] Menu – Theory

Lecture 2: [PROJECT] Menu – Lab

Lecture 3: Why to use input[4] with fgets

Lecture 4: Unions and Menu Improvement

Chapter 11: User Defined Types

Lecture 1: Enums

Lecture 2: Typedef

Chapter 12: File Management

Lecture 1: File Management

Lecture 2: Modes of file opening

Lecture 3: The usage of fprintf

Chapter 13: [PROJECT] Bitmap File Editor

Lecture 1: Theory

Lecture 2: Lab

Lecture 3: Lab – Change the contrast of an arbitrary bitmap image

Lecture 4: Note on the bitmap file used in this example

Lecture 5: More ideas on Bitmap project for your own practice

Instructors

Ahmed Adel
Senior Software Engineer

Rating Distribution

1 stars: 2 votes
2 stars: 2 votes
3 stars: 4 votes
4 stars: 17 votes
5 stars: 35 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu