wie kann ich wissen, den zugewiesenen Speicher von pointer-Variablen in c

Ich habe vor einige problem in diesem Fall können Sie gerne Ihre Ideen.

main()
{
char *p=NULL;
p=(char *)malloc(2000 * sizeof(char));
printf("size of p = %d\n",sizeof (p));
}

In diesem Programm Seinen drucken Sie die 4, (char *) Wert,aber ich brauche, wie viele bytes reserviert für
.

möglich, Duplikat der Wie kann ich die Größe der Speicherblock mit malloc()?
Sie (und die Antwort) weglassen können sizeof(char) ist Es per definition immer 1.
Sie sollten nicht festgelegten das Ergebnis von malloc in C. stackoverflow.com/search?q=typecast+result+malloc
möglich, Duplikat der Wie kann ich die Größe eines Arrays von einem Zeiger in C?

InformationsquelleAutor RoCkStUnNeRs | 2011-08-26

3

Ist es unmöglich zu wissen, wie viel Speicher zugewiesen wurde, indem Sie nur den Mauszeiger. dabei sizeof (p) wird die Größe des Zeiger-variable p das es zur compile-Zeit, und das ist die Größe des Zeigers. Der Speicher der Zeiger-variable zu speichern, die Zeiger-variable p. Innerhalb p die Startadresse des Speicherblocks gespeichert.

Sobald Sie reservieren von Speicher mit malloc wird es wieder die Startadresse des Speicherblocks, aber das Ende des Blocks kann nicht gefunden werden, da ist kein terminator für einen block. Definieren Sie das Ende des Blocks deshalb Sie brauchen, um zu identifizieren, es mit allen Mitteln, so speichern Sie es irgendwo. Daher müssen Sie, um die Erhaltung der block Länge irgendwo zu wissen, wo der block, der Spitzen, von p endet.

Hinweis: Obwohl die memory-allocation-Struktur verfolgt der zugeordneten und nicht zugeordneten Blöcken, daher können wir wissen, die zugewiesenen Speicherblock der Länge von diesen Strukturen, aber diese Strukturen sind nicht verfügbar für die Verwendung durch den Benutzer, es sei denn, eine Bibliothek-Funktion bietet. Also ein code mit dieser Funktion nicht tragbar (wies von @Rudy Velthuis) . Deshalb ist es am besten zu verfolgen, die Struktur selbst.

Während ich Stimme mit dem, was Sie schrieb, gibt es offensichtlich einen Weg, da free() muss die Größe wissen, zu. Aber es ist nicht immer öffentlich zugänglich und sicherlich kein Tragbarer Weg.
ja, freies wissen müssen, aber es ist abhängig von der internen Struktur und der Algorithmus verwendet wird. Also "es ist unmöglich" ist eine übertreibung.

InformationsquelleAutor phoxis
3

Könnte man auch implementieren einen wrapper für malloc und free, um tags hinzuzufügen (wie die zugewiesene Größe, und andere meta-Informationen), bevor Sie den zurückgegebenen Zeiger von malloc. Dies ist in der Tat die Methode, dass ein c++ - compiler-tags Objekte mit Referenzen zu virtuellen Klassen.
Hier ist ein Beispiel:
```
#include <stdlib.h>
#include <stdio.h>

void * my_malloc(size_t s) 
{
  size_t * ret = malloc(sizeof(size_t) + s);
  *ret = s;
  return &ret[1];
}

void my_free(void * ptr) 
{
  free( (size_t*)ptr - 1);
}

size_t allocated_size(void * ptr) 
{
  return ((size_t*)ptr)[-1];
}

int main(int argc, const char ** argv) {
  int * array = my_malloc(sizeof(int) * 3);
  printf("%u\n", allocated_size(array));
  my_free(array);
  return 0;
}
```
Der Vorteil dieser Methode gegenüber einer Struktur mit Größe und Zeiger
```
 struct pointer
 {
   size_t size;
   void *p;
 }; 
```
ist, dass Sie brauchen nur zu ersetzen, die malloc und frei Anrufe. Alle anderen Zeiger-Operationen erfordern keine Umgestaltung.

Gute Antwort. Ich mag es.
Netter Ansatz! Aber es gibt einige sehr spezielle Fälle, wo diese Methode nicht geeignet ist. Ich meine, wenn erforderlich ist die Angleichung != sizeof(size_t). Das ist der Fall von SSE-Daten, die verwendet 128bits Ausrichtung und ausgerichtet, Daten zu erfüllen cache-Zeilen (64-bit). Die Polsterung von size_t bricht die Ausrichtung, die mit _aligned_malloc. Aber in allen anderen Fällen, in denen Standard-Ausrichtung entspricht sizeof(size_t) (in der Regel 32 oder 64bits), die ist perfekt.
Eigentlich obige code bricht mit der Standard-malloc 16 Byte Ausrichtung in x86_64. Size_t Polsterung schneidet die ersten 8 bytes. Eine einfache Lösung sollte zurück &ret[2] über die Verteilung; der index -2 in beiden allocated_size() und my_free () - Funktionen.

