Zeiger auf string-array in C

Spielen mit Zeigern in C ist Spaß (nicht wirklich).

Ich habe mehrere arrays von strings ich möchte erklären auf einfache Weise, am besten etwas wie:

arrayOfStrings1 = {"word1", "word2", etc. };
arrayOfStrings2 = {"anotherword1", "anotherword2", etc. };
arrayOfStrings3 = etc.
etc.

Etwas ähnliches wie eine übersetzung array (aber nicht ganz), also ich will in der Lage, wechseln zwischen diesen während der Laufzeit. Dafür will ich einen Zeiger pointerToArrayOfStrings dass ich tauschen kann wie:

pointerToArrayOfStrings = arrayOfStrings1;
doStuff();
pointerToArrayOfStrings = arrayOfStrings2;
doSomeOtherStuff();

In meiner naiven Verständnis von arrays von strings und Pointer auf diese, das ist, was ich versucht habe:

//Danish transforms
const unsigned char* da_DK[] = {"b","bb","c","c","cc","d","dd","e","f","ff","g","gg","h","hh","j","j","jj","k","k","kk","l","l","l","l","ll","m","mm","n","n","nn","p","pp","r","r","r","rr","s","s","s","ss","t","t","tt","v","v","vv","æ"};

//British english transforms
const unsigned char* en_GB[] = {"a","a","a","a","a","a","a","a","a","a","a","a","a","age","ai","aj","ay","b","cial","cian","cian","dj","dsj","ea","ee","ege","ei","ei","eigh","eigh","f","f","f","g","g","gs","i","i","i","j","j","k","ks","kw","l","m","n","n","o","r","s","s","sd","sdr","sion","sion","sj","sj","tial","tion","tion","tj","u","u","u","u","w","ye","ye","z"};

    //More languages....

const unsigned char** laguageStrings;

//Assign language
if (streq(language, "da-DK")){
    laguageStrings= da_DK;
}
else if (streq(language, "en-GB")){
    laguageStrings= en_GB;
}
else
         return 0;
}

Sprache ist ein char * mit der Sprache "en-GB", "da-DK" etc., streq() ist nur eine Heimat gebraut (etwas schneller als strcmp()) string-Vergleich-Funktion.

Lange Geschichte kurz, je nach compiler kann diese Annäherung arbeiten, berichten, dass der compiler Warnungen oder kompilieren, aber unerwarteten Ergebnissen führen.

Was der korrekte Weg wäre, dieses problem zu lösen?

Was ist das problem?
Sie sollten am Ende Ihrer string-arrays mit einem NULL-Zeiger, so dass Sie durchsuchen können Sie sinnvoll: const char * strs[] = { "aa", "bb", NULL };
Je nach compiler funktioniert es nicht. Linux GNU-compiler mag es und funktioniert XCODE nicht und macht einige komische Fehler.
irgendein besonderer Grund für die Verwendung unsigned char nicht char?
Jetzt bin ich die Vermeidung von multibyte/wide-Zeichen-Unterstützung als es ist geschrieben in plain C, aber ich möchte so viele chars von ISO-8859-1 wie möglich, daher unsigned chars.
Ich habe aktualisiert die text, damit es klarer, was meine Frage ist. Ich hoffe, Sie verstehen jetzt.
haben Sie sich überlegt Beachtung der compiler-Warnungen als relevant? Es ist noch nicht klar, ob dein problem mit dem custom streq Funktion oder mit deinem char-Zeigern. Wieder, die compiler-Warnungen, und alle runtime Fehler oder debugger-Ausgabe wäre hilfreich, um zu ermitteln, dass.
Ich werde vorschlagen, Sie Bearbeiten Ihre Frage zu geben, die kürzeste geschlossene (d.h. komplette, das ist kompilierbare) Beispiel für das problem, das Sie erleben. Eine minimale triviales Beispiel. Und gehören die compiler-Warnungen und/oder Laufzeit-Fehler (oder debugger-Ausgabe des Fehlers).
Die Frage ist-vollständig und vage. Ich habe versucht mein bestes, Sie zu beantworten. +1 für deine Frage, wie es verlangt klares Verständnis von dem array von Zeichen (Zeichenfolgen), Ihre Frage zu beantworten.
Ich habe bewusst nicht von compiler-Warnungen/Fehler, weil ich meinte, diese Frage als eine theoretische Frage über die ordnungsgemäße Durchführung der Zeiger auf arrays von strings - @SangeethSaravanaraj hast es genau richtig. Entschuldigungen wenn das war nicht klar.

InformationsquelleAutor Woodgnome | 2012-01-11

arrays c pointers string

Dort sind zwei Weise des Arbeitens mit Arrays von Zeichen (Zeichenketten) in C. Sie sind wie folgt:

char a[ROW][COL];
char *b[ROW];

Bildliche Darstellung ist als ein inline-Kommentar in den code.

Basierend auf, wie Sie darstellen möchten, die das array von Zeichen (strings), können Sie festlegen Zeiger auf, die wie folgt

    char (*ptr1)[COL] = a;
    char **ptr2 = b;

Sind Sie grundsätzlich verschiedene Typen (auf subtile Weise) und so die Zeiger, Sie ist auch ein bisschen Verschieden.

Das folgende Beispiel demonstriert die verschiedenen Möglichkeiten bei der Arbeit mit strings in C und ich hoffe, dass es Ihnen hilft, besser zu verstehen array von Zeichen (Zeichenketten) in C.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define ROW 5
#define COL 10

