Mô tả

What you will learn in this course?

The C programming language in 2020 is still one of the most popular and widely used languages. Having C programming skills gives you great career options, but learning the C language, particularly some of the trickier advanced stuff can be really difficult.

This course is designed to take your basic C skills to the next level and help you obtain mastery of the language by helping you understand advanced concepts of the C programming language, enabling you to master the art of problem-solving in programming using efficient, proven methods.

You’ll learn how to write high-quality C code and to make yourself more marketable for higher-level programming positions.

Just some of the topics in this huge 28-hour course include Threads, Function Pointers, Double Pointers, Recursion, Networking using Sockets, Bit manipulation, Macros, Signals, Storage Classes and loads more.  Check the curriculum on this page for full details of what is included in this very comprehensive course.

By the end of this course, with your new-found skills, you will be able to apply for real-time/embedded C programming positions or any job that requires mastery of the C programming language and be able to apply your new skills developing your own Advanced C programs.

What's different about this course?

Jason Fedin is your instructor in this course and this course takes the skills you learned in that course to the next level.

This course focuses on the details and a thorough understanding of all advanced C programming concepts. This is not just a how-to course, it is a "why?" course.

You will learn how to implement specific advanced C concepts such as multi-threading and double pointers, in addition to learning why they are the best approach and how they make you a high-quality C programmer.

Many, many examples, challenges and quizzes are provided to test your understanding of every concept that you have learned.

This course is unique to other courses here at Udemy in that the details and the why are explained. We do not just go through projects and provide a how-to.

Who is the course aimed at?

This is not a beginner's course.  It's assumed you have some knowledge of the C programming language, preferably having completed our Beginner course (here on Udemy) or similar training and/or commercial programming experience in C or a similar language.

Getting started

If you are ready to get started, click on the enroll or Add to Cart button on this page and start taking your C Language skills to the next level.

Bạn sẽ học được gì

Understand and be able to apply advanced concepts of the C programming language to create advanced C applications.

Understand Function and Double Pointers, Recursion, Bit Manipulation, Macros, Signals and loads more (check curriculam on this page for full list).

Learn all about threads and networking with Sockets.

Master the art of problem solving in programming using efficient, proven methods.

Be able to apply advanced C concepts to other programming languages.

How to write high quality C code, to make yourself more marketable for higher level programming positions and be apply for real-time/embedded programming positions.

Yêu cầu

  • Basic knowledge of the C programming language (ideally having completed our Beginners course on Udemy).
  • A computer running Microsoft Windows, Linux or the Mac operating systems.
  • At least 4GB of ram on your computer.

Nội dung khoá học

24 sections

Introduction

4 lectures
Welcome to Class!
14:42
Class Organization
05:55
The C99 Standard
05:03
The C11 Standard
06:00

Installing Required Software

15 lectures
Overview
04:50
Installing the C Compiler (Windows)
08:38
Installing CodeLite On Windows
03:51
Configuring CodeLite on Windows
18:30
Installing the C Compiler (Mac)
04:16
Installing CodeLite on Mac
04:43
Configuring CodeLite on Mac
19:01
Installing CodeLite on Ubuntu Linux
06:43
Configuring CodeLite on Ubuntu Linux
10:46
Creating a Default CodeLite Project Template (All Versions)
07:16
Using the Command Line Interface
02:18
Using the Command Line Interface on Windows
10:37
Using the Command Line Interface on Mac
10:08
Using the Command Line Interface on Linux
10:10
Using a Web-based C compiler
07:46

Starting to Write Code

3 lectures
Exploring the CodeLite Environment
12:04
Creating our first C program
07:22
Building/Compiling our first program
13:35

Working with Larger Programs

6 lectures
Overview
18:49
Compiling multiple source files from the command line
05:45
Makefiles
05:57
Communication between files
04:12
Using Header files effectively
04:46
Heap and Stack Memory Allocation
07:40

Storage Classes

6 lectures
Automatic Variables
12:39
External
13:22
Static
14:09
Register
08:29
(Quiz)
12 questions
(Challenge)
02:56

Advanced Data Types

11 lectures
The #define statement (constants)
09:54
Using typedef
10:37
Variable Length Arrays
10:55
(Challenge) Variable Length Arrays
01:54
Flexible Array Members
05:11
(Challenge) Flexible Array Members
01:51
Complex number types
15:51
(Challenge) Complex number types
02:28
Designated Initializers
10:49
(Quiz)
14 questions
(Demonstration) Challenge solutions
14:03

Type Qualifiers

4 lectures
const
14:33
volatile
05:00
restrict
08:05
(Quiz)
9 questions

Bit Manipulation

15 lectures
Binary numbers and bits
13:05
(Challenge) Binary numbers and Bits
02:07
(Demonstration) Binary numbers and Bits
10:40
Bitwise Operators (Logical)
21:43
Bitwise Operators (Shifting)
13:22
(Challenge) Bitwise Operators
04:38
(Demonstration) Bitwise Operators
05:27
Bitmasks
14:34
Using Bit Operators to pack data
09:20
(Challenge) Setting and Reading bits
02:22
(Demonstration) Setting and Reading bits
06:08
Using Bit Fields to pack data
10:08
(Challenge) Using Bit Fields to pack data
05:10
(Demonstration) Using Bit Fields to pack data
07:49
(Quiz)
15 questions