InformationsquelleAutor StefanW
3

Obwohl es möglich sein kann, dass einige Bibliotheken ermöglicht es Ihnen, um zu bestimmen, die Größe des zugewiesenen Puffers, wäre es nicht ein standard-C-Funktion, und Sie sollten suchen Sie in Ihrer Bibliothek die eigenen Dokumentationen.

Jedoch, wenn es gibt viele Orte, die Sie brauchen, zu wissen, die Größe des zugewiesenen Arbeitsspeichers die sauberste Art und Weise Sie es tun ist, um die Größe weiter auf den Zeiger. Das heißt:
```
struct pointer
{
    size_t size;
    void *p;
};
```
Dann jedes mal, wenn Sie malloc den Zeiger, notieren Sie sich die Größe in der size Feld auch. Das problem mit dieser Methode ist jedoch, dass Sie zum cast der Zeiger jedes mal wenn Sie es verwenden. Wenn man in C++ wäre, hätte ich vorgeschlagen, mit template-Klassen. Doch auch in diesem Fall ist es nicht schwer, einfach erstellen Sie so viele Strukturen wie die Typen, die Sie haben. So zum Beispiel
```
struct charPtr
{
    size_t size;
    char *p;
};
struct intPtr
{
    size_t size;
    int *p;
};
struct objectPtr
{
    size_t size;
    struct object *p;
};
```
Ähnliche Namen gegeben, nach der Definition der Zeiger, benötigen Sie keinen zusätzlichen Aufwand (wie z.B. Gießen) für den Zugriff auf das array. Ein Beispiel der Nutzung ist:
```
struct intPtr array;
array.p = malloc(1000 * sizeof *array.p);
array.size = array.p?1000:0;
...
for (i = 0; i < array.size; ++i)
    printf("%s%d", i?" ":"", array.p[i]);
printf("\n");
```
Cool, tolle Idee,

InformationsquelleAutor Shahbaz
1

Müssen Sie zu verfolgen, es in eine variable, wenn Sie wollen, es zu wissen für später:
```
char *p = NULL;
int sizeofp = 2000*sizeof(char);
p = (char *)malloc(sizeofp);
printf("size of p = %d\n",sizeofp);
```
Sie sollten nicht festgelegten das Ergebnis von malloc in C. stackoverflow.com/search?q=typecast+result+malloc
Einige Compiler sich beschweren, wenn Sie nicht gegossen das Ergebnis von malloc ein pointer-Typ, vor allem, wenn Sie casting, um einen struct-pointer oder ein typedef benutzerdefinierte pseudo-Typ. Wenn Sie OCD und kann es nicht ertragen jedes feedback Warnungen vom compiler dann möchten Sie vielleicht, um die Stille solche Warnungen mit einem cast.

InformationsquelleAutor Paulpro
1

Können Sie nicht verwenden den sizeof-in diesem Fall, da p ist ein pointer, kein array, aber da Sie es zuweisen, die Sie bereits kennen:
```
main()
{
    size_t arr_size = 2000;
    char *p=NULL;
    p=malloc(arr_size * sizeof(char));
    printf("size of p = %d\n",arr_size);
}
```
Bearbeiten - Wenn die malloc fehlschlägt, um zuzuteilen, die Größe, die Sie wollte, es nicht geben Ihnen einen Zeiger auf einen kleineren Puffer, aber es wird NULL zurückgegeben.

Und wenn Sie nicht markieren Sie, es gibt einfach keine (standard -) Weg, um herauszufinden, wie groß die Zuteilung war.
Wo haben Sie studiert?
Sie sollten nicht festgelegten das Ergebnis von malloc in C. stackoverflow.com/search?q=typecast+result+malloc
das stimmt, dies ist eine Gewohnheit, die vom schreiben von C-code in C++ - Umgebung
dein code ist richtig, aber deine Aussage ist, fehlt eine wichtige information. Bei der Zuteilung eines Blocks des Speichers, sagen wir 50, weil der header (für die Speicherung von Informationen über den zugewiesenen block), der Daten-Speicher ist tatsächlich kleiner als 50, vielleicht 45, weil der header in der Struktur. Wenn ich falsch bin bitte lassen Sie mich wissen, aber ich bin ziemlich sicher, ich erinnere mich gut.

InformationsquelleAutor MByD

Gibt es keinen portablen Weg, aber für windows:

#include <stdio.h>
#include <malloc.h>

#if defined( _MSC_VER ) || defined( __int64 ) /* for VisualC++ or MinGW/gcc */   
#define howmanybytes(ptr) ((unsigned long)_msize(ptr))
#else
#error no known way
#endif

int main()
{
  char *x=malloc(1234);

  printf( "%lu", howmanybytes(x) );

  return 0;
}

InformationsquelleAutor user411313

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.