CF

Rust from C/C++

5h 31m 48s
English
Paid

This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust's native compilation, memory management, and advanced features, you'll compare and contrast key concepts like types, control flow, and data structures in this class. Delve into Rust's strengths in memory safety and concurrency, alongside its unified tool, Cargo, streamlining development. Additionally, learn how Rust facilitates interoperability with C and C++ through Foreign Function Interface (FFI).

Additional

https://github.com/thebracket/ArdanRustService

About the Author: Ardan Labs

Ardan Labs thumbnail

Ardan Labs is a US training company founded by William Kennedy, focused almost entirely on Go (Golang) and the systems-engineering disciplines around it. Bill Kennedy is one of the most cited Go educators alive — co-author of Go in Action (Manning), maintainer of the Ardan Labs blog, and the lead instructor on a multi-track Go syllabus that runs from beginner through ultimate-Go advanced engineering.

The CourseFlix listing under this source carries nineteen Ardan Labs courses — covering Go language fundamentals, concurrency, advanced engineering patterns, Kubernetes (Bill teaches Go as the implementation language for cloud infrastructure), and the data-engineering / AI tracks Ardan added in recent years. Material is paid and aimed at engineers serious about Go as a career-defining language rather than as a syntax pickup.

Watch Online 38 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 38 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1. Introduction
All Course Lessons (38)
#Lesson TitleDurationAccess
1
1. Introduction Demo
02:30
2
2.0 - 2.4 Hello World in C, C++, Rust & Rust Syntax
14:25
3
3.0 Touring the Rust Language & 3.1 Primitive Types
04:52
4
3.2 Mutability
04:57
5
3.3 Primitive Type Conversion
05:59
6
3.4 Numeric Overflow
04:25
7
3.5 Control Flow
03:12
8
3.6 Loops
04:05
9
3.7 Strings
06:09
10
3.8 Functions and Scopes
07:06
11
3.9 Structures
07:11
12
3.10 Structure Functions
07:41
13
3.11 Destructors - Drop
04:21
14
3.12 Tuples and Destructuring
02:13
15
3.13 Enums
10:54
16
3.14 Containers
12:19
17
3.15 Iterators
08:56
18
3.16 Move by Default
04:01
19
3.17 Borrowing
03:36
20
3.18 Slices
02:28
21
3.19 Memory Management & 3.19.1. C-style allocation and deallocation
16:30
22
3.19.2 Box - Unique Pointer
03:21
23
3.19.3 Rc and Arc - Shared Pointer
04:38
24
3.19.4 The Borrow Checker
24:12
25
3.19.5 Lifetimes
11:48
26
3.20 Concurrency & 3.20.1 Data Race Protection
22:11
27
3.20.2 Spawning Threads
03:38
28
3.20.3 Dividing Workloads
05:29
29
3.20.4 Scoped Threads
02:50
30
3.20.5 Rayon
06:40
31
3.21 Program Organization
16:53
32
3.22 Traits
26:12
33
3.23 Generics
15:57
34
3.24 Error Handling
12:00
35
4.0 Touring the Rust Ecosystem and 4.1 Tool Equivalencies
04:47
36
4.2 Unit Tests
06:04
37
4.3 Benchmarking
10:57
38
5.0 Calling C from Rust with FFI
16:21
Unlock unlimited learning

Get instant access to all 37 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites should I have before taking this course?
This course is designed for individuals who are already familiar with C and C++. It assumes a working knowledge of these languages, as it focuses on transitioning from C/C++ to Rust. Familiarity with concepts like types, control flow, and memory management in C/C++ will be beneficial.
What projects or examples will I build during the course?
Throughout the course, you will engage with various examples that illustrate Rust's capabilities compared to C and C++. This includes writing 'Hello World' in different languages, exploring memory management techniques, and implementing concurrency with threads. The course also covers interoperability with C using the Foreign Function Interface (FFI).
Who is the target audience for this course?
The course is intended for developers with experience in C and C++ who are looking to transition to Rust. It is particularly suitable for those interested in leveraging Rust's strengths in memory safety and concurrency while maintaining interoperability with existing C/C++ codebases.
How does the depth of this course compare to other programming language courses?
This course offers a detailed comparison between C/C++ and Rust, focusing on critical areas like memory management, concurrency, and data structures. It provides a deep dive into Rust-specific features such as the borrow checker and lifetime management, which are not typically covered in basic programming language courses.
What specific tools or platforms will I learn to use in this course?
The course introduces Cargo, Rust's package manager and build system, which streamlines development. Additionally, you will learn about Rust's unit testing and benchmarking tools, as well as tools for managing concurrency and memory safety, like Rc and Arc pointers.
What topics are not covered in this course?
While the course provides a comprehensive look at transitioning from C/C++ to Rust, it does not cover advanced Rust topics beyond the basics of memory management, concurrency, and interoperability with C/C++. Topics such as web development, GUI applications, or network programming in Rust are not included.
What is the time commitment for completing this course?
The course consists of 38 lessons, but the exact runtime is not specified. Given the depth of topics covered, including memory management, concurrency, and FFI, students should be prepared to invest a significant amount of time in both the lessons and practical exercises to fully grasp the material.