Arrays in programming languages C and C++

Array variables are used when it is necessary to remember in memory more data of the same type, e.g. int. Consider the following task: It is necessary to enter grades from n subjects and calculate the highest grade.
We reserve the memory for the grade data, and then using the cycle we try to enter n grade (eg N = 5):

Example 1: Take inputs of grades from user using for loop

int grade, n=5;
//Taking inputs from user and store them in array
for(int i=0; i < n; i++)
{
cout<<"Enter "+(i+1)+". grade";
cin>>grade;
}

However, because grades only remembers one number, after leaving the for cycle only the last grade will be remembered. The task will not be solved in this way. The highest grade (maximum) cannot be determined further, as not all grades are memorized. Grades could be remembered if we used an variable of an array instead of the usual variable, which can store more data of the same type. Let's introduce a arrays:

int grades[n];
…
The name of the array is: grades. The previous expression reserved memory for n integers, because the value in square brackets is actually the dimension of the array.

Figure 1: Defining an array

The figure shows the memory reserved for at least 5 elements. The numbers below the field represent the index of the array field. The first member of the sequence has the index 0, and the last n-1, ie. in this case it is 4. If we want to enter a grade of 5 in the field with index 2 (third field) we have written:

grade [2] = 5;

Here's what the memory state would look like in that case:

Figure 2: Accessing array elements

Entering grades using the cin input command, through the for loop would now look like:

Example 2: Take inputs of array elements from user using for loop

int n=5;
int grade[n];
//Taking inputs from user and store them in array
for(int i=0; i < n; i++)
{
cout<<"Enter "+(i+1)+". grade";
cin>>grade[i];
}

The array of grades would be filled in order through cycles. In the 1st cycle when i = 0, the value entered at standard input would go to the field with index 0, in the 2nd cycle when i = 1 in the grades [1], which is the second field in the array and so on until the end of array. At the end of the for loop, the state in memory would look like:

Figure 3: Example of an array, with a state in memory

Determining the maximum value of an array (maximum)

Now that all the grades are stored in memory, we can extract them as needed and, say, determine the highest grade in the array.
The maximum grade is determined as follows:

int max = grades [0];

First, an integer variable is defined that will represent the maximum grade and it is assumed that one is the first grade in the array, ie. its initial value , grades [0]. It is further moving trough the loop and the next grade in the order of grades [i] is accessed. It is checked in each cycle whether the new score is higher than the current maximum and if so, that value becomes the maximum. It looks like this:

Example 3:Determining the largest value in an array

#include < stdio.h >
#include < stdlib.h >

int main()
{

const int n = 5;
int grade[n];
//Taking inputs from user and store them in array
for(int i=0; i < n; i++)
{

cout << "Enter "+(i+1)+". grade";
cin >> grade[i];

}
//Determining the largest value in an array
int max=grades[0];
for(int i=1; i< n; i++)
{

if(grades[i]>max)

max=grades[i];

}
cout << "max grade is " << max;

}

Determining the maximum sum of consecutive subarray

Within a one-dimensional array of numbers it is necessary to find the subset of consecutive numbers that has the bigest sum (sum). Eg for the array:

3.5, -10, -34.16 2

the bigest sum has a subarray 16, 2 which value is 18.
For a complete explanation and animation explaining the algorithm, see webpage:

Maximum Sum of Contiguous Subarrays

Figure 4: Determining the maximum sum of consecutive subarray

Declaring and defining arrays

Definition of an array of 10 integers (then the memory is reserved for that array):
int A[10];

This will provide memory space for 10 integers. If we tried to access the 11th element of the array, the program would abort execution at that point due to an error.
The disadvantage of arrays is that, when we do not know in advance how many elements the array will contain, we have to reserve more space than we expect, just in case. Some of these places will probably remain unused, but the program will not be interrupted due to that.
The possibility to reserve the number of seats exactly as many as will be needed is solved by using collections, but that is the subject of an exhibition at a higher course.

Defining an array of real numbers

An array of real numbers is defined similarly to an array of integer, with double or float instead of int.

float A[10]; or

double A[10];

Giving values to elements of array

The elements of an array are accessed using indexes starting from 0. E.g. if the number of real numbers is five , defining and assigning values to the elements would be:
double [ ] A= new double [5];
A[0] = 1.1;
A[1] = 2.0;
A[2] = 2.5;
A[3] = - 1.6;
A[4] = 3.3;
The array would then look like:

Figure 5: Giving values to elements of an array wich contain real numbers

Giving values to array elements wich they are known

