Was passiert, wenn wir zwei Zeiger in C gleichsetzen?

Question

Dies ist ein C-Code zum Sortieren der Teilstrings eines großen Strings, beginnend bei jedem Index, aber ich kann nicht verstehen, wie wir das Array a im Code sortieren können.

Soweit ich verstehen:

• wir a[i]-&c[i] beziehen und so erstellt es n-Arrays aber nicht &a[i][1] == &a[i+1][0]?

• Seit a[i] = &c[i], stimmt es, dass &a[i][0] == &c[i]?

• Wenn nicht, sieht das wie eine schnellere Möglichkeit aus, n (Länge der ursprünglichen -Zeichenfolge) Arrays zu erstellen, ohne es tatsächlich zu kopieren. Ist das wahr?

Mein Code

#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
#define M 1 
#define MAXN 5000000 
char c[MAXN], *a[MAXN]; 
int pstrcmp(char **p, char **q){ 
    return strcmp(*p, *q); 
} 
int main(){ 
    int i, ch, n = 0, maxi, maxlen = -1; 
    while ((ch = getchar()) != EOF) { 
     a[n] = &c[n]; 
     c[n++] = ch; 
    } 
    c[n] = 0; 
    qsort(a, n, sizeof(char *), pstrcmp); 
    printf("%s",a[1]); 
    return 0; 
} 

Answer 1

ich pstrcmp erraten habe, ist ein Wrapper um strcmp, die zwei Zeiger vergleicht Zeiger auf char. Etwas wie:

int pstrcmp(const void *a, const void *b) { 
    return strcmp(*(char**)a, *(char**)b); 
} 

Ihre Fragen zu beantworten,

• Ja, &a[i][1] == &a[i+1][0]. Sie zeigen beide auf den i + 1 -ten Charakter von c.
• Ja, &a[i][0] == &c[i].
• Sie erstellen tatsächlich Zeiger auf n Zeichenfolgen, aber es gibt einen Haken: Wenn Sie eine Zeichenfolge ändern (sagen wir das letzte Zeichen), würden Sie mehr Zeichenfolgen ändern. Diese Strings sind also nicht unabhängig.

Konzeptionell ist a[i] ein Zeiger auf das Suffix c beginnend an Position i. Das Programm sortiert dann a gemäß den Werten der Zeichenfolgen, auf die sie zeigen. Also, für c = "abacaba", würden Sie { "a", "aba", "abacaba", "acaba", "ba", "bacaba", "caba" } bekommen.

Bitte beachten Sie, dass es schnellere Möglichkeiten gibt, suffix arrays zu bauen.

Answer 2

In diesem Code sehe ich keine Unterzeichenfolgen, da Sie keine erstellen.
Technisch a ist ein Array von Zeigern vom Typ char, dass es ein Array von Strings machen könnte, aber die Art und Weise verbinden Sie c-a, effektiv a ein Index von c ist.
Innerhalb der Schleife füllen Sie den Index char von char. Später, wenn Sie a sortieren, sortieren Sie den Index.

Das Problem mit dem Index ist, dass Sie nicht wirklich heraus als String drucken können, da es nicht ein char *, dass das %s printf Format Modifikator erwartet, sondern ein char **. Das allein sollte dich vor etwas Gruseligem warnen. Ich sehe, dass Sie dieses Problem als harte Codierung a[1] als Parameter umgehen, aber das einzige Problem, welche Index zu verwenden, erzählt, dass Sie in die falsche Richtung gehen.

Ich habe Ihren Code etwas bearbeitet, wie er das sortierte Array ausdrucken würde. Wenn Sie denken, es ist nicht tun, was Sie wollen, gibt es ein Missverständnis zwischen was Sie wollen und was Ihr Code (außer der letzten printf).

#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
#define MAXN 5000000 
// This is an array of characters: 
char c[MAXN]; 
// This is an array of pointers pointing to individual characters. Essentially, this is an index. 
char *a[MAXN]; 
static int pstrcmp(const void *p1, const void *p2){ 
    // wrapper between strcmp and qsort's compare signature. 
    // See: man 3 qsort -- http://linux.die.net/man/3/qsort 
    return strcmp(* (char * const *) p1, * (char * const *) p2); 
} 
int main() { 
    int ch; 
    size_t n = 0; 
    while ((ch = getchar()) != EOF) { 
     // In this loop, you systematically build up an index, where a[i] points to c[i]. 
     a[n] = &c[n]; 
     c[n] = ch; 
     n++; 
    } 
    c[n] = 0; 
    qsort(a, n, sizeof(char *), pstrcmp); // Now, you sort the _index_. 
    printf("\nc: %s\n", c); // Print Original array. 
    printf("a: "); // Print Ordered array: 
    for (size_t i = 0; i < n; i++) 
     printf("%c", *a[i]); // Look at the indirection 
    printf("\n"); 
    return 0; 
}