Advanced C Programming Masterclass Pointers Memory in C

Advanced Concepts in C Language – Pointers Masterclass, Memory Addressing, Low-Level Programming, Embedded C Preparation
Advanced C Programming Masterclass Pointers Memory in C
File Size :
9.78 GB
Total length :
31h 12m

Category

Instructor

Vlad Budnitski

Language

Last update

4/2023

Ratings

4.4/5

Advanced C Programming Masterclass Pointers Memory in C

What you’ll learn

Introduction To Pointers For Beginners
Pointers Declaration, Initialization, and Usage
Pointers Dereferencing
Multiple Indirection
Pointers Arithmetics
Generic Pointers
Dynamic Memory Allocation
“malloc” function
“calloc” function
“realloc” function & “issues”
“free” function
Dangling Pointers
Memory Leakage Tool – Valgrind
Pointers Arithmetic
“sizeof” operator
Arrays & Pointers
Strings & Pointers
A few Secrets of Strings using Pointers
Function Pointers
Arrays of Pointers to Functions

Advanced C Programming Masterclass Pointers Memory in C

Requirements

Basic knowledge of C programming language – ideally having completed my “C Programming for Beginners” course on Udemy
A computer with Windows, Linux or Mac OS
At least 4GB RAM (recommended)

Description

IntroductionC programming language still remains one of the most popular and used languages in 2022.There is a high demand for C developers in the market – at both large companies as well as startups. Thus, having good C programming skills can give you great career options in different industries, such as:- Cyber Security.- Smart Homes & Smart Cities.- Drones.- And especially in Embedded Systems where you have Sensors and Micro-Controllers.What you will learn in this course?There is an ‘ancient’ phrase saying “to become an expert in C – you need to master pointers”.One of the main objectives of this course is designed to take your basic knowledge of pointers (one of the most significant topics) to the next level. The goal is to take the basic skills you’ve gained so far in C programming and take this knowledge to a whole new level. We will cover pointers, memory addressing, pointers to functions, advanced concepts of structs and dynamic memory allocation, and so much more.The beauty of this course is that it regularly gets updated with new material. And the material being added to the course these days includes lots of information in the low-level programming (the bits and bytes), preparation for usage of Embedded C in Embedded Systems, and other very important topics for the next generation of engineers.This course covers the topics in-depth, from different angles, and with various visualizations and illustrations – that should make the learning process of pointers and low-level programming much easier and fun for you.Also, you will get a whole dedicated section on how to use a debugger and what is the debugging process that may help you so much in developing your future applications.After completing this course you will gain plenty of new skills and knowledge that may improve your chances of getting a job position as a C Developer as well as increasing your chances to pass the exam (if you’re still a student).What’s different about this course?Vlad Budnitski will be your instructor for this course.He has years of experience working as a Software Developer (also working with complex systems developed in C language). As well as 4 years of experience teaching C Programming for Beginners and Advanced C Programming in College.So you got lucky on this one because you will get knowledge from a practical software developer and experienced instructor.You will get a handpicked, concise, and straight to the point material that you will be amazed by the way these complicated pointers can be taught.This course is also guided with concrete exercises, challenges, and full solution videos – that will help you to practice the materials.Who’s this course for?First of all, this course is not for “absolute beginners” and it requires you to have at least the basic knowledge of programming. It’s assumed you have some knowledge of the basics in C – preferably having completed our “C Programming for Beginners” course (here on Udemy).This course is great both for students in college as well as graduates who need to learn and understand pointers in depth.In addition, if you’re planning to explore and master the Embedded Systems domain using Embedded C – then this course is a great preparation of various topics for the Embedded Domain. Once you master all the concepts of this course you’ll be a few steps closer to proceeding and mastering Embedded Systems, programming Micro Controllers, etc.Do you still have got doubts?That’s OK. Pointers can get us all confused to some extent… If you’re still unsure if this course is exactly what you’re looking for, feel free to go over the full detailed curriculum. Then, enroll in the course and be sure that you’ve done a great decision to improve your knowledge in pointers and to become a better C developer.