If we know the values of the array elements in advance, then the array is initialized together with the array definition. The previous array is initialized as follows:
double A[ ] = {1.1, 2.0, 2.5, -1.6, 3.3};

EXAMPLE 5: Entering elements of an array from a user and determining the number of positive ones:

Task text: Enter the number of elements, then enter the members of the integer array and determine how many of them are positive.

Solution:
First you need to enter the number of elements of the sequence n, in order to be able to define an array of real numbers:

int n;
cout << "Enter the number of elements of an array" << endl;
cin >> n;

Then the memory is reserved for a series of integers that will have n elements:

// Define a string of n elements

int A [n];

Now you can enter the elements:

//Entering an array
for(int i=0; i < n; i++)
{
cout<<"Enter "+(i+1)+". element of an array";
cin>>A[i];
}

The array of real numbers is then printed as follows using a loop:

//Printing an array
for(int i=0; i < n; i++)
{
cout << A[i] << " ";
}

In the second part, using a loop with the same parameters as when entering elements and printing array elements, a number of elements that are positive are calculated:

// Determining the number of positive elements

int numOfPos=0;
for(int i=0; i < n; i++)
{
if( A[i] > 0)
{
numOfPos++;
}
}
cout<< "Number of positive one is " << numOfPos<< endl;
}

EXAMPLE 6: Entering array elements from a user and specifying the bigest element:

Task text: Enter the number of elements, then enter the real numbers of the array and determine maximum of them.

Solution:

We must first define the array.

int n;
cout << "Enter the nuber of elements" << endl;
cin >> n;

Suppose that the five elements of a string from a user are entered and that the values are entered as shown in the figure below

Figure 6: Determining the largest element in the array

Determining the maximum can be done as follows:

Assume that the maximum is the first element of the array

double max;
max= a[0];

Then the current element of the array is changed through the for loop and it is checked whether it is greater than the assumed maximum. If so, that element becomes the maximum.

for(int i=0; i < n; i++)
{
if( a[i] > max)
{
max=a[i];
}
}
cout<< "max=" << max << endl;
}

The determination of the minimum is done in a similar way, only as a condition it is checked whether the current member is lower than the assumed minimum.

double min;
min= a[0];
for(int i=0; i < n; i++)
{
if( a[i] < min)
{
min=a[i];
}
}
cout<< "min=" << min << endl;
}

Deeper Analysis of Differences Between Arrays in C and C++

1. Memory Management in C Arrays

Static Allocation: Arrays in C are usually declared with a fixed size determined at compile time. The memory is allocated on the stack for such arrays:

int arr[5]; // Allocated on the stack.

Dynamic Allocation: For more flexibility, dynamic arrays can be created using functions like malloc or calloc. These are allocated on the heap, requiring explicit management to avoid memory leaks:

int* arr = (int*)malloc(5 * sizeof(int)); // Allocate space for 5 integers.
free(arr); // Deallocate the memory when done.

Challenges: Managing memory manually increases the risk of errors, such as memory leaks or segmentation faults due to improper allocation or deallocation.

2. Memory Management in C++ Arrays

Static Arrays: Similar to C, C++ supports fixed-size arrays

int arr[5];

Dynamic Arrays: Dynamic memory can be allocated using the new keyword:

int* arr = new int[5]; // Allocate memory for 5 integers.
delete[] arr; // Deallocate memory.

Modern C++ Practices: Since C++11, raw pointers are discouraged in favor of safer alternatives like std::unique_ptr and std::shared_ptr.

3. std::vector: A Safer and More Flexible Alternative

Introduction: The std::vector class from the Standard Template Library (STL) is a dynamic array that automatically manages memory. It offers several advantages over raw arrays:

Automatic Resizing: Dynamically adjusts size as elements are added or removed.
Safety: Prevents out-of-bound errors with bounds-checked access using .at() method.
Ease of Use: Memory management is handled internally, reducing the risk of leaks

std::vector<int> vec = {1, 2, 3};
vec.push_back(4); // Add an element.

Performance Considerations: Although std::vector may have a slight overhead compared to raw arrays due to its dynamic nature, it’s highly optimized for typical use cases.

4. Key Differences

Aspect	C Arrays	C++ Arrays
Memory Allocation	Requires manual memory management using `malloc`, `calloc`, and `free`.	Can use `new` and `delete` for dynamic memory, but STL containers like `std::vector` handle this automatically.
Bounds Checking	No built-in bounds checking; accessing out-of-bounds elements leads to undefined behavior.	Same for raw arrays, but `std::vector` provides bounds checking using the `at()` method.
Size Management	Fixed size defined at compile-time or runtime. Size cannot change.	`std::vector` supports dynamic resizing and provides functions like `push_back()` and `resize()`.
Ease of Use	Requires manual tracking of size and memory, leading to potential errors.	`std::vector` provides a high-level interface, simplifying usage and reducing errors.
Initialization	Must initialize elements explicitly. Example: `int arr[5] = {1, 2, 3, 0, 0};`.	`std::array` (from C++11) or `std::vector` supports modern initialization syntax.

