Parsing einer Zeichenfolge mit Token für das erste und letzte Wort (in C)

Question

Ich werde versuchen, das Problem zu erklären.

Ich bekomme eine Zeichenfolge mit einem Registrierungsschlüssel. Zum Beispiel:

HKEY_CURRENT_USER\Software\MyProgram\SomeOtherValue\SomeKey 

Jetzt muss ich diese Zeichenfolge in 3 verschiedene char (oder char *) Variablen analysieren. Nach dem Parsen wird es so etwas wie:

string1 = HKEY_CURRENT_USER 
string2 = \Software\MyProgram\SomeOtherValue\ /* with the '\' */ 
string3 = SomeKey 

nicht nur ich zu einer Gruppe müssen die Schrägstriche; Ich weiß auch nicht, wie viele von ihnen dort sind.

HKEY_CURRENT_USER\Software\SomeKey 

oder so etwas wie:: Ich habe etwas wie haben könnte

HKEY_CURRENT_USER\Software\SomeValue\SomeOthervalue\Someblah\SomeKey 

Ich habe versucht, mit strtok() und strcspn(), aber ich bin immer hier sehr verwirrt ... Jede Idee, wie dies zu tun bekommen? Code wird geschätzt.

Danke!

Answer 1

Pseudo-Code:

Schritt 1: Vorwärts spulen, bis die erste "\", den Index beachten.

Schritt 2: Scan vom Ende bis zum letzten "\" (das erste "\" beim Rückwärtsgehen), notieren Sie sich den Index.

Schritt 3: Streichen Sie die relevanten Teile in 3 Strings aus.

Code: (setzt nicht auf strrchr oder andere Methoden, die Sie scheinen sich mit Fragen zu haben)

void ParseRegEntry(char* regKey, char** TopLevel, char** Path, char** Key); 

int main(void) 
{ 
    char* regKey = "HKEY_CURRENT_USER\\Software\\MyProgram\\SomeOtherValue\\SomeKey"; 
    char* TopLevel; 
    char* Path; 
    char* Key; 

    ParseRegEntry(regKey, &TopLevel, &Path, &Key); 

    printf("1: %s\n2: %s\n3: %s\n", TopLevel, Path, Key); 
    free(TopLevel); 
    free(Path); 
    free(Key); 

    return 0; 
} 

void ParseRegEntry(char* regKey, char** TopLevel, char** Path, char** Key) 
{ 
    int firstDelimiter = 0; 
    int lastDelimiter = strlen(regKey)-1; 
    int keyLen; 

    while(regKey[firstDelimiter] != '\\') 
    { 
     firstDelimiter++; 
    } 

    while(regKey[lastDelimiter] != '\\') 
    { 
     lastDelimiter--; 
    } 
    keyLen = strlen(regKey) - lastDelimiter-1; 

    *TopLevel = (char*)malloc(firstDelimiter+1); 
    strncpy(*TopLevel, regKey, firstDelimiter); 
    (*TopLevel)[firstDelimiter] = '\0'; 

    *Path = (char*)malloc(lastDelimiter - firstDelimiter+2); 
    strncpy(*Path, regKey+firstDelimiter, lastDelimiter - firstDelimiter); 
    (*Path)[lastDelimiter-firstDelimiter] = '\0'; 


    *Key = (char*)malloc(keyLen+1); 
    strncpy(*Key, regKey+lastDelimiter+1, keyLen); 
    (*Key)[keyLen] = '\0'; 
} 

Answer 2

Kopieren Sie die Zeichenfolge in eine zugewiesene und teilen Sie die Variable, indem Sie ein "\ 0" in den Schrägstrich setzen, wo Sie es abschneiden möchten.

Sie können die Zeichenfolge mit der Funktion strchr nach Schrägstrichen durchsuchen.

void to_split(char *original, int first_slash, int second_slash, char **first, char **second, char **third) { 
     int i; 
     char *first_null; 
     char *second_null; 
     char *allocated; 

     if (first_slash >= second_slash) 
       return; 
     allocated = malloc(strlen(original) + 1); 
     *first = allocated; 
     strcpy(allocated, original); 
     for (i = 0, first_null = allocated; i < first_slash && (first_null = strchr(first_null,'\\')); i++); 

     if (first_null) { 
       *first_null = '\0'; 
       *second = first_null + 1; 
     } 

     second_null = allocated + strlen(original); 
     i = 0; 
     while (i < second_slash && second_null > allocated) 
      i += *second_null-- == '\\'; 

     if (++second_null > allocated) { 
      *second_null = '\0'; 
      *third = second_null + 1; 
     } 
} 

Verbrauch:

int main (int argc, char **argv) { 
     char *toSplit = "HKEY_CURRENT_USER\\Software\\MyProgram\\SomeOtherValue\\SomeKey"; 
     char *first; 
     char *second; 
     char *third; 
     to_split(toSplit, 1, 3, &first, &second, &third); 
     printf("%s %s %s\n", first, second, third); 
     return 0; 
} 

Es ist nicht der beste Code in der Welt, aber es gibt Ihnen eine Idee.

Answer 3

strchr (char *, char): Finden Sie das erste Vorkommen von char in string

strrchr (char *, char): locate letzte Vorkommen von char in string

char* str = "HKEY_CURRENT_USER\Software\MyProgram\SomeOtherValue\SomeKey"; 
char token1[SIZE], token2[SIZE], token3[SIZE]; 

char* first = strchr(str, '\\'); 
char* last = strrchr(str, '\\')+1; 

strncpy(token1, str, first-str); 
token1[first-str] = '\0'; 
strncpy(token2, first, last-first); 
token2[last-first] = '\0'; 
strcpy(token3, last); 

Wir verwenden strchr die erste zu finden '\' und strrchr zu f ind das letzte '\'. Wir kopieren dann basierend auf diesen Positionen auf token1, token2, token3.

Ich entschied mich dafür, nur Puffer fester Größe anstelle von Callocing zu verwenden, weil das nicht so wichtig ist, um den Punkt zu veranschaulichen. Und ich habe es ständig vermasselt.:)

Answer 4

Hier ist ein Beispiel mit strchr und strrchr um vorwärts und rückwärts in der Zeichenfolge für das '\' zu scannen.

char str[] = "HKEY_CURRENT_USER\Software\MyProgram\SomeOtherValue\SomeKey"; 
char *p, *start; 
char root[128], path[128], key[128]; 

p = strchr (str, '\\'); 
strncpy (root, str, p - str); 
start = p; 
p = strrchr (str, '\\') + 1; 
strncpy (path, start, p - start); 
strcpy (key, p);