Overview

Section 1: Welcome Aboard!

Lecture 1 About the course

Section 2: Pointers – Introduction to Basics

Lecture 2 Introduction to Pointers + General Visualization

Lecture 3 Why using Pointers? [Reasons & Motivation]

Lecture 4 Another reasons and motivation behind the usage of pointers

Lecture 5 Declaration & Usage of Pointers

Lecture 6 Pointers Initialization

Lecture 7 Short Dereference

Lecture 8 Challenge #1 – Printing Value & Address of a Variable

Lecture 9 Challenge #2 – Guessing the Output

Lecture 10 Exclusive Pass By Reference Guide

Lecture 11 Quick Summary

Section 3: Pointers Arithmetic & “sizeof” operator

Lecture 12 Pointers Arithmetic Introduction

Lecture 13 Pointers Arithmetic Examples

Lecture 14 Rules – Summary

Lecture 15 Pointers Arithmetic – DIY Exercises

Lecture 16 The “sizeof” Operator – Introduction

Lecture 17 The “sizeof” Operator – Basic Practice

Lecture 18 “sizeof” & Static Arrays

Lecture 19 “sizeof” & Pointers

Section 4: Pointers Concept and Beyond

Lecture 20 Exercise – Swap Function

Lecture 21 Milestone #1 – Develop Your Real Swap Function!

Lecture 22 Milestone #1 – Solution

Lecture 23 Multiple Indirection

Lecture 24 Generic Pointer (void star) – What is “void *”? [Generic Universal Pointer]

Lecture 25 Generic Swap Function (including “memcpy” function)

Section 5: Arrays & Pointers – Theory & Practical Exercises

Lecture 26 Arrays – Memory Representation

Lecture 27 Passing an Array to a Function

Lecture 28 Search if an Element is in a Given Array

Lecture 29 Challenge#1 [Question]: Function to Find Maximum Value of an Array and Return it

Lecture 30 Challenge#1 [Solution]: Function to Find Maximum Value of an Array and Return it

Lecture 31 Challenge #2 [Question]: Calculates the Average Value of an Array (using 2 func)

Lecture 32 Challenge #2 [Solution]: Calculates the Average Value of an Array (using 2 func)

Lecture 33 Input & Print Functions – (useful for any given array)

Lecture 34 Challenge #3 – Finding and Passing by Pointer – “Min” & “Max” values of an array

Lecture 35 Challenge #3.1 [Additional] – Function to Update the Average by Reference

Lecture 36 Challenge #3.1 [Solution] – Function to Update the Average by Reference

Lecture 37 Challenge #4 – Does Array Has An Element With Good Neighbors – Question

Lecture 38 Challenge #4 – Does Array Has An Element With Good Neighbors – Solution

Lecture 39 Challenge #5 – Function To Find If Array Is Sorted Or Not – Question

Lecture 40 Challenge #5 – Iterative Solution

Lecture 41 Challenge #5 – Advanced Recursive Solution [Using Recursion & Functions]

Lecture 42 Challenge #6 -Reverse Array using Pointers Arithmetic – Iter. & Recursive – Q.

Lecture 43 Challenge #6 -Reverse Array using Pointers Arithmetic – Iter. & Recursive – S.

Lecture 44 (old version) – Exercise – Reverse Array Using Recursion And Pointer Arithmetic

Lecture 45 Challenge #7 – Count and Print the Frequency of Each Array’s Element – Question

Lecture 46 Challenge #7 – Count and Print the Frequency of Each Array’s Element – Solution

Lecture 47 Challenge #8 – Find & Return the “Second Smallest” Element – Question

Lecture 48 Challenge #8 – Find & Return the “Second Smallest” Element – Solution

Lecture 49 Challenge #9 – Find 2 specific elements in Sorted Array O(n^2) & O(n) – Question

Lecture 50 Challenge #9 – Find 2 specific elements in Sorted Array O(n^2) & O(n) – Solution

Lecture 51 Challenge #9 – Find 2 specific elements – Optimized Solution