5. When to Use Each

Use C arrays for:

Low-level, performance-critical applications.
Scenarios where memory management needs fine control.

Use std::vector for:

Most C++ applications requiring dynamic arrays.
Safer and easier code maintenance.

Two-dimensional arrays

Two-dimensional arrays or matrices are used to place numbers in multiple rows and columns. Read more about it on the website:
Two dimensional array-matrix

Figure 7: Matrix(Two dimensional array)

Image by Gerd Altmann from Pixabay

Advanced Examples Section

Tic-Tac-Toe Game Using Multidimensional ArraysOne engaging example for readers is the implementation of the popular game Tic-Tac-Toe using a 2D array. This not only demonstrates the use of multidimensional arrays but also introduces basic game logic.

#include <iostream>
using namespace std;

void printBoard(char board[3][3]) {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << board[i][j] << " ";
}
cout << endl;
}
}

bool checkWin(char board[3][3], char player) {
// Check rows and columns
for (int i = 0; i < 3; i++) {
if ((board[i][0] == player && board[i][1] == player && board[i][2] == player) ||
(board[0][i] == player && board[1][i] == player && board[2][i] == player)) {
return true;
}
}
// Check diagonals
if ((board[0][0] == player && board[1][1] == player && board[2][2] == player) ||
(board[0][2] == player && board[1][1] == player && board[2][0] == player)) {
return true;
}
return false;
}

int main() {
char board[3][3] = { {'-', '-', '-'}, {'-', '-', '-'}, {'-', '-', '-'} };
char player = 'X';
int row, col;

while (true) {
printBoard(board);
cout << "Player " << player << ", enter your move (row and column): ";
cin >> row >> col;
if (board[row][col] == '-') {
board[row][col] = player;
if (checkWin(board, player)) {
printBoard(board);
cout << "Player " << player << " wins!" << endl;
break;
}
player = (player == 'X') ? 'O' : 'X';
} else {
cout << "Cell already occupied. Try again." << endl;
}
}
return 0;
}

Key Takeaways:

Demonstrates initialization, iteration, and manipulation of 2D arrays.
Includes game logic, user interaction, and win conditions.

2. Dynamic Memory Allocation for 2D Arrays

More advanced example involves dynamically allocating memory for a 2D array, manipulating its elements, and properly deallocating memory using delete[].
Code Example:

#include <iostream>
using namespace std;

int main() {
int rows, cols;
cout << "Enter the number of rows and columns: ";
cin >> rows >> cols;

// Dynamically allocate memory for a 2D array
int** matrix = new int*[rows];
for (int i = 0; i < rows; i++) {
matrix[i] = new int[cols];
}

// Initialize the array
cout << "Enter elements of the matrix:" << endl;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
cin >> matrix[i][j];
}
}

// Print the matrix
cout << "Matrix:" << endl;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
cout << matrix[i][j] << " ";
}
cout << endl;
}

// Deallocate memory
for (int i = 0; i < rows; i++) {
delete[] matrix[i];
}
delete[] matrix;

cout << "Memory deallocated successfully." << endl;
return 0;
}

Key Takeaways:

Highlights the flexibility of dynamically allocated arrays.
Introduces new for allocation and delete[] for proper memory cleanup.
Emphasizes the importance of memory management in C++.

Discussion on Safety and Potential Errors in Array Usage

Avoiding Common Errors

Boundary Overruns (Buffer Overflow):
One of the most common issues in C and C++ when working with arrays is accessing elements outside their defined bounds. This leads to undefined behavior, potential crashes, or even security vulnerabilities in applications.

Example:

int arr[5] = {1, 2, 3, 4, 5};
// Accessing out-of-bounds element
std::cout << arr[5]; // Undefined behavior!

Tip: Always validate indices before accessing array elements:

if (index >= 0 && index < sizeof(arr) / sizeof(arr[0])) {
std::cout << arr[index];
} else {
std::cerr << "Index out of bounds!";
}

Using Safer Alternatives in C++

C++ offers tools to avoid such errors by design:

std::array (C++11): Provides bounds-checking with the at() method, throwing an exception if an invalid index is accessed.

