C++ Girl
  1. C++ Girl
  3. Allocation dynamic de tableaux 2D en C
Intereting Posts
Qt moc avec des implémentations à l’intérieur de fichiers d’en-tête? Std :: vector répond-il aux exigences de conteneur pour les allocateurs Boost.Interprocess? Implémenter correctement un QWidget personnalisé dans Qt Normes de codage C et C ++ Comment utiliser «modèle externe» avec une classe nestede utilisée par un membre modèle de la même classe? Passer des structs à des fonctions Profiter de SSE et d’autres extensions de processeur Référence non définie à ‘glewExperimental’, ‘glewInit @ 0’, ‘__glewGenBuffers’ Comment utiliser les types std :: tuple avec les algorithmes boost :: mpl? renvoyer une classe abstraite d’une fonction exception de sérialisation boost: classe non enregistrée, problème de sérialisation de base polymorphe Fractionner une chaîne en utilisant C ++ boost :: split sans scinder le texte cité Comment installer extension-functions.c pour sqlite3 sur ubuntu Est-ce que «potentiellement évalué» signifie la même chose que «odr-used» en C ++ 03? Comstackr plusieurs fichiers sources dans Rcpp

Allocation dynamic de tableaux 2D en C

Comment dois-je allouer des tableaux dynamics en C? Actuellement, j’ai une fonction que j’ai écrite appelée malloc2D qui ressemble à ceci: 

 void* malloc2D(size_t unitSize, uint firstCount, uint secondCount) { void** pointer = malloc(sizeof(id) * firstCount); for (int i =0; i < firstCount; i ++){ pointer[i] = malloc(unitSize * secondCount); } return pointer; }

Cela fonctionne bien, mais on m’a dit que cela allège considérablement la mémoire allouée séparément. Quelle est la meilleure façon ou la plus conventionnelle de le faire?

Vous pouvez allouer le tableau sous forme de bloc contigu, comme celui-ci. Supposons que vous souhaitiez 

 int (*arr)[secondCount] = malloc( sizeof(int[firstCount][secondCount]) );

Vous pouvez cacher cela derrière une macro qui prend le nom de type comme argument de macro, bien que le code soit assez simple pour que ce ne soit pas vraiment nécessaire.

Vous pouvez allouer le bloc entier à la fois: 

 int ** foo; foo = malloc(sizeof(int*) * firstCount); foo[0] = malloc(sizeof(int) * firstCount * secondCount); for (int i=1; i

Ma suggestion serait de garder ce que vous avez.

  1. C’est déjà développé.
  2. C’est testé.
  3. C’est intuitif / lisible sans utiliser de macro.
  4. C’est extensible.
  5. Aucun goulot d’étranglement n’a été identifié quantitativement.

Parfois, essayer d’optimiser lorsqu’il n’y a pas de problème peut nuire aux performances. Avez-vous fait des repères contre la théorie de vos amis?

faire fonctionner un gros morceau nécessite de localiser un espace d’adressage contigu et pourrait même provoquer l’échec de malloc lorsque votre méthode actuelle aboutirait ( fragmentation de l’espace d’adressage , etc.).

Quand j’ai dit que votre implémentation actuelle est extensible, je veux dire qu’il est sortingvial de la redimensionner. Si vous allouez pour un [100] [3] et réalisez plus tard que vous avez besoin d’un [100] [4], il vous suffira alors de 100 très petits reallocs, qui ne changeront probablement pas d’adresse. Toutefois, si la méthode macro a besoin d’être redimensionnée, vous devez realloc l’intégralité du bloc qui n’existe peut-être pas de manière contiguë. Pire encore, les données ne sont plus au bon endroit pour accéder à la macro car le calcul a changé, vous aurez donc besoin d’une série de memmove coûteuses.

Pour généraliser, je pense qu’il est important de toujours coder avec lisibilité, facilité de maintenance et facilité d’utilisation – et d’optimiser uniquement après avoir établi un goulot d’étranglement.