int main(void) 
{
    int i, j;
    char a[ROW][COL] = {"string1", "string2", "string3", "string4", "string5"};
    char *b[ROW];

    /*

    a[][]

      0   1   2   3   4   5   6     7    8   9
    +---+---+---+---+---+---+---+------+---+---+
    | s | t | r | i | n | g | 1 | '\0' |   |   |
    +---+---+---+---+---+---+---+------+---+---+
    | s | t | r | i | n | g | 2 | '\0' |   |   |
    +---+---+---+---+---+---+---+------+---+---+
    | s | t | r | i | n | g | 3 | '\0' |   |   |
    +---+---+---+---+---+---+---+------+---+---+
    | s | t | r | i | n | g | 4 | '\0' |   |   |
    +---+---+---+---+---+---+---+------+---+---+
    | s | t | r | i | n | g | 5 | '\0' |   |   |
    +---+---+---+---+---+---+---+------+---+---+

    */  

    /* Now, lets work on b */    
    for (i=0 ; i<5; i++) {
        if ((b[i] = malloc(sizeof(char) * COL)) == NULL) {
            printf("unable to allocate memory \n");
            return -1;
        }
    }

    strcpy(b[0], "string1");
    strcpy(b[1], "string2");
    strcpy(b[2], "string3");
    strcpy(b[3], "string4");
    strcpy(b[4], "string5");

    /*

       b[]              0   1   2   3   4   5   6    7     8   9
    +--------+        +---+---+---+---+---+---+---+------+---+---+
    |      -- | ------->| s | t | r | i | n | g | 1 | '\0' |   |   |
    +--------+        +---+---+---+---+---+---+---+------+---+---+
    |      -- | ------->| s | t | r | i | n | g | 2 | '\0' |   |   |
    +--------+        +---+---+---+---+---+---+---+------+---+---+
    |      -- | ------->| s | t | r | i | n | g | 3 | '\0' |   |   |
    +--------+        +---+---+---+---+---+---+---+------+---+---+
    |      -- | ------->| s | t | r | i | n | g | 4 | '\0' |   |   |
    +--------+        +---+---+---+---+---+---+---+------+---+---+
    |      -- | ------->| s | t | r | i | n | g | 5 | '\0' |   |   |
    +--------+        +---+---+---+---+---+---+---+------+---+---+

    */

    char (*ptr1)[COL] = a;
    printf("Contents of first array \n");
    for (i=0; i<ROW; i++)
        printf("%s \n", *ptr1++);


    char **ptr2 = b;
    printf("Contents of second array \n");
    for (i=0; i<ROW; i++)
        printf("%s \n", ptr2[i]);

    /* b should be free'd */
    for (i=0 ; i<5; i++)
        free(b[i]);

    return 0;
}

Also, wenn ich wollte, um zu definieren, mein array von strings als char *[COLS] ich bin gezwungen, zu malloc() und dann strcpy()? Es gibt keine Weise, die ich kann, initialisieren Sie ihn mit einer Liste von string-wie {"string1", "string2", ...}?
Sorry, das war ja char *[ROWS]
Ja, Sie können nicht zuordnen einer Zeichenkette zu einem char[] oder char * wie ordnen Sie einen integer-Wert in eine integer-variable. Für die Zeichenfolge, die Sie verwenden müssen, string-Bibliothek Funktionen wie strcpy()
Könnten Sie Jungs geben eine Erklärung für -1?!
Vielen Dank für die Wahl meiner Antwort. Ich hoffe, es war hilfreich für Sie! .. Wenn du, wie die Antwort, bitte fühlen Sie sich frei, um upvote es! Danke! 🙂
Ich von Ihnen positiv bewertet werden, sobald Sie beantwortet 😛 Die downvote verwirrt mich auch. Mit Bezug auf meine follow-up Frage, werde ich das Wort anders; ich weiß, ich kann nicht erklären, ein char-array string[5]; und dann später initialisieren, wie string = "test";, aber ich habe gelesen, dass es möglich ist, zu initialisieren, eine nur-lese-string wie char *string = "test"; - wenn dem so ist, wäre es nicht möglich, das gleiche zu tun mit char *b[ROWS] = {...} im Sie Beispiel? Sofern ich nicht brauchen, um änderungen an der string natürlich.
das problem mit diesem Fall char *b[rows]= {"first","second" ... ist, dass, wenn Sie möchten, ändern Sie die Zeichenfolge es führt zu nicht spezifiziertem Verhalten !! Das ist, warum es besser ist, verwenden Sie die malloc() Funktion !

InformationsquelleAutor Sangeeth Saravanaraj

1

Was der korrekte Weg wäre, dieses problem zu lösen?

Gut, der richtige Weg wäre, um eine Bibliothek speziell für den Umgang mit mehrsprachigen Schnittstellen - zum Beispiel gettext.

Einen anderen Weg, obwohl patchier, wäre die Verwendung einer hash-Tabelle (auch bekannt als "Wörterbuch" oder "hash-map" oder "assoziative Karte" in anderen Sprachen/Technologien): Der Suche nach einer guten hash-Tabelle für die Implementierung in C

Es ist wahrscheinlich nicht die Antwort, die Sie gesucht, aber Sie gebeten haben, die falsche Frage zum richtigen problem.

InformationsquelleAutor Flavius

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.