Lecture 52 ATTENTION! Problem with Returning a Static Array from a Function

Lecture 53 Extra Practice #1 – Recursion – is Array of Integers a Palindrome – Question

Lecture 54 Extra Practice #1 – Recursion – is Array of Integers a Palindrome – Solution

Lecture 55 Extra Practice #2 – Exchanging Signs Array Recursively – Question

Lecture 56 Extra Practice #2 – Exchanging Signs Array – Solution

Lecture 57 Extra Practice #3 – Maximum of 2 Adjacent Elements (using pointers) – Question

Lecture 58 Extra Practice #3 – Maximum of 2 Adjacent Elements (using pointers) – Solution

Lecture 59 Extra Practice #4 – Print Array Elements using Pointers in C – Question

Lecture 60 Extra Practice #4 – Print Array Elements using Pointers in C – Solution

Lecture 61 Extra Practice #5 – Recursively using Pointers & Functions – Find Array Average

Lecture 62 Extra Practice #5 – Recursively using Pointers & Functions – Find Average – Sol.

Lecture 63 Extra Practice #6 – Adjacent Elements Parts Sorted in Floating Point Array – Q.

Lecture 64 Extra Practice #6 – Adjacent Elements Parts Sorted in Floating Point Array – S.

Lecture 65 Extra Practice #7 – Print Number in Binary using Recursion Function – Question

Lecture 66 Extra Practice #7 – Print Number in Binary using Recursion Function – Solution

Section 6: Arrays Swapping Exercises – Intermediate to Expert Questions!

Lecture 67 Swapping in O(n) Complexity

Lecture 68 Swapping in O(1) Complexity

Lecture 69 SwapArray(O1) – Further Visualization & Additional Clarification – part 1

Lecture 70 SwapArray(O1) – Further Visualization & Additional Clarification – part 2

Section 7: Dynamic Memory Allocation

Lecture 71 What is DMA and why we may need it?

Lecture 72 “malloc” function

Lecture 73 Challenge #1 – Creating and Returning a Dynamically Allocated Array from a Func

Lecture 74 Challenge #2 – Print Dynamically Allocated Array

Lecture 75 “calloc” function

Lecture 76 “free” function

Lecture 77 Dangling Pointer

Lecture 78 Finding Memory Leakages [Valgrind]

Lecture 79 “realloc” function

Lecture 80 “realloc” issues

Lecture 81 “realloc” – practical code example

Lecture 82 Implementing your own “universal realloc function” – Question

Lecture 83 Implementing your own “universal realloc function” – Solution #1

Lecture 84 Implementing your own “universal realloc function” – Solution #2 – using memcpy

Lecture 85 Adjustable Reallocation + Performance – Question

Lecture 86 Adjustable Reallocation + Performance – Explanation & Solution

Lecture 87 IMPORTANT Question – Create and Pass 1D Array using Pointer to Pointer!

Lecture 88 IMPORTANT Solution – Create and Pass 1D Array using Pointer to Pointer!

Section 8: Advanced Exercises – Pointers & DMA

Lecture 89 Exercise #1 – Creating a “new array” with NO DUPLICATES

Lecture 90 Exercise #2 – Splitting “source array” into ODD and EVEN arrays

Lecture 91 Exercise #3 – “Lower Case” & “Upper Case” arrays allocation

Lecture 92 Advanced: Practical Universal Insert Function – Question

Lecture 93 Advanced: Practical Universal Insert Function – Solution

Lecture 94 Advanced: Practical Universal Remove Function – Question

Lecture 95 Advanced: Practical Universal Remove Function – Solution

Lecture 96 Question – Copy an Array and pass a new one by Reference

Lecture 97 Solution – Copy an Array and pass a new one by Reference

Section 9: 2D Dynamically Allocated Arrays (Matrix)

Lecture 98 Dynamic Matrix – Introduction

Lecture 99 Arrays of Pointers – Introduction & Usage

Lecture 100 Usage of Arrays of Pointers VS Static 2D Arrays

Lecture 101 Creating a Totally Dynamically 2D Array

