Supprimer les éléments de tableaux dynamiques

Je vois plusieurs problèmes dans la posté code, chaque de ce qui pourrait causer des problèmes:

retour de la new array

Votre fonction est de prendre un int* array mais alors vous essayez de changer votre temp variable à la fin avant de renvoyer le nouveau tableau. Cela ne fonctionnera pas, que vous êtes tout simplement en remplacement de la copie locale de int* array qui disparaîtra après le retour de la fonction.

Vous avez besoin de passer votre pointeur sur le tableau dans un int**, qui vous permettra d'indiquer le pointeur vers le tableau dans la fonction, ou, je dirais juste retour d'une valeur
de int* de votre fonction, et le retour de la nouvelle pile.

Aussi, comme mentionné dans cette réponse, vous n'avez même pas besoin de réaffecter lors de la suppression d'un élément du tableau, puisque le tableau d'origine est assez grand pour contenir tout.

de taille et d'offset des calculs

1. Vous utilisez sizeof(int*) pour le calcul de la matrice de la taille de l'élément. Cela peut fonctionner pour certains types, mais, par exemple, pour un short tableau sizeof(short*) ne fonctionne pas. Vous ne voulez pas la taille du pointeur vers le tableau, vous voulez que la taille des éléments, qui, pour votre exemple devrait être sizeof(int) bien qu'il ne peut pas causer des problèmes dans ce cas.

2. Votre calcul de la longueur pour les décalages dans les tableaux semble ok, mais vous avez oublier de multiplier le nombre d'éléments par la taille de l'élément pour le paramètre de taille de la memcpy. par exemple,memcpy(temp, array, indexToRemove * sizeof(int));.

3. Votre deuxième appel à memcpy est à l'aide de temp en plus de la compensation de la source de tableau, mais il devrait être array plus l'écart.

