Zuweisen von Speicher -, Doppel-Zeiger?

Ich habe Schwierigkeiten zu verstehen, wie Speicher zuweisen
auf ein double-Zeiger.
Ich will Lesen ein array von strings und speichern Sie es.

    char **ptr;
    fp = fopen("file.txt","r");
    ptr = (char**)malloc(sizeof(char*)*50);
    for(int i=0; i<20; i++)
    {
       ptr[i] = (char*)malloc(sizeof(char)*50);
       fgets(ptr[i],50,fp);
    }

statt diese ich weisen Sie einfach einen großen Speicherblock und
speichern Sie die Zeichenfolge

  char **ptr;
  ptr = (char**)malloc(sizeof(char)*50*50);

wäre das falsch? Und wenn ja, warum ist das so?

Nennen Sie es nicht eine "doppelte pointer" - dies bekommt Sie off auf dem falschen Fuß geistig - es ist ein Zeiger auf einen Zeiger.

InformationsquelleAutor lazy_hack | 2010-02-13

  1. 12

    Ihre zweite Beispiel ist falsch, weil jeder memory location konzeptionell würde nicht halten eine char* sondern eine char. Wenn Sie leicht ändern Sie Ihr denken, kann es helfen, mit diesem:

    char *x;  //Memory locations pointed to by x contain 'char'
char **y; //Memory locations pointed to by y contain 'char*'

x = (char*)malloc(sizeof(char) * 100);   //100 'char'
y = (char**)malloc(sizeof(char*) * 100); //100 'char*'

//below is incorrect:
y = (char**)malloc(sizeof(char) * 50 * 50);
//2500 'char' not 50 'char*' pointing to 50 'char'

    Weil, Ihre erste Schleife wäre, wie man in C ein array von Zeichen-arrays/Zeigern. Mit einem festen block von Speicher für ein array von Zeichen-arrays ist ok, aber würden Sie einen einzigen char* eher als eine char**, da Sie keine Zeiger in den Speicher, nur chars.

    char *x = calloc(50 * 50, sizeof(char));

for (ii = 0; ii < 50; ++ii) {
    //Note that each string is just an OFFSET into the memory block
    //You must be sensitive to this when using these 'strings'
    char *str = &x[ii * 50];
}
    sollte man nicht die Letzte Zeile sein char *str = x+(ii*50)?
    Und nicht gegossen, das Ergebnis malloc()!

    InformationsquelleAutor user7116

  2. 3

    ich gebe ein Beispiel, das vielleicht klar, der Zweifel,

    char **str;                              //here its kind a equivalent to char *argv[]
str = (char **)malloc(sizeof(char *)*2)  //here 2 indicates 2 (char*)
str[0]=(char *)malloc(sizeof(char)*10)   //here 10 indicates 10 (char)
str[1]=(char *)malloc(sizeof(char)*10)   //<same as above>

strcpy(str[0],"abcdefghij");   //10 length character 
strcpy(str[1],"xyzlmnopqr");   //10 length character

cout<<str[0]<<endl;    //to print the string in case of c++
cout<<str[1]<<endl;    //to print the string in case of c++

or

printf("%s",str[0]);
printf("%s",str[1]);  

//finally most important thing, dont't forget to free the allocated mem
free(str[0]);
free(str[1]);
free(str);

    InformationsquelleAutor Abhishek D K

  3. 1

    Einem Doppel-pointer ist nur ein Zeiger auf einen anderen Zeiger. So können Sie reservieren:

    char *realptr=(char*)malloc(1234);