Lecture 102 Developing the “allocate2DMatrix” function

Lecture 103 Developing the “print2DMatrix” function

Lecture 104 Developing the “freeMatrix” function

Lecture 105 Practice Questions – 2D Dynamic Arrays – Question

Lecture 106 Swap 2 rows in 2D Dynamic Array – using Universal Approach (solution)

Lecture 107 Swap 2 columns in 2D Dynamic Array – for 2D Integer Arrays

Lecture 108 Question – 2 functions – lower and upper triangle matrix functions

Lecture 109 Solution – 2 functions – lower and upper triangle matrix creation

Lecture 110 Question – write two functions to PRINT – lower and upper triangle matrix

Lecture 111 Solution – 2 functions to print – lower and upper triangle matrix

Lecture 112 Intermediate: 2D Matrix Allocation and Passing by Reference Function – Question

Lecture 113 Intermediate: 2D Matrix Allocation and Passing by Reference Function – Solution

Section 10: Strings & Pointers

Lecture 114 Returning a string from a function – example with “strConcat”

Lecture 115 **Exclusive** Extra Lecture on Strings & Pointers

Section 11: String Library Functions Implementation – Using Pointers

Lecture 116 Library Functions Implementation – Introduction

Lecture 117 Finding String Length – Implementation in C (using pointers)

Lecture 118 Concatenating 2 Strings – Implementation in C (using pointers)

Lecture 119 Copying One String Into Another – Implementation in C (using pointers)

Lecture 120 Comparing 2 Strings – Implementation in C (using pointers)

Section 12: Debugger & Debugging – let’s find out the problems!

Lecture 121 Introduction to Debugging

Lecture 122 Debugger & Debugging Process – Learning the Basics

Lecture 123 Using Breakpoints Effectively

Lecture 124 Viewing Memory Representation in a Debugger Mode.

Lecture 125 Debugging & Pointers – easy memory representation

Lecture 126 Arrays & Pointers Arithmetic (diving deeper with the debugging process)

Lecture 127 Debugging – Strings & 2D Matrix

Section 13: Structs – Basics & Beyond

Lecture 128 Creating Arrays of Struct Variables in a Static Manner

Lecture 129 Dynamically Allocated Array of Structs.

Lecture 130 Passing structs to functions by value + Updating by Pointer

Lecture 131 Structs Composition

Lecture 132 Exercise: 2 functions to dynamically allocate an array of structs – Question

Lecture 133 Exercise: 2 functions to dynamically allocate an array of structs – Solution

Section 14: Introduction to Computer Architecture & Data Alignment

Lecture 134 Introduction to Memory, Architecture, and Alignment

Lecture 135 Word & Architectures

Lecture 136 Word Addressable VS Byte Addressable

Lecture 137 Variables Alignment

Lecture 138 Practical Checking Variables Addresses in Memory in IDE

Section 15: Structs Alignment

Lecture 139 Introduction to Padding (Data Alignment with Structs) – Structure Padding in C

Lecture 140 Practical Struct Variable Memory Utilization

Lecture 141 Example #1 – Struct Memory Utilization and Data Alignment (+padding)

Lecture 142 Example #2 – Reorganizing Members Order and its Affect on Memory Utilization

Lecture 143 Exercise #1 – Structs, Members Organization, Data Alignment and Memory – Quest.

Lecture 144 Exercise #1 – Structs, Members Organization, Data Alignment and Memory – Sol.

Lecture 145 Adding Data Member to Struct without Increasing the Size of a Variable in Memory

Lecture 146 Exercise #2 – Structs, Members Organization, Data Alignment and Memory – Quest.

Lecture 147 Exercise #2 – Structs, Members Organization, Data Alignment and Memory – Sol.

Lecture 148 Data Alignment and Padding with Structs Composition

Lecture 149 Tightly Packing & Packing to UnAligned Data

Section 16: Pointers to Functions

Lecture 150 Function Pointers – Introduction

Lecture 151 Problem Example – Motivation to use Functions Pointers

Lecture 152 Declaration of Pointer to a Function