#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5};
try {
std::cout << arr.at(5); // Throws std::out_of_range exception
} catch (const std::out_of_range &e) {
std::cerr << e.what();
}

2. std::vector: A dynamic array with built-in memory management and safe access methods. It also supports bounds-checking with at().

#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
try {
std::cout << vec.at(5); // Throws std::out_of_range exception
} catch (const std::out_of_range &e) {
std::cerr << e.what();
}

Tools for Debugging Array Issues

Static Analyzers:
Tools like clang-tidy or cppcheck can help identify potential boundary issues in your code.

AddressSanitizer:
A runtime tool that detects memory errors like buffer overflows in both C and C++.

g++ -fsanitize=address -g main.cpp -o main
./main

Code Example: Safeguarded Array Manipulation

Using std::vector to ensure safe access:

#include <iostream>
#include <vector>

int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};

// Safe access with bounds-checking
for (size_t i = 0; i <= numbers.size(); i++) {
try {
std::cout << numbers.at(i) << " ";
} catch (const std::out_of_range &e) {
std::cerr << "\nError: " << e.what();
}
}
return 0;
}

Benefits of std::array and std::vector

Reduced Risk of Overflows: Built-in bounds-checking with at().
Automatic Memory Management: Avoids manual allocation and deallocation of memory, reducing the risk of memory leaks.
Compatibility with Standard Algorithms: Fully compatible with STL algorithms, enabling safer and more efficient operations.

Optimization of Code: Efficient Array Iteration

Importance of Efficient IterationWhen working with arrays, the efficiency of your iteration logic can significantly impact performance, particularly in compute-intensive applications or with large data sets. By choosing the right loop structure and techniques, you can optimize the performance and readability of your code.

Traditional Loops vs. Range-Based Loops

Traditional For Loop: The classic for loop provides explicit control over iteration but requires careful handling of indices and boundary conditions.

#include <iostream>
#include <vector>

int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (size_t i = 0; i < numbers.size(); ++i) {
std::cout << numbers[i] << " ";
}
return 0;
}

Pros: Full control over the iteration process.
Cons: Prone to errors (e.g., boundary overflows) and verbose.

Range-Based For Loop (C++11+): The range-based for loop simplifies iteration by abstracting away indices and focusing on the elements.

#include <iostream>
#include <vector>

int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
std::cout << num << " ";
}
return 0;
}

Pros: Cleaner syntax, reduces error risk, and improves readability.
Cons: Limited flexibility (e.g., you can't directly modify elements unless using references).

Using References in Range-Based Loops: For scenarios where you need to modify elements of an array or a vector:

#include <iostream>
#include <vector>

int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int &num : numbers) {
num *= 2; // Modify elements directly
}
for (const int &num : numbers) {
std::cout << num << " ";
}
return 0;
}

Leveraging STL Algorithms

For highly optimized and expressive code, consider using STL algorithms like std::for_each with lambda functions:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
std::for_each(numbers.begin(), numbers.end(), [](int num) {
std::cout << num << " ";
});
return 0;
}

Pros: Optimized under the hood, concise, and adheres to modern C++ practices.

Cache Optimization Techniques

Iterating through arrays in a cache-friendly manner can improve performance, especially for multidimensional arrays:
Row-Major Order: Access elements in the same order as they are stored in memory.

Example:

int matrix[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
std::cout << matrix[i][j] << " ";
}
}

Key Takeaways for Optimization

Choose the Right Loop: Use range-based loops for simplicity and STL algorithms for expressive and optimized iteration.
Minimize Cache Misses: Access array elements in memory-friendly patterns to leverage spatial locality.
Avoid Unnecessary Copies: Use references in loops to prevent expensive element copying.
Profile and Benchmark: Always test the performance of your code with tools like gprof or perf to identify bottlenecks.

Interaction Between Arrays and Functions in C and C++

In C and C++, arrays are frequently passed to functions to enable processing of larger datasets. This approach allows for efficient manipulation but requires an understanding of pointers and references, as arrays are passed to functions as pointers.
Key Points:

Passing Arrays by Pointer: When an array is passed to a function, what is actually passed is the address of its first element.
Manipulating Arrays Within Functions: Functions can modify array elements directly since they work with the original memory locations.
Difference Between Pointers and Arrays: While they behave similarly in many scenarios, pointers and arrays have distinct differences, especially in arithmetic operations and dynamic memory allocation.

For a more detailed explanation of how functions interact with arrays, including practical examples such as sorting arrays within a function, visit the following page:
Functions in C and C++

Previous
|< Loops in C/C++

Next
Dynamic array-vector >|

Arrays in programming languages C and C++​