Libérant des chaînes de caractères en C

Si je voulais écrire:

char *a=malloc(sizeof(char)*4);
a="abc";
char *b="abc";

ai-je besoin de libérer cette mémoire, ou est-il fait par mon système?

Une autre observation est que je crois que vous n'avez pas besoin sizeof(char) depuis dans toutes les implémentations j'ai vu jusqu'à présent c'est toujours de 1 octet. Donc malloc(4); il suffirait d'une
en fait au-dessus de la mise en œuvre est bonne. Bien que la plupart des systèmes utilisent un octet caractères, la mise en œuvre au-dessus de la laisse clairement ce qui est alloué, et si le code est modifié pour utiliser unichars, qui sont généralement de deux octets, alors il sera plus facile de changer.
J'ai peur, je ne suis pas sûr de ce que exactement un unichar est, mais je suppose que cela a à faire avec unicode. Une rapide recherche sur google suggère objective-c qui est une autre langue 😛 Mais tous les caractères unicode ne sont généralement pas appelé tout à l'omble chevalier. Prendre caractères larges wchar_t par exemple. Peut-être tort, mais c'est ce que j'ai vu jusqu'à présent avec les implémentations j'ai traité avec
Oui, un unichar est un caractère Unicode, mais le concept n'est pas spécifique à l'objective-C. En général n'est pas une bonne idée de faire des hypothèses sur la taille des structures de données.

InformationsquelleAutor Andna | 2012-04-08

c free

11

Dans votre situation, vous n'aurez aucun moyen de libérer la dynamique de la mémoire allouée parce que vous sont en train de perdre la référence à elle.

Essayez ceci:
```
#include <stdio.h>
#include <stdlib.h>

int main()
{
  char *a=(char*)malloc(sizeof(char)*4);
  printf("Before: %p\n",a);
  a = "abc";
  printf("After: %p\n",a);
  free(a);
  char *b = "abc";

  return 0;
}
```
Vous obtiendrez
```
Before: 0x100100080
After: 0x100000f50
```
Vous verrez que les deux pointeurs sont différents. Cela parce que la chaîne de caractères littérale "abc" est placé dans le secteur de données des fichiers binaires et quand vous ne le
```
a = "abc"
```
vous sont en train de changer le pointeur de a à point pour la constante de chaîne littérale "abc" et vous font perdre de la déjà de la mémoire allouée. L'appel de free sur a n'est pas correct de plus, juste parce qu'il ne pointe pas vers un valide allouée dynamiquement adresse plus. Afin de préserver le pointeur et être en mesure de le libérer, vous devez copier la chaîne avec
```
strncpy(a, "abc", 4)
```
Cela aura pour effet de copier les caractères à partir du sens littéral de la allouée dynamiquement la méthode, la préservation de l'original pointeur.
- strcpy est la racine de beaucoup de dépassements de la mémoire tampon. Utiliser strncpy à la place.
- Vous avez raison, j'étais juste compte tenu de ce cas spécifique, permettez-moi de le modifier
- Juste par curiosité, pourquoi dites-vous cela? Parce que strcpy copie strlen(source) octets qui peuvent ne pas toujours être vérifiée par rapport à la taille de la mémoire tampon de la destination? Ou je comprends mal?
- Il n'est pas vérifiée à tous, strcpy copie strlen(source) sans se soucier de la destination de la taille. Si la longueur de la source > dest longueur, alors il va écrire en dehors de limites.
- Merci pour l'explication et la preuve.
- bien sûr, si vous utilisez strncpy vous aurez à libérer la mémoire avec free(a) à la fin du code.
- ouais c'est ce que je voulais dire. Par être vérifié que je voulais dire par vous(le programmeur). Strncpy car elle nécessite variable supplémentaire il vous fait penser, "hé, je dois vérifier des trucs ici, rien n'est automagique" 🙂
InformationsquelleAutor Jack
4

Vous avez une fuite de mémoire ici. Lorsque vous définissez a="abc", vous n'êtes pas le remplissage de la mémoire que vous venez alloué, vous êtes à réaffecter le pointeur sur la statique de la chaîne "abc". b points à la même chaîne statique.

Ce que vous voulez, au contraire, est strncpy(a, "abc", 4), qui permet de copier le contenu de "abc" dans la mémoire allouée (qui a points).

Alors vous auriez besoin de libérer lorsque vous avez terminé.

InformationsquelleAutor rampion
3

Simple réponse oui,non. Aussi votre code est bogué.

Réponse concrète:
```
char *a=malloc(sizeof(char)*4);
```
Allouer de la mémoire de sorte que vous devriez gratuit.
```
a="abc";
```
Il attribue un pointeur vers une chaîne constante à votre char* a, ce faisant, vous perdez le pointeur vers la mémoire allouée dans la première ligne, vous ne devriez jamais gratuitement les chaines.

Utilisation strcpy(a,"abc"); au lieu de a="abc"; pour déplacer la chaîne dans votre mémoire allouée.
- strcpy est la racine de beaucoup de dépassements de la mémoire tampon. Utiliser strncpy à la place.
InformationsquelleAutor josefx
3

Vous ne pouvez pas affecter la chaîne de cette façon, avec C
```
a = "abc"
```
Toutefois, si vous utilisez malloc alors vous devez utiliser free, à l'instar de ce
```
free(a);
```
Mais attention si vous utilisez free(a) dans votre exemple, vous obtiendrez une erreur. Parce que, après le malloc vous changer le pointeur de la a de la valeur à la chaîne statique "abc";
Donc, la prochaine free(a) essayer de libérer de l'une des données statiques. Et vous obtenez l'erreur.

InformationsquelleAutor dash1e
0

oui, vous avez besoin de libérer de la mémoire retourné par malloc.

InformationsquelleAutor paquetp
0

Oui, il va provoquer une fuite de mémoire. Le système ne peut pas gérer le cas.

InformationsquelleAutor Kevin

Vous devez vous connecter pour publier un commentaire.