4. Votre deuxième appel à memcpy est à l'aide de sizeOfArray - indexToRemove pour le nombre d'éléments à copier, mais vous ne devez copier SizeOfArray - indexToRemove - 1 éléments (ou (sizeOfArray - indexToRemove - 1) * sizeof(int) octets

5. Partout où vous effectuez le calcul des décalages dans le temp et un tableau de tableaux, vous n'avez pas besoin de multiplier par sizeof(int), depuis l'arithmétique des pointeurs tient déjà compte de la taille des éléments. (J'ai raté cela à tout d'abord, merci à: cette réponse.)

regardant incorrect élément

L'impression de test[16] (17e) pour le test, mais vous êtes en train de supprimer le 16e élément, ce qui serait test[15].

coin de cas

Aussi (grâce à cette réponse), vous devez gérer le cas où indexToRemove == 0 et indexToRemove == (sizeOfArray - 1), où vous pouvez faire de l'ensemble de la suppression dans un memcpy.

Aussi, vous avez besoin de s'inquiéter à propos de l'affaire où sizeOfArray == 1. Dans ce cas, peut-être allouer 0, la taille du bloc de mémoire, ou de retourner la valeur null. Dans mon code mis à jour, j'ai choisi d'allouer un 0-la taille de bloc, juste pour différencier entre un tableau avec des 0 éléments contre un tableau non alloué.

Retour d'un 0-tableau de taille signifie aussi il n'y a pas des modifications supplémentaires nécessaires pour le code, parce que les conditions avant chaque memcpy pour gérer les deux premiers cas mentionnés sera d'empêcher les memcpy.

Et juste de mentionner, il n'y a pas de gestion des erreurs dans le code, il y a donc implicitement les conditions pour que indexToRemove est dans les limites, que array n'est pas null, et que array a la taille passée en tant que sizeOfArray.

exemple de code mis à jour

int* remove_element(int* array, int sizeOfArray, int indexToRemove)
{
int* temp = malloc((sizeOfArray - 1) * sizeof(int)); //allocate an array with a size 1 less than the current one
if (indexToRemove != 0)
memcpy(temp, array, indexToRemove * sizeof(int)); //copy everything BEFORE the index
if (indexToRemove != (sizeOfArray - 1))
memcpy(temp+indexToRemove, array+indexToRemove+1, (sizeOfArray - indexToRemove - 1) * sizeof(int)); //copy everything AFTER the index
free (array);
return temp;
}
int main()
{
int howMany = 20;
int* test = malloc(howMany * sizeof(int*));
for (int i = 0; i < howMany; ++i)
(test[i]) = i;
printf("%d\n", test[16]);
remove_element(test, howMany, 16);
--howMany;
printf("%d\n", test[16]);
return 0;
}

quelques mots sur la gestion de la mémoire/les types de données abstraites

Enfin, quelque chose à considérer: il est possible à des questions à la fois avec l'aide de malloc à mémoire de retour à un utilisateur qui devrait être freed par l'utilisateur, et avec freeing mémoire qu'un utilisateur malloced. En général, il est moins probable que la gestion de la mémoire sera confuse et difficile à gérer si la conception de votre code d'unités telles que l'allocation de mémoire est gérée au sein d'une logique unique unité de code.

Par exemple, vous pouvez créer un type abstrait de données module qui vous permet de créer un tableau d'entiers à l'aide d'une structure qui contient un pointeur et d'une longueur, et puis tout à la manipulation de ces données passe par des fonctions de la prise de la structure en tant que premier paramètre. Cela vous permet également, à l'exception de l'intérieur de ce module, pour éviter d'avoir à faire des calculs comme elemNumber * sizeof(elemType). Quelque chose comme ceci:

struct MyIntArray
{
int* ArrHead;
int ElementSize;
//if you wanted support for resizing without reallocating you might also
//  have your Create function take an initialBufferSize, and:
//int BufferSize;
};
void MyIntArray_Create(struct MyIntArray* This, int numElems /*, int initBuffSize */);
void MyIntArray_Destroy(struct MyIntArray* This);
bool MyIntArray_RemoveElement(struct MyIntArray* This, int index);
bool MyIntArray_InsertElement(string MyIntArray* THis, int index, int Value);

etc.

C'est essentiellement le fait de la mise en œuvre en C++des fonctions de type C, et c'est de l'OMI, une très bonne idée, surtout si vous partez de zéro et que vous voulez créer quelque chose de plus qu'une application très simple. Je sais que certains développeurs C qui n'aime vraiment pas ce langage, mais il a bien fonctionné pour moi.

La bonne chose à propos de cette façon de la mise en œuvre de choses, c'est que quelque chose dans votre code à l'aide de la fonction pour supprimer un élément serait de ne jamais être en contact avec le pointeur directement. Cela permettrait de différentes parties de votre code pour stocker un pointeur de votre résumé de la matrice de structure, et lorsque le pointeur vers les données de la matrice a été modifiée après que l'élément a été supprimé, toutes les variables pointant vers votre tableau abstrait serait automatiquement mis à jour.

En général, la gestion de la mémoire peut être très déroutant, et c'est une stratégie qui peut le rendre un peu moins. Juste une pensée.

OriginalL'auteur shelleybutterfly

@cnicutar est la droite (+1), mais aussi, vous écrivez:

memcpy(temp+(indexToRemove * sizeof(int*)), temp+((indexToRemove+1) * sizeof(int*)), sizeOfArray - indexToRemove); //copy everything AFTER the index

alors qu'il devrait être:

memmove(temp+(indexToRemove), temp+(indexToRemove+1), sizeOfArray - indexToRemove); //copy everything AFTER the index

Depuis la multiplication par la taille de int* est fait par le compilateur (c'est de l'arithmétique des pointeurs)

Aussi, lors du déplacement de la superposition de zones de mémoire, utilisez memmove et pas memcpy.

OriginalL'auteur MByD

Il y a quelques problèmes avec ce code :

(a) Lors de l'allocation de la mémoire, vous devez vous assurer d'utiliser le bon type avec sizeof. Pour un tableau de int eg., vous allouer un bloc de mémoire avec une taille qui est un multiple de sizeof(int). Donc :

int* test = malloc(howMany * sizeof(int*));

devrait être :

int* test = malloc(howMany * sizeof(int));

(b) Vous n'avez pas de libérer la mémoire pour le tableau à la fin de main.

(c) memcpy prend le nombre d'octets à copier en tant que troisième paramètre. Vous devez donc, à nouveau, assurez-vous de passer un multiple de sizeof(int). Donc :

memcpy(temp, array, cnt);

devrait être :

memcpy(temp, array, cnt * sizeof(int));

(d) lors de la copie d'éléments de l'ancien tableau à la nouvelle pile, assurez-vous de copier les données correctes. Par exemple, il y a indexToRemove éléments avant de l'élément à l'index indexToRemove, pas un de moins. De même, vous aurez besoin pour vous assurer que vous avez une copie du bon montant, après l'élément qui doit être retiré.

(e) Lors de l'incrémentation d'un pointeur, vous n'avez pas besoin de multiplier avec sizeof(int) - c'est ce que fait implicitement pour vous. Donc :

temp + (cnt * sizeof(int))

devrait vraiment être :

temp + cnt

(f) Dans votre remove_element fonction, vous pouvez assigner une valeur à la variable locale array. Tout changement de variables locales ne sont pas visibles à l'extérieur de la fonction. Donc, après l'appel à remove_element se termine, vous ne pourrez pas voir le changement dans main. Une façon de résoudre ce problème, il est de retour le nouveau pointeur de la fonction, et de l'assigner dans main :

test = remove_element(test, howMany, 16);

OriginalL'auteur Sander De Dycker