MP3 Jukebox Assignments

COS2614 - Programming: Contemporary Concepts · Programming Assignments

MP3 Jukebox Assignments

The MP3 Jukebox Assignments involve creating a program that manages MP3 playlists and databases. This topic focuses on understanding how to work with dynamic arrays and pointers in C++. You will learn how to manage memory effectively, which is crucial for developing robust applications.

Key idea: After studying this topic, you should be able to:

Understand the use of dynamic arrays in C++.
Implement pointer arithmetic with arrays.
Manage dynamic memory using new and delete.
Prevent memory leaks in your programs.

Dynamic Arrays in C++

A dynamic array allows you to create an array whose size can be determined at runtime. This is useful when you do not know the number of elements in advance. You can allocate a dynamic array using the following syntax:

uint size;
T* pt;
pt = new T[size];

Here, T is the type of elements in the array, and size is the number of elements you want to allocate. For example, to create an array of integers with a size of 10, you would write:

int size = 10;
int* pt;
pt = new int[size];

Default Initialization

When you allocate a dynamic array, each element is given default initialization. For basic data types like int, this means they will contain garbage values unless explicitly initialized. You should always initialize your array elements to avoid undefined behaviour.

Pointer Arithmetic

Pointer arithmetic allows you to navigate through the elements of an array using pointers. For example, if you have a pointer pt that points to the first element of an array, you can access the second element using pt + 1:

int* pt = new int[5];
pt[0] = 1;
pt[1] = 2;
pt[1] = *(pt + 1); // Accessing the second element

However, you must ensure that you do not go beyond the bounds of the array. Doing so leads to undefined behaviour.

Watch out: Common mistakes include:

Accessing elements outside the bounds of the array, which can cause crashes or incorrect results.
Forgetting to deallocate memory, leading to memory leaks.

Memory Management

It is essential to manage memory properly in C++. When you allocate a dynamic array, you must also deallocate it when it is no longer needed. Use the following syntax to delete a dynamic array:

delete[] pt;

For example:

delete[] pt; // Deallocate the dynamic array

Handling Memory Leaks

A memory leak occurs when a program allocates memory but fails to release it. To prevent memory leaks:

Always match every new with a corresponding delete.
Use tools like Valgrind to detect memory leaks in your applications.

Tip: Use smart pointers (like std::unique_ptr or std::shared_ptr) in modern C++ to manage memory automatically.

Example Implementation

Here is an example of how to create and use a dynamic array in C++:

#include <iostream>
using namespace std;

int main() {
    int size = 5;
    int* pt = new int[size];

    for (int i = 0; i < size; i++) {
        pt[i] = i * 10; // Initialize elements
    }

    for (int i = 0; i < size; i++) {
        cout << pt[i] << " "; // Print elements
    }

    delete[] pt; // Deallocate memory
    return 0;
}

This program creates a dynamic array of integers, initializes it, prints the values, and then deallocates the memory.

Summary

Dynamic arrays are created using new.
Pointer arithmetic allows navigation through array elements.
Always deallocate memory with delete[] to prevent memory leaks.
Use tools to check for memory management issues.

Check your understanding

What is the syntax to allocate a dynamic array in C++?
How do you access the third element of a dynamic array using pointer arithmetic?
What happens if you forget to deallocate memory for a dynamic array?
How can you prevent memory leaks in your programs?