Several common methods to initialize two-dimensional arrays in C++

There are several different ways to initialize a 2D array in C++, depending on the type of array you want and the specific situation of initializing the data. Here are some commonly used initialization methods:

1. Static initialization

If you know the size and initial value of the array, you can initialize it directly at the time of declaration. This method uses nested braces{}To specify array elements line by line.

int array[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

2. Use loop initialization

You can use nested loops to iterate through each element of the array and assign an initial value to each element. For example:

int arr[3][3];
int value = 1;
 
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        arr[i][j] = value;
        value++;
    }
}

int arr[3][3];
int values[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int index = 0;
 
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        arr[i][j] = values[index];
        index++;
    }
}

3. All initialized to zero

If you want to initialize all elements to zero, you can use{}。

int array[2][3] = {};

4. Partial initialization

If only partial elements are initialized, unspecified elements will be automatically initialized to zero.

int array[2][3] = {
    {1, 2},
    {4}
};

5. Use std::array (C++11 and above)

If you are using C++11 or newer versions, you can usestd::array, which will provide better type safety and more standard library features support.

#include <array>
std::array<std::array<int, 3>, 2> array = {{{1, 2, 3}, {4, 5, 6}}};

6. Dynamic initialization

For dynamically sized two-dimensional arrays, pointers can be initialized using pointers.

int** array = new int*[rows];
for(int i = 0; i < rows; ++i) {
    array[i] = new int[cols];
    for(int j = 0; j < cols; ++j) {
        array[i][j] = 0; // Initialize to 0 or other values    }
}

7. Use std::vector (dynamic size)

If you are not sure about the size of the array, or the size of the array may change at runtime, usestd::vectorIt is a more flexible choice.

#include <vector>
std::vector<std::vector<int>> vec = {
    {1, 2, 3},
    {4, 5, 6}
};

In C++, std::vector<std::vector<int>> is a very flexible and powerful data structure that essentially represents a dynamic two-dimensional array or table. This data structure is composed of nested std::vector containers in the standard template library (STL). Each internal vector can independently change its size, which provides many features and advantages that traditional static two-dimensional arrays do not have.

Unlike traditional two-dimensional arrays that must have fixed row and column sizes, std::vector<std::vector<int>> allows each row to have different lengths, which makes it possible to represent irregular data structures such as triangles or other more complex structures.

std::vector<std::vector<int>>It is a two-dimensional vector, it represents a vector composed of integer vectors. In other words, it is a nested vector where each element is an integer vector.

std::vector<std::vector<int>>It can represent various data structures and relationships, including:

• **Adjacent table: ** represents the vertices in the graph and their adjacent vertices.
• **Matrix: ** represents a two-dimensional array where each element is an integer.
• **Table data: ** represents a table where each row is an integer vector and each column is a specific attribute.
• **Nested List: ** represents a list where each element is a list of integers.

Here are somestd::vector<std::vector<int>>Specific examples:

// Represents a 3x3 matrixstd::vector<std::vector<int>> matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
 
// Represents an adjacency table of a graph with 4 verticesstd::vector<std::vector<int>> adjList = {
    {1, 2},
    {0, 3},
    {0, 3},
    {1, 2}
};
 
// Represents a table where each row is the student's gradesstd::vector<std::vector<int>> grades = {
    {90, 85, 95},
    {80, 90, 85},
    {75, 80, 90}
};

More generally speaking,std::vector<std::vector<int>>Can represent any set that can be represented as an integer vector. For example, it can represent:

• A set of points, where each point is represented by its coordinates.
• A set of rectangles, where each rectangle is represented by its upper left and lower right corner coordinates.
• A set of strings, where each string is represented by its characters.

std::vector<std::vector<int>>is a flexible data structure that can be used to represent various data and relationships. It is widely used in C++ to represent complex data structures and algorithms.

A two-dimensional array in C++ is a multi-dimensional array, usually an array consisting of multiple arrays, each array itself is a one-dimensional array. Here are some features of two-dimensional arrays:

1. Memory layout: A two-dimensional array is stored continuously in memory, and its elements are arranged in row-first order.

2. index: Elements of a two-dimensional array can be accessed through two indices, the first index represents the row and the second index represents the column.

3. Fixed size: Two-dimensional arrays in C++ usually have a fixed size, that is, you need to specify the number of rows and columns when declaring.

4. type: All elements must have the same type, that is, the two-dimensional array is homogeneous.

5. initialization: You can use initialization lists or loop nesting to initialize elements of a two-dimensional array.

6. Pass parameters: When passed as a function parameter, a two-dimensional array usually needs to specify the number of columns, because the array name will be converted to a pointer to the first element, but the compiler will not retain the array size information.

This is the end of this article about several common methods of initializing two-dimensional arrays in C++. For more related content on C++ initializing two-dimensional arrays, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!