char **ptr=&realptr;

    Haben Sie im Auge zu behalten, wo sich Ihre Zeiger gespeichert ist (in diesem Beispiel die doppelten Zeiger auf einen Zeiger-variable auf den stack, so ist es ungültig, nachdem die Funktion zurückkehrt).

    InformationsquelleAutor Pent Ploompuu

  4. 1

    andere, einfachere Art und Weise auswendig zu lernen

    Case -1 :

    Schritt-1 : char *p;

    Schritt -2 :
    bitte Lesen Sie es wie unten

    char (*p); ==> p ist ein Zeiger auf ein char

    nun müssen Sie nur tun malloc für den Typ (Schritt-2) ohne Klammern

    d.h., p = malloc(sizeof(char) * some_len);

    Case -2 :

    Schritt-1 : char **p;

    Schritt -2 :

    bitte Lesen Sie es wie unten

    char* (* p); ==> p ist ein Zeiger auf eine char *

    nun müssen Sie nur tun malloc für den Typ (Schritt-2) ohne Klammern

    d.h., p = malloc(sizeof(char *) * some_len);

    Case -3 :

    Niemand nutzt diese aber nur aus Gründen der Erläuterung

    char ***p;

    Lesen wie,

    char** (*p); ==> p ist ein Zeiger auf eine char* - * (und für diese Prüfung Fall 2 oben)

    p = malloc(sizeof(char**) * some_len);

    InformationsquelleAutor ravi chandra

  5. 1
     char **ptr;
    fp = fopen("file.txt","r");
    ptr = (char**)malloc(sizeof(char*)*50);
    for(int i=0; i<50; i++)
    {
       ptr[i] = (char*)malloc(sizeof(char)*50);
       fgets(ptr[i],50,fp);
    }

fclose(fp);

    kann deine Tippfehler Fehler, aber die Schleife sollte von 50 anstelle von 20, wenn Sie schauen, für 50 x 50-matrix. Auch nach der Zuteilung von Speicher oben erwähnt können Sie den Zugriff auf die Puffer-ptr[i][j] ich.e im 2D-format.

    InformationsquelleAutor AnkitSahu

  6. 0

    Hinzufügen Pent Antwort, wie er richtig hervorhob, werden Sie nicht in der Lage sein, diese zu verwenden, Doppel-Zeiger, sobald die Funktion zurückkehrt, denn es wird an einen Speicherbereich auf die Funktion " activation-record auf dem stack, der nun obsolet ist (nachdem die Funktion zurückgekehrt ist). Wenn Sie möchten, verwenden Sie diesen Doppel-Zeiger nach der Funktion zurückgegeben hat, können Sie dies tun:

    char * realptr = (char *) malloc(1234);
char ** ptr = (char **) malloc(sizeof(char *));
*ptr = realptr;
return ptr;

    Den Rückgabetyp der Funktion muss offensichtlich sein char **.

    InformationsquelleAutor Rohan Saxena

  7. -3

    Doppel-Zeiger ist, einfach ausgedrückt, ein Zeiger auf einen Zeiger,
    In vielen Fällen ist es verwendet, als eine Reihe von anderen Arten.

    Zum Beispiel, wenn Sie möchten, erstellen Sie ein array von strings, können Sie einfach tun:

    char** stringArray = calloc(10, 40);

    diese erstellt ein array der Größe 10, jedes element wird ein string der Länge 40.

    damit Sie Zugriff auf diese durch stringArray[5] und erhalten Sie einen string in der 6. position.

    dies ist eine Verwendung, die anderen sind wie schon oben erwähnt, ist ein Zeiger auf einen Zeiger, und zugeordnet werden können einfach durch:

    char* str = (char*)malloc(40);
char** pointerToPointer = &str //Get the address of the str pointer, valid only in the current closure.

    Lesen Sie hier mehr:
    gutes tutorial array

    Nein, das schafft ein einzelnes array von 100 char*, vorausgesetzt, char* benötigt 4 bytes.
    Was Hans sagt, ist richtig. Noch mehr, die das array von 100 char* mit 0 initialisiert wird, (da Sie verwendet werden, calloc) so, dass alle diejenigen, char* zeigt auf null und den Zugriff auf die array-Position wird einen Fehler verursachen.

    InformationsquelleAutor MindFold

Schreibe einen Kommentar