Course Content

C++ Pointers and References

1. Pointers Fundamentals

Introduction to Pointer Assigning Addresses to Pointers Link Between Pointer and Variable Pointers Use Cases

2. Pointer Arithmetic

Introduction to Pointer Arithmetic Pointer Arithmetic Practice Arrays and Pointers Connection Array Pointer Arithmetic Practice

3. References Fundamentals

Introduction to References Reference Use Cases Rvalue and Lvalue References Reference vs Pointers

4. Dynamic Memory Allocation

Introduction to Memory Dynamic Allocation Dynamic Allocation of the Array Pointer to Pointer Dynamic Allocation Summary and Overview

Dynamic Allocation of the Array

Before we explore why dynamic allocation is necessary, let's quickly recap the characteristics of static and dynamic arrays:

Fixed Size: Once declared, the size of a static array is fixed and cannot be changed during runtime;
Memory Allocation at Compile Time: The memory required for a static array is allocated at compile time.

Resizable: Dynamic arrays allow for resizing during runtime, providing flexibility to adapt to changing program requirements;
Memory Allocation at Runtime: Memory for dynamic arrays is allocated during program execution.

The Limitations of a Static Approach

Consider the program that prompts the user to input performance scores for each day that has passed in current month.

Unfortunately, we can't achieve this using a static array:

main


              12345678910
            
#include <iostream>
#include <ctime>

int main() {
    std::time_t currentTime = std::time(nullptr);
    int day_passed = std::localtime(&currentTime)->tm_mday;
    
    int arr[day_passed];
    std::cout << day_passed << std::endl; 
}

Note

This will generate a compilation error because day_passed is not a constant expression it depends on the runtime value of the current day of the month.

So instead of static array we have to use a dynamic allocated array.

Task

Swipe to show code editor

Create a dynamic array with a size equivalent to the number of days that have passed.
Free allocated memory.

Switch to desktop for real-world practiceContinue from where you are using one of the options below

Everything was clear?

Thanks for your feedback!

Section 4. Chapter 3

Dynamic Allocation of the Array

Before we explore why dynamic allocation is necessary, let's quickly recap the characteristics of static and dynamic arrays:

Fixed Size: Once declared, the size of a static array is fixed and cannot be changed during runtime;
Memory Allocation at Compile Time: The memory required for a static array is allocated at compile time.

Resizable: Dynamic arrays allow for resizing during runtime, providing flexibility to adapt to changing program requirements;
Memory Allocation at Runtime: Memory for dynamic arrays is allocated during program execution.

The Limitations of a Static Approach

Consider the program that prompts the user to input performance scores for each day that has passed in current month.

Unfortunately, we can't achieve this using a static array:

main


              12345678910
            
#include <iostream>
#include <ctime>

int main() {
    std::time_t currentTime = std::time(nullptr);
    int day_passed = std::localtime(&currentTime)->tm_mday;
    
    int arr[day_passed];
    std::cout << day_passed << std::endl; 
}

Note

This will generate a compilation error because day_passed is not a constant expression it depends on the runtime value of the current day of the month.

So instead of static array we have to use a dynamic allocated array.

Task

Swipe to show code editor

Create a dynamic array with a size equivalent to the number of days that have passed.
Free allocated memory.

Switch to desktop for real-world practiceContinue from where you are using one of the options below

Everything was clear?

Thanks for your feedback!

Section 4. Chapter 3

Dynamic Allocation of the Array

Before we explore why dynamic allocation is necessary, let's quickly recap the characteristics of static and dynamic arrays:

Fixed Size: Once declared, the size of a static array is fixed and cannot be changed during runtime;
Memory Allocation at Compile Time: The memory required for a static array is allocated at compile time.

Resizable: Dynamic arrays allow for resizing during runtime, providing flexibility to adapt to changing program requirements;
Memory Allocation at Runtime: Memory for dynamic arrays is allocated during program execution.

The Limitations of a Static Approach

Consider the program that prompts the user to input performance scores for each day that has passed in current month.

Unfortunately, we can't achieve this using a static array:

main


              12345678910
            
#include <iostream>
#include <ctime>

int main() {
    std::time_t currentTime = std::time(nullptr);
    int day_passed = std::localtime(&currentTime)->tm_mday;
    
    int arr[day_passed];
    std::cout << day_passed << std::endl; 
}

Note

This will generate a compilation error because day_passed is not a constant expression it depends on the runtime value of the current day of the month.

So instead of static array we have to use a dynamic allocated array.

Task

Swipe to show code editor

Create a dynamic array with a size equivalent to the number of days that have passed.
Free allocated memory.

Switch to desktop for real-world practiceContinue from where you are using one of the options below

Everything was clear?

Thanks for your feedback!

Before we explore why dynamic allocation is necessary, let's quickly recap the characteristics of static and dynamic arrays:

Fixed Size: Once declared, the size of a static array is fixed and cannot be changed during runtime;
Memory Allocation at Compile Time: The memory required for a static array is allocated at compile time.

Resizable: Dynamic arrays allow for resizing during runtime, providing flexibility to adapt to changing program requirements;
Memory Allocation at Runtime: Memory for dynamic arrays is allocated during program execution.

The Limitations of a Static Approach

Consider the program that prompts the user to input performance scores for each day that has passed in current month.

Unfortunately, we can't achieve this using a static array:

main


              12345678910
            
#include <iostream>
#include <ctime>

int main() {
    std::time_t currentTime = std::time(nullptr);
    int day_passed = std::localtime(&currentTime)->tm_mday;
    
    int arr[day_passed];
    std::cout << day_passed << std::endl; 
}

Note

This will generate a compilation error because day_passed is not a constant expression it depends on the runtime value of the current day of the month.

So instead of static array we have to use a dynamic allocated array.

Task

Swipe to show code editor

Create a dynamic array with a size equivalent to the number of days that have passed.
Free allocated memory.

Switch to desktop for real-world practiceContinue from where you are using one of the options below

Section 4. Chapter 3

Switch to desktop for real-world practiceContinue from where you are using one of the options below