Comment puis-je créer des tableaux bidimensionnels de taille dynamique en C en fonction des entrées de l'utilisateur ?

Tableau bidimensionnel de taille dynamique basé sur les entrées de l'utilisateur

Dans de nombreux scénarios de programmation, il devient nécessaire de créer des tableaux ou des matrices avec des tailles qui ne sont pas connues lors de la compilation. temps. Cela pose un défi car les tableaux ont généralement des dimensions fixes. Cependant, C propose des mécanismes pour allouer dynamiquement de la mémoire au moment de l'exécution, permettant la création de tableaux dont les tailles sont basées sur les entrées de l'utilisateur.

Utilisation du vecteur de vecteurs STL

Une approche pour créer un fichier bidimensionnel dynamique array consiste à utiliser un vecteur de vecteurs. Cela implique de définir un vecteur qui stocke d’autres vecteurs, créant ainsi une structure matricielle. Par exemple :

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

Cela crée une matrice N par N où chaque élément des vecteurs internes représente une cellule de la matrice. Cependant, il est important de noter que chaque vecteur interne devra être redimensionné ou attribué des valeurs individuellement, ce qui le rendra moins efficace en mémoire par rapport aux autres méthodes.

Utiliser une classe Wrapper Matrix

Une alternative L’approche consiste à créer une classe wrapper qui résume la représentation matricielle et gère l’allocation dynamique de mémoire. Voici un exemple :

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]; }
};

Cette classe définit une matrice dynamique de type T, où le constructeur attribue le nombre de colonnes et de lignes, et la fonction Operator() permet d'accéder aux éléments de la matrice de manière intuitive indices de lignes et de colonnes.

Surcharge de l'opérateur d'indice de tableau

Une autre technique consiste à surcharger l'opérateur d'indice de tableau ([]). Cela nous permet d'accéder aux éléments matriciels en utilisant la syntaxe familière :

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]; }
};

Grâce à cette approche, nous pouvons accéder aux éléments matriciels via :

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

Le choix de la méthode dépend du spécifique contexte et exigences de performance. Qu'il s'agisse d'utiliser un vecteur de vecteurs, une classe wrapper ou une surcharge d'opérateurs, ces techniques offrent la flexibilité nécessaire pour créer et manipuler des tableaux bidimensionnels dynamiques en C .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!