Lecture 153 Coding Example with Pointers to Functions

Lecture 154 Common Mistakes when using a Pointer to a Function

Lecture 155 An array of Pointers to Functions

Section 17: Files – Advanced Content

Lecture 156 1. Functions for working and finding File’s Location

Lecture 157 Common things to note when working with Sequential (Textual) files

Lecture 158 Introduction to Structured Files

Lecture 159 Writing a Structure Record to a File

Lecture 160 Writing 2 Points read from the user to a file

Lecture 161 Writing an array of points to a file.

Lecture 162 Search for a specific point in a file. Reading.

Lecture 163 Edit a specific point in the file

Section 18: Enums

Lecture 164 Enums – Part 1

Lecture 165 Enum – Part 2

Section 19: Constants & Pointers Masterclass

Lecture 166 Constants – General Intro + Usage

Lecture 167 Constants – Why & When + Example

Section 20: Counting Arrays – Part #2 – Practice Exercises Function

Lecture 168 Function – FreqAsValue – Question

Lecture 169 Function – FreqAsValue – Solution

Lecture 170 Function – FindDominantValue – Question

Lecture 171 Function – FindDominantValue – Solution

Lecture 172 Function – FindSpecificValueMaxSum – Question

Lecture 173 Function – FindSpecificValueMaxSum – Solution

Lecture 174 Function – FindLargestMissingValue – Question

Lecture 175 Function – FindLargestMissingValue – Solution

Lecture 176 Function – areAllCharactersIncluded – Question

Lecture 177 Function – areAllCharactersIncluded – Solution

Section 21: OPTIONAL: Introduction to Bitwise Operations

Lecture 178 Introduction to Bitwise Operations + NOT operator

Lecture 179 The AND bitwise operator

Lecture 180 The OR bitwise operator

Lecture 181 The XOR bitwise operator and its relation to TOGGLE

Lecture 182 Using NOT, AND, OR, XOR in your own programming language

Lecture 183 Demonstration in CC++ – Bitwise NOT, AND, OR, XOR

Lecture 184 Introduction to Bit Masks

Lecture 185 Finding the rightmost digit using a masking bitwise AND

Lecture 186 Finding the leftmost digit using a masking bitwise AND

Lecture 187 Finding specific combinations of bits in a value – using bit masking

Lecture 188 Introducing the Masking Process to Set Specific bits using bitwise OR operator

Lecture 189 Practicing Setting specific bits

Lecture 190 Masking Process to Turn-Off Specific Bits using the AND bitwise operator

Lecture 191 14. Introducing the XOR operator for Toggle Functionality

Lecture 192 Shift Left & Shift Right Operators

Lecture 193 Displaying a number in binary (using Bitwise Shift Operators) [Implementation]

Lecture 194 Implementing Bitwise Right Rotation

Lecture 195 Implementing Bitwise Left Rotation

Lecture 196 Interview Level Question: Exercise – Implement Swap using Bitwise Operations

Lecture 197 Solution – Implement Swap using Bitwise Operations – without THIRD VARIABLE

Section 22: OPTIONAL: Basic Algorithms

Lecture 198 Merge Functionality – General Introduction

Lecture 199 Merge Functionality in C

Lecture 200 Merge In Place – General Introduction – Basis for Merge Sort

Lecture 201 Merge In Place – Practical Implementation – Part A

Section 23: Congratulations! You’ve made it! What’s next?

Lecture 202 Bonus Lecture

Basic knowledge (and Beyond) C Developers,Students at the Computers and Engineering Faculties,C programmers who need to learn and understand Pointers In Depth,This course is not aimed for “total beginners”. It’s better to have some basic knowledge in C Programming before enrolling in this course. I would suggest purchasing my “C Programming for Beginners” course first, fully complete it and then come back to get ultimate experience with Pointers.

Course Information:

Udemy | English | 31h 12m | 9.78 GB
Created by: Vlad Budnitski

You Can See More Courses in the Developer >> Greetings from CourseDown.com

New Courses

Scroll to Top