# Dynamic Memory Allocation Program

### Introduction

Dynamic memory allocation is a key feature in C++ that allows programmers to allocate memory at runtime. This capability is essential for managing memory efficiently, particularly when the size of the data structure is not known at compile time. This program demonstrates how to dynamically allocate memory for an integer variable, assign a value to it, print both the value and the memory address, and then deallocate the memory to prevent memory leaks. The `dynamicMemoryAllocation` function provides a clear example of these concepts in action.

### Program Overview

The program consists of the following components:

1. **Function:** `dynamicMemoryAllocation` - This function handles the dynamic allocation, assignment, output, and deallocation of memory for an integer variable.
    
2. **Function:** `main` - The entry point of the program, which demonstrates how to use the `dynamicMemoryAllocation` function with an example integer variable.
    

---

### Complete Code

```cpp
#include <iostream>
using namespace std;


void dynamicMemoryAllocation(int value) {
   
    int* ptr = new int;
    
    *ptr = value;
    
    cout << "Value: " << *ptr << endl;
    cout << "Memory address: " << ptr << endl;
    
    delete ptr;
}

int main() {

    int intValue = 10;
    
    dynamicMemoryAllocation(intValue);
    
    return 0;
}
```

---

### Function: `dynamicMemoryAllocation`

```cpp
void dynamicMemoryAllocation(int value);
```

#### Purpose

The `dynamicMemoryAllocation` function allocates memory for an integer, assigns a specified value to it, and prints the value and the memory address before deallocating the memory.

#### Parameters

* `int value`: The integer value to be stored in the dynamically allocated memory. This parameter is passed by value to the function.
    

#### Functionality

1. **Memory Allocation**: Uses the `new` operator to allocate memory for an integer variable.
    
2. **Value Assignment**: The function assigns the provided `value` to the newly allocated memory.
    
3. **Output**: It prints the stored value and the memory address where the variable is allocated.
    
4. **Memory Deallocation**: The function calls `delete` to free the allocated memory, ensuring that there are no memory leaks.
    

#### Example Usage

```cpp
int intValue = 10;
dynamicMemoryAllocation(intValue);
```

In this example, the function is called with the value `10`, which it will allocate dynamically and print.

---

### Function: `main`

```cpp
int main();
```

#### Purpose

The `main` function serves as the starting point of the program, demonstrating the functionality of `dynamicMemoryAllocation`.

#### Functionality

1. **Variable Declaration**: Declares an integer variable `intValue` and initializes it with the value `10`.
    
2. **Function Invocation**: Calls the `dynamicMemoryAllocation` function with `intValue` to show how dynamic memory allocation works in practice.
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729845078453/821a2ee7-22a3-4fa5-81be-32c647807f17.png align="center")

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729845049123/c2c45668-a0b4-4752-af49-94f3f6ef68c3.png align="center")

#### Output

When executed, the program displays the following output (exact memory addresses will vary):

```bash
Value: 10
Memory address: 0x556030a0
```

This output shows the assigned value and the memory address allocated for that value.

---

### Program Requirements

* **C++ Compiler**: This program can be compiled with any standard C++ compiler that supports C++98 or later.
    
* **Libraries**: The program requires the `<iostream>` library for input/output operations.
    

---

### Conclusion

This program provides a fundamental understanding of dynamic memory allocation in C++. The `dynamicMemoryAllocation` function clearly illustrates the process of allocating memory at runtime, assigning values, and properly managing memory by deallocating it when no longer needed. This understanding is crucial for any C++ programmer, particularly when working with data structures whose sizes may change dynamically during program execution. The principles demonstrated can be easily adapted to other data types by creating similar functions for different types, thereby reinforcing the importance of memory management in C++ programming.