How Can I Create Dynamically Sized Two-Dimensional Arrays in C Based on User Input?

Dynamically Sized Two-Dimensional Array Based on User Input

In many programming scenarios, it becomes necessary to create arrays or matrices with sizes that are not known at compile-time. This poses a challenge as arrays typically have fixed dimensions. However, C offers mechanisms to dynamically allocate memory at runtime, enabling the creation of arrays with sizes based on user input.

Using STL Vector of Vectors

One approach to create a dynamic two-dimensional array is to utilize a vector of vectors. This involves defining a vector that stores other vectors, effectively creating a matrix structure. For example:

std::vector<std::vector<int>> matrix(N);

This creates an N-by-N matrix where each element in the inner vectors represents a cell in the matrix. However, it's important to note that each inner vector will need to be resized or assigned values individually, making it less memory-efficient compared to other methods.

Utilizing a Matrix Wrapper Class

An alternative approach is to create a wrapper class that abstracts the matrix representation and handles dynamic memory allocation. Here's an example:

template <class T>
class Matrix {
    int columns_;
    std::vector<T> data;

public:
    Matrix(int columns, int rows) : columns_(columns), data(columns * rows) {}

    T& operator()(int column, int row) { return data[row * columns_ + column]; }
};

This class defines a dynamic matrix of type T, where the constructor assigns the number of columns and rows, and the function operator() provides access to the elements of the matrix using intuitive row and column indices.

Overloading Array Subscript Operator

Another technique involves overloading the array subscript operator ([]). This allows us to access matrix elements using the familiar syntax:

class Matrix {
    int columns_;
    std::vector<T> data;

public:
    Matrix(int columns, int rows) : columns_(columns), data(columns * rows) {}

    T& operator[](const std::pair<int, int>& indices) { return data[indices.first * columns_ + indices.second]; }
};

Using this approach, we can access the matrix elements via:

T& element = matrix[std::make_pair(row, column)];

The choice of method depends on the specific context and performance requirements. Whether utilizing a vector of vectors, a wrapper class, or operator overloading, these techniques provide the flexibility to create and manipulate dynamic two-dimensional arrays in C .

The above is the detailed content of How Can I Create Dynamically Sized Two-Dimensional Arrays in C Based on User Input?. For more information, please follow other related articles on the PHP Chinese website!