Free Programming learning guide
C++ for Beginners: A Comprehensive Step-by-Step Guide
C++ for Beginners: A Comprehensive Step-by-Step Guide — a free beginner-level guide covering how to learn c++ for beginners. Learn with clear...
What you will learn
- Introduction and Environment Setup
- Variables, Data Types, and Basic I/O
- Control Flow: Conditionals
- Control Flow: Loops
- Functions and Scope
- Arrays and Strings
- Pointers and Memory Basics
- Dynamic Memory Management
- Structures and Enumerations
- Introduction to Object-Oriented Programming
- Inheritance and Polymorphism
- The Standard Template Library (STL) Basics
1. Introduction and Environment Setup
From Human Thought to Machine Action Imagine you are trying to give directions to someone who speaks a completely different language. You cannot simply say, "Turn left at the big oak tree," because they don't know what "left," "big," or "oak tree" means. To communicate, you need a translator—someone who can take your high-level instructions and convert them into a language the other person understands perfectly. Programming is exactly this process. Your computer is an incredibly fast machine, but it is also remarkably simple. At its core, a computer does not understand English, Spanish, or even the logic of a "loop" or a "variable." It only understands binary: a series of 1s and 0s representing electrical switches being on or off. C++ is the language we use to bridge this gap. It is a "high-level" language, meaning it is written in a way that is readable to humans, but it is powerful enough to be translated into the "low-level" machine code that the hardware requires to function. The Translation Process: Source Code vs. Machine Code Before we install any tools, it is vital to understand what happens between the moment you type a line of code and the moment the computer executes it. Source Code When you write a program, you are creating Source Code. This is a plain text file (usually ending in .cpp) that contains instructions written in the C++ syntax. If you were to open a source code file in a basic text editor like Notepad or TextEdit, it would look like English-adjacent text. However, the computer cannot "run" this file directly. Machine Code Machine Code (or binary) is the final product. It consists of the raw instructions that the CPU (Central Processing Unit) can execute. This is a series of bits (0s and 1s) that tell the processor exactly which electrical circuits to activate. The Compiler: The Translator To get from source code to machine code, we use a special program called a Compiler. The compiler performs several critical tasks: 1. Syntax Checking: It reads your source code to ensure you haven't made any "grammar" mistakes (called syntax errors). If you forget a semicolon or misspell a keyword, the compiler will stop and tell you exactly where the error is. 2. Optimization: It looks for ways to make your code run faster or use less memory. 3. Translation: It converts the human-readable C++ instructions into the specific machine code required for your computer's operating system (Windows, macOS, or Linux) and hardware architecture. The Workflow Summary: Source Code (.cpp) $\rightarrow$ Compiler $\rightarrow$ Executable File (.exe or .out) $\rightarrow$ CPU Execution Setting Up Your Development Environment To start coding, you need two primary tools. While you could technically …
2. Variables, Data Types, and Basic I/O
The Digital Notebook: What are Variables? Imagine you are building a simple application to track a player's score in a video game. As the player defeats enemies or collects coins, that score changes. The computer needs a way to remember that number, store it while the game is running, and update it instantly. The computer cannot simply "remember" a value in the abstract; it needs a specific location in its physical memory (RAM) to hold that piece of information. A variable is essentially a named container for a value. Instead of forcing you to remember a complex memory address (like 0x7ffdf3a2), C++ allows you to give that memory location a human-readable name, such as playerScore. When you create a variable, you are telling the compiler to reserve a small slice of memory to hold a specific kind of data. Static Typing: The Rules of the Container C++ is a statically typed language. This means that every variable must have a declared data type before it can be used, and that type cannot change during the program's execution. Think of data types like physical containers. If you have a cardboard box designed specifically to hold a large pizza, you cannot suddenly decide it is now a bottle for soda. Similarly, if you tell C++ that a variable is an integer (a whole number), you cannot later try to store a sentence or a decimal number in that same variable. Static typing provides two major benefits: 1. Performance: The compiler knows exactly how much memory to allocate for each variable, making the resulting machine code faster. 2. Safety: The compiler can catch "type errors" during the syntax checking phase. If you try to perform a mathematical operation on a piece of text, the compiler will alert you before the program even runs. Fundamental Data Types While C++ has many complex types, almost everything is built from a few fundamental building blocks. int (Integers) The int type is used for whole numbers. This includes positive numbers, negative numbers, and zero. It cannot store fractions or decimals. Example use: Counting items, tracking a year, or representing a player's level. Typical size: 4 bytes. double (Floating-Point Numbers) The double (short for "double precision floating point") is used for numbers that require a fractional part. Example use: Measuring temperature (e.g., 98.6), calculating a GPA, or representing the price of an item (e.g., 19.99). Typical size: 8 bytes. char (Characters) The char type stores a single character. This can be a letter, a digit, or a symbol. In C++, char values must be enclosed in single quotes (' '). Example use: Storing a grade ('A', 'B', 'C') or a gender initial ('M', 'F'). Typical size: 1 byte. …
3. Control Flow: Conditionals
Making Decisions: The Logic of Programming Imagine you are designing a simple program for an automated coffee machine. If the user presses the "Espresso" button, the machine should brew a concentrated shot. If they press "Latte," it should steam milk first. If the water tank is empty, it shouldn't brew anything at all—instead, it should display a warning: "Please refill water." Up until now, your C++ programs have been linear. They start at the top of main(), execute every line in order, and then end. But real-world software isn't a straight line; it is a series of forks in the road. This ability to choose different paths based on specific conditions is called Control Flow. To implement this, we use Conditionals. A conditional is a block of code that only runs if a specific requirement is met. --- Boolean Expressions: The Foundation of Choice Before a program can make a decision, it needs a way to ask a "Yes or No" question. In C++, these questions are called Boolean Expressions. A Boolean is a data type that can only hold one of two values: true or false. When you write an expression that compares two values, C++ evaluates that expression and returns a boolean result. Relational Operators To create these expressions, we use Relational Operators. These operators compare two values and determine the relationship between them. | Operator | Meaning | Example | Result if $x=10, y=5$ | | :--- | :--- | :--- | :--- | | == | Equal to | x == y | false | | != | Not equal to | x != y | true | | | Greater than | x y | true | | < | Less than | x < y | false | | = | Greater than or equal to | x = 10 | true | | <= | Less than or equal to | y <= 2 | false | Crucial Warning: = vs == One of the most common mistakes for beginners is using a single equals sign (=) when they mean to compare two values. - = is the Assignment Operator. It sets a variable to a value (e.g., x = 10;). - == is the Equality Operator. It asks "Are these two things the same?" (e.g., x == 10). Using = inside a conditional can lead to "logical errors"—your code will compile and run, but it will behave unpredictably because you are accidentally changing a variable's value instead of checking it. Logical Operators Sometimes a single comparison isn't enough. You might need to check if two different conditions are both true, or if at least one of several conditions is true. For this, …
4. Control Flow: Loops
The Power of Repetition Imagine you are writing a program for a digital clock. To make the clock work, you need to update the time every single second. If you wrote your code linearly, you would have to write the "update time" command 86,400 times to cover a single day. Now imagine you are building a game where a character walks forward as long as the player holds down the 'W' key. You don't know if the player will hold that key for half a second or ten minutes. You cannot write a fixed number of lines of code to handle this because the duration is unpredictable. This is where loops come in. A loop is a control flow structure that allows you to execute a block of code repeatedly. Instead of writing the same line a thousand times, you write it once and tell C++ how many times (or under what conditions) it should repeat. Definite Iteration: The for Loop When you know exactly how many times a piece of code needs to run before it starts, you are dealing with definite iteration. The most common tool for this in C++ is the for loop. Anatomy of a for Loop The for loop is unique because it bundles three essential pieces of information into one line: where to start, when to stop, and how to change the value each time. 1. Initialization: This happens only once, at the very beginning. It is usually where you create a counter variable (typically an integer) to keep track of how many times the loop has run. 2. Condition: This is a boolean expression (like the ones used in the Conditionals chapter). Before every single iteration, C++ checks this condition. If it is true, the loop runs. If it is false, the loop stops immediately. 3. Update: This happens at the end of every loop cycle. It is used to increment or decrement the counter variable so that the loop eventually reaches the stop condition. Example: Counting Down to Launch Here is a practical example of a countdown timer: Breaking down the code: int i = 10: We initialize our counter i at 10. i 0: The loop will continue as long as i is greater than 0. i--: This is the decrement operator. It subtracts 1 from i after every loop. If we had used i++ (the increment operator) instead of i--, the value of i would go 10, 11, 12... and since those are all greater than 0, the loop would never stop. Indefinite Iteration: while and do-while Sometimes, you don't know how many times a loop needs to run. You only know that it should keep running until a certain …
5. Functions and Scope
The Problem with "Giant" Code Imagine you are building a digital calculator. At first, it’s simple: you just need to add two numbers. You write a few lines of code in your main() function, and it works. Then, you decide to add subtraction, multiplication, division, square roots, and trigonometry. If you keep putting every single calculation inside main(), your code will quickly become a "monolith"—a giant, towering wall of text. If you find a bug in the multiplication logic, you have to hunt through hundreds of lines of code to find the specific spot where that math happens. Even worse, if you want to use that same multiplication logic in a different part of your program, you have to copy and paste the code, creating more room for errors. This is where functions come in. A function is a reusable block of code that performs a specific task. Instead of writing the same logic ten times, you write it once inside a function and "call" it whenever you need it. Understanding Functions A function is essentially a "sub-program." You give it a name, tell it what data it needs to work with, and tell it what result it should give back to you. Anatomy of a Function To create a function, you must define it. A function definition consists of a header and a body. Let's break down the jargon here: 1. Return Type (int): This tells the compiler what kind of data the function will send back when it finishes. In this case, it returns an integer. If a function performs an action but doesn't return a value, we use the keyword void. 2. Function Name (addNumbers): This is the unique identifier you use to call the function. 3. Parameters (int a, int b): These are the inputs. Parameters act as placeholders for the values the function will receive. They are defined by their data type and a name. 4. The Body ({ ... }): Everything inside the curly braces is the code that executes when the function is called. 5. The Return Statement (return sum;): This exits the function and sends the specified value back to wherever the function was called. Calling a Function Defining a function is like writing a recipe; it doesn't actually "cook" anything until you tell it to. To execute the code inside a function, you must call (or invoke) it. When addNumbers(5, 10) is called, the value 5 is copied into parameter a, and 10 is copied into parameter b. The program jumps from main() to addNumbers(), runs the logic, and then "jumps" back to main() with the value 15. Prototypes vs. Definitions C++ reads your source code from top to bottom. If …
6. Arrays and Strings
The Problem of Scale Imagine you are writing a program to track the grades of five students in a classroom. Using what you learned in Variables, Data Types, and Basic I/O, you would likely do this: This works fine for five students. But what happens when you have 50 students? Or 500? Creating grade500 manually is tedious, prone to typos, and makes your code impossible to maintain. If you wanted to calculate the average grade, you would have to write a mathematical expression adding 500 different variable names together. To solve this, C++ provides Arrays. An array allows you to store multiple values of the same data type under a single name, treating them as a collection rather than individual, disconnected variables. --- Understanding Fixed-Size Arrays An array is a collection of elements of the same type stored in contiguous (adjacent) memory locations. When you declare an array, you tell the compiler two things: the type of data it will hold and how many elements it can store. Declaring and Initializing Arrays To declare an array, you use the data type, followed by the name of the array, and then the size in square brackets []. At this point, the array exists, but it contains "garbage values"—whatever random data happened to be in that memory location previously. To give the array specific values, you can use initialization. 1. Initialization at Declaration You can fill the array immediately using curly braces {}: 2. Partial Initialization If you provide fewer values than the size of the array, C++ fills the remaining slots with zeros: 3. Implicit Sizing If you provide an initialization list but leave the brackets empty, the compiler counts the elements for you: The Concept of Indexing To access a specific item in an array, you use an index. An index is a number that represents the position of the element. Crucially, C++ uses zero-based indexing. This means the first element is at index 0, not index 1. First element: scores[0] Second element: scores[1] Last element (for size 5): scores[4] Warning: Out-of-Bounds Errors C++ does not check if the index you are requesting actually exists. If you have an array of size 5 and try to access scores[10], the program will look at a memory location it doesn't own. This results in Undefined Behavior, which can lead to your program crashing or producing nonsensical data. Always ensure your index is between 0 and size - 1. --- Iterating Through Arrays Manually accessing scores[0], scores[1], etc., is just as tedious as creating individual variables. To handle arrays efficiently, we use the loops covered in Control Flow: Loops. Because array indices are numeric and sequential, the for loop is the ideal tool …
7. Pointers and Memory Basics
The Map of Your Computer's Memory Imagine you are working in a massive warehouse filled with millions of identical cardboard boxes. Each box can hold a piece of data—perhaps an integer or a character. If you want to find a specific piece of information, you can't just wander around aimlessly; you need the exact aisle, shelf, and box number. In your computer, the RAM (Random Access Memory) is that warehouse. Every single byte of memory has a unique numerical identifier called a memory address. Up until now, you have been using variables. When you write int score = 100;, the C++ compiler handles the "warehouse" logistics for you. It finds an empty spot in memory, labels it score, and puts the value 100 inside. You don't have to care where that box is located; you just use the name. Pointers are the tool C++ gives you to stop relying on labels and start dealing with the addresses directly. A pointer is simply a variable that stores the memory address of another variable. The Address-of Operator (&) Before we can use pointers, we need a way to find out where a variable is actually living in the RAM. C++ provides the address-of operator, represented by the ampersand symbol (&). When you place & before a variable name, you aren't getting the value stored in the variable; you are asking the computer, "Where is this variable located?" Example: Peeking at the Address If you run this code, the second line of output won't be 25. Instead, it will look something like 0x7ffeb4a2c104. This strange string of numbers and letters is written in hexadecimal (base-16), which is the standard way to represent memory addresses. The 0x at the beginning is just a signal to the compiler that "the following characters are a hexadecimal number." Declaring and Using Pointers Now that we know how to find an address, we need a place to store it. A regular int cannot hold a memory address because addresses have a different format and size than standard integers. For this, we use a pointer. Pointer Syntax To declare a pointer, you use the asterisk () symbol. The syntax follows this pattern: type pointerName; The type tells C++: "This variable will not hold a value like 10 or 50; it will hold the address of a variable of this specific type." In the example above, ptr does not contain the number 25. It contains 0x7ffeb4a2c104. Dereferencing: Following the Map Storing an address is only useful if you can use that address to get back to the original value. This process is called dereferencing. To dereference a pointer, you use the asterisk () again, but this time you use it …
8. Dynamic Memory Management
The Problem with Fixed Sizes Imagine you are writing a program to manage a guest list for a wedding. When you start the program, you ask the user: "How many guests are attending?" If the user says 50, you need space for 50 names. If they say 500, you need space for 500. In Chapter 6, we learned about Arrays. However, standard arrays require a size that is known at the moment you write the code (compile-time). If you declare string guests[100];, you have two problems: 1. If 101 people show up, your program crashes or behaves unpredictably. 2. If only 2 people show up, you are wasting memory for 98 empty slots. To solve this, we need a way to ask the computer for exactly the amount of memory we need while the program is actually running. This is called Dynamic Memory Management. The Stack vs. The Heap To understand how dynamic memory works, you have to understand that your computer organizes RAM (Random Access Memory) into different zones. The two most important for a C++ programmer are the Stack and the Heap. The Stack (Automatic Memory) Up until now, every variable you have created has lived on the stack. When you declare int x = 10; inside a function, C++ puts that variable on the stack. The stack is like a physical stack of plates. When a function is called, C++ "pushes" the necessary variables onto the top of the stack. When the function finishes (reaches the closing curly brace }), those variables are "popped" off and destroyed automatically. Characteristics of the Stack: Automatic: You don't have to tell the computer to allocate or delete the memory. Fast: Accessing stack memory is incredibly quick. Limited: The stack is relatively small. If you try to put too much data on it (like a massive array), you will get a Stack Overflow error. Fixed Size: The size of stack variables must be known before the program runs. The Heap (Free Store) The heap is a large pool of memory available to your program. Unlike the stack, the heap is not managed automatically. If you want a piece of memory on the heap, you must explicitly ask for it, and—more importantly—you must explicitly give it back when you are done. Characteristics of the Heap: Manual: You control exactly when memory is allocated and deleted. Flexible: You can decide how much memory you need while the program is running. Large: The heap is much larger than the stack, making it ideal for big data sets. Slower: Accessing the heap is slightly slower than accessing the stack. Because the heap doesn't "clean up" after itself, we must use Pointers (from Chapter 7) to …
9. Structures and Enumerations
The Problem with Disconnected Data Imagine you are writing a program to manage a library. You need to keep track of a book's title, its author, the year it was published, and whether it is currently checked out. Using the Variables and Data Types you learned in Chapter 2, you might create variables like this: This works fine for one single book. But what happens when the library has 10,000 books? You cannot create 40,000 separate variables. You might think of using Arrays (from Chapter 6), but arrays require every element to be the same data type. You can have an array of strings for titles and an array of integers for years, but these lists are "disconnected." If you sort the title array alphabetically, the years array remains in its original order, and suddenly your data is mismatched. To solve this, we need a way to bind different data types together into a single unit. This is where Structures and Enumerations come in. Understanding Structures (structs) A Structure (or struct for short) is a user-defined data type. While a int always holds an integer and a bool always holds a true/false value, a struct allows you to define a new type that contains a collection of other variables. Think of a struct as a blueprint. The blueprint isn't the object itself; it just describes what the object should look like. Defining a Struct To create a structure, you use the struct keyword followed by the name of your new type. In this example, Book is now a valid data type in your program, just like int or double. The variables inside the struct—title, author, year, and isCheckedOut—are called members. Creating and Initializing Structs Once you have defined the Book blueprint, you can create an actual instance (an object) of that struct. Accessing Members with the Dot Operator To get to the data inside a struct, C++ uses the dot operator (.). This operator tells the compiler: "Go inside this specific structure and find this specific member." Memory Layout of a Structure Understanding how a struct exists in your computer's RAM is vital for moving toward advanced memory management. When you define a struct, the compiler allocates a contiguous block of memory large enough to hold all its members. If a Book contains two strings, an integer, and a boolean, the computer places them one after another in memory. Memory Alignment and Padding You might assume that the size of a struct is exactly the sum of its parts. For example, if an int is 4 bytes and a bool is 1 byte, you might expect a struct containing both to be 5 bytes. However, this is often not the …
10. Introduction to Object-Oriented Programming
The Blueprint and the Building Imagine you are designing a video game. You need to create 100 different enemies. Each enemy has a name, a health pool, a movement speed, and the ability to take damage. If you used the tools from previous chapters, you might create a Structure (from Chapter 9) to hold the data. But a structure is just a bag of variables; it doesn't "know" how to do anything. To make an enemy take damage, you would have to write a separate function, pass the structure into it, modify the health variable, and ensure you don't accidentally set the health to a negative number. As your game grows to include players, NPCs, and items, managing these separate functions and data structures becomes a chaotic mess. This is where Object-Oriented Programming (OOP) comes in. OOP allows us to bundle the data (attributes) and the behaviors (functions) into a single unit. Instead of having a "Health" variable and a "TakeDamage" function floating separately in your code, you create a single entity that owns both. Understanding Classes and Objects At the heart of OOP are two fundamental concepts: the Class and the Object. The Class: The Blueprint A Class is a user-defined data type. Think of it as a blueprint or a template. A blueprint for a house isn't a house itself—you can't live in it—but it describes exactly what a house should have (windows, doors, rooms) and how it should function (the doorbell rings, the lights turn on). In C++, a class defines what data the object will hold and what operations it can perform. The Object: The Instance An Object is a specific instance of a class. If the class is the blueprint for a house, the object is the actual house built on a specific street corner. You can use one blueprint (Class) to build many houses (Objects), and each house can have different colors or different people living inside, but they all follow the same basic structure. Instantiation is the technical term for the process of creating an object from a class. Defining Your First Class To create a class in C++, we use the class keyword followed by the name of the class. By convention, class names usually start with an uppercase letter. Inside the class, we define Member Variables (also called attributes) and Member Functions (also called methods). Access Modifiers: Public vs. Private In a real-world object, some things are visible to everyone, while others are hidden. You can see the exterior paint of a car (Public), but you cannot see the internal combustion process happening inside the engine (Private). C++ uses Access Modifiers to control this: 1. public: Members under this label are …
11. Inheritance and Polymorphism
The "Is-A" Relationship: Why Redundancy is the Enemy Imagine you are developing a software system for a zoo. You need to create classes for Lion, Tiger, and Bear. If you follow what you learned in the Introduction to Object-Oriented Programming chapter, you might create three separate classes. You'll quickly realize that all three animals have a name, an age, and a function called eat(). You end up writing the same code three times. If you decide later that every animal also needs a weight variable, you have to manually update all three classes. This is where Inheritance comes in. Instead of writing redundant code, you create one general class (the Animal) and let the specific animals "inherit" those traits. In programming, we call this the "Is-A" relationship: A Lion is-an Animal. A Tiger is-an Animal. Understanding Single Inheritance Inheritance is a mechanism that allows a new class to acquire the properties (variables) and behaviors (functions) of an existing class. Base Classes and Derived Classes In any inheritance relationship, there are two players: 1. Base Class (Parent): The existing class that provides the common logic. (e.g., Animal) 2. Derived Class (Child): The new class that inherits from the base class. (e.g., Lion) Implementing Inheritance in C++ To inherit from a class, you use a colon (:) during the class declaration. The Access Specifier: public Inheritance In the example above, we used public Animal. The keyword public here is the inheritance access specifier. It tells C++ that all public members of the Animal class should remain public in the Lion class. For beginners, public inheritance is the standard way to implement the "Is-A" relationship. Overriding Base Class Functions Sometimes, a derived class inherits a function from the base class, but the base class version isn't quite right. For example, while all animals eat(), a Lion eats meat and a Cow eats grass. Function Overriding occurs when a derived class provides a specific implementation for a function that is already defined in its base class. Example: Specializing Behavior If you create a Dog object and call makeNoise(), C++ will use the version inside the Dog class because it is more specific. This allows you to define general behavior in the parent and specialized behavior in the child. Polymorphism and Virtual Functions The word Polymorphism comes from Greek, meaning "many forms." In C++, it allows us to treat different derived objects as if they were objects of the same base class, while still maintaining their unique behaviors. The Problem: Static Binding By default, C++ uses Static Binding (or Early Binding). This means the compiler decides which function to call at compile-time based on the type of the pointer/reference, not the type of the actual …
12. The Standard Template Library (STL) Basics
Why Reinvent the Wheel? Imagine you are building a digital address book. You need a way to store names and phone numbers. You might start with an array, but then you realize you don't know how many contacts the user will add. If you use the dynamic memory management techniques from Chapter 8, you'll have to manually track the size, allocate new memory, copy the old data over, and delete the old memory every time the list grows. Now imagine you need to find a specific person's phone number instantly among 10,000 entries. Writing a search algorithm from scratch is time-consuming and prone to bugs. This is where the Standard Template Library (STL) comes in. The STL is a powerful collection of pre-written, highly optimized C++ classes and functions. Instead of building a dynamic array or a sorting algorithm from scratch, you use a "template" provided by the language. These tools are tested by millions of developers and are almost always faster and safer than something a beginner (or even an expert) could write quickly. Understanding Templates and the STL Before diving into the tools, we need to understand the word Template. In C++, a template is a blueprint. Normally, if you wanted a function to sort integers, you'd write one function. If you then wanted to sort doubles, you'd have to write another. Templates allow you to write a function or a class once, using a "placeholder" for the data type. When you actually use the tool, you tell C++ which data type to plug into that placeholder. The STL consists of three main components: 1. Containers: Objects that store data (like std::vector and std::map). 2. Algorithms: Procedures to manipulate data (like std::sort). 3. Iterators: The "glue" that allows algorithms to move through containers. Dynamic Arrays with std::vector In Chapter 6, you learned about arrays. The biggest limitation of a standard array is that its size is fixed. Once you declare int myNumbers[10], it can never hold 11 items. A std::vector is a dynamic array. It manages its own memory automatically. When you add an item to a vector that is already full, the vector silently handles the memory reallocation—growing its capacity so you don't have to manually call new or delete. Basic Vector Operations To use vectors, you must include the header: include <vector. Common Vector Methods pushback(value): Adds an element to the end of the vector. popback(): Removes the last element. size(): Returns the number of elements currently in the vector. clear(): Removes all elements from the vector. at(index): Similar to [index], but safer because it checks if the index is out of bounds. Key-Value Storage with std::map Sometimes, storing data in a simple list isn't efficient. …
Continue learning
- Learn Basic Coding for BeginnersLearn Basic Coding for Beginners — a free beginner-level guide covering learn basic coding for beginners. Learn with clear explanations, real examples,...
- Intermediate Python Automation Scripts for BeginnersIntermediate Python Automation Scripts for Beginners — a free intermediate-level guide covering intermediate python automation scripts for beginners....
- Intermediate Python Projects for Portfolio BuildingIntermediate Python Projects for Portfolio Building — a free intermediate-level guide covering intermediate python projects for portfolio building....
- C# for Beginners: A Complete Step-by-Step GuideC# for Beginners: A Complete Step-by-Step Guide — a free beginner-level guide covering how to learn c# for beginners. Learn with clear explanations,...