Advanced Control Flow

8 lectures
The goto statement
09:36
(Challenge) The goto statement
01:53
The null statement
05:02
The comma operator
07:40
setjmp and longjmp functions
12:45
(Challenge) setjmp and longjmp functions
01:28
(Demonstration) Advanced Control Flow
08:06
(Quiz)
8 questions

Input and Output

11 lectures
char functions (input)
19:35
char functions (output)
11:30
(Challenge) char functions
03:00
(Demonstration) char functions
12:16
string functions
17:49
(Challenge) string functions
02:11
(Demonstration) string functions
07:03
Formatting functions
20:37
(Challenge) Formatting functions
02:55
(Demonstration) Formatting functions
05:08
(Quiz)
10 questions

Advanced Function Concepts

10 lectures
Variadic Functions
17:47
va_copy
08:27
(Challenge) Variadic Functions
03:30
(Demonstration) Variadic Functions
03:58
Recursion
19:35
(Challenge) Recursion
02:54
(Demonstration) Recursion
10:27
Inline Functions
06:11
_Noreturn Functions
07:50
(Quiz)
14 questions

Unions

6 lectures
Overview
09:39
Defining a Union
10:56
Accessing Union Members
10:41
(Challenge) Unions
03:05
(Demonstration) Unions
03:52
(Quiz)
8 questions

The Preprocessor

5 lectures
Overview
04:03
Conditional Compilation
15:49
Include guards and #undef
04:11
#pragma and #error
10:47
(Quiz)
16 questions

Macros

7 lectures
Overview
06:16
Macros vs. Functions
05:17
Creating your own Macros
16:56
Preprocessor Operators
16:35
Predefined Macros
05:59
(Challenge) Macros
06:07
(Demonstration) Macros
09:21

Advanced Debugging, Analysis, and Compiler Options

10 lectures
GCC Compiler Options (part 1)
17:53
GCC Compiler Options (part 2)
17:37
Debugging with the preprocessor
21:10
Debugging with gdb (part 1)
18:01
Debugging with gdb (part 2)
18:53
core files
13:11
Profiling
10:47
Static Analysis
08:42
(Challenge)
16:23
(Demonstration)
18:34

Advanced Pointers

9 lectures
Double pointers (pointer to a pointer)
14:19
Double pointers (pointer to a pointer) Part 2
15:17
(Challenge) Double pointers
06:01
(Demonstration) Double pointers
08:07
Function pointers
17:38
(Challenge) Function pointers
07:23
(Demonstration) Function pointers
07:38
void pointers
10:54
(Quiz)
15 questions

Static Libraries and Shared Objects

10 lectures
Overview
15:50
Creating a Static Library (archive)
17:45
(Challenge) Static Library
04:23
(Demonstration) Static Library
12:12
Creating a Dynamic Library (Shared object)
23:35
(Challenge) Dynamic Library
03:54
(Demonstration) Dynamic Library
12:49
Dynamically loading a shared object
20:55
(Challenge) Dynamic Loading
03:53
(Demonstration) Dynamic Loading
09:51

Useful C Libraries

8 lectures
Assert
08:47
General Utilities (stdlib.h)
16:59
General Utilities (stdlib.h) part 2
15:44
General Utilities (stdlib.h) part 3
17:14
Date and Time functions
17:10
(Challenge)
02:55
(Demonstration)
11:01
(Quiz)
15 questions

Data Structures

12 lectures
Abstract Data Types
08:36
Linked Lists (Overview)
07:26
Linked LIsts (Implementation)
20:30
(Challenge) Linked Lists
05:57
(Demonstration) Linked Lists
12:11
Stacks (Overview)
06:07
Stacks (Implementation)
12:15
Queues (Overview)
05:51
Queues (Implementation)
12:31
Binary Trees (Overview)
10:25
Binary Trees (Implementation)
08:52
(Quiz)
20 questions

Interprocess Communication and Signals

8 lectures
Interprocess Communication
15:43
Signals (Overview)
07:08
Raising a Signal
07:09
Handling a Signal using the signal function
12:30
Handling a Signal using sigaction
10:52
The fork() system call
09:23
(Challenge)
06:41
(Demonstration)
07:13

Threads

10 lectures
Overview
09:35
Creating a thread
10:43
Passing arguments and returning values
08:48
Common Thread functions
10:35
Thread Synchronization Concepts
09:16
Mutexes
16:42
Condition Variables
08:57
(Challenge)
13:21
(Demonstration)
15:46
(Quiz)
14 questions

Networking (Sockets)

6 lectures
Overview
08:52
The Socket API
19:19
Creating a Server Socket
09:49
Creating a Client Socket
10:25
(Challenge)
02:44
(Demonstration)
10:19

Conclusion

1 lectures
Course Summary
23:11

Extra Information - Source code, and other stuff

2 lectures
Source Codes
01:05
Bonus Lecture and Information
04:49

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.