Ausgabe in einer bestimmten Art und Weise

Question

Ich versuche, die ASCII-Werte aller Zeichen in einer Textdatei auszudrucken.

Ist es möglich, den Ausgang wie unten gezeigt zu zeigen?

r  a  n  d  o  m 
114 97 110 100 111 109 

Angenommen, das erste Wort in meiner Eingabedatei ist 'zufällig'. Danke

Answer 1

Sie können zuerst einen Puffer verwenden, um die Eingabe in einer Zeile aufzuzeichnen, dann können Sie die ASCII-Werte der Eingabe anzeigen, indem Sie die Zeichen im Puffer in ganze Zahlen in der folgenden Zeile übertragen.

Answer 2

Ja, wie hexiecs sagte, ist es sehr möglich. Fragen wie wäre eine viel bessere Frage. Ich gehe davon aus, dass Sie das meinen. Hier

ist ein Beispiel dafür, wie Sie gehen könnte dies zu tun:

#include <stdio.h> 
#define NEW_TERMINAL_LINE 10 

void print_current_characters(char char_equivalents[]); 

int main(int argc, char const *argv[]) { 
    char char_equivalents[NEW_TERMINAL_LINE] = {0}; 

    int c; 
    int i = 0; 
    int final_position; /* Store the final position that we will use later 
         * to get the remaining characters in the buffer */ 

    FILE *file; 
    file = fopen("file.txt", "r"); 
    if (file) { 
    while ((c = getc(file)) != EOF) { 
     if (i > NEW_TERMINAL_LINE - 1) { 
      /* Every time the buffer fills up, we need to go to a new line 
      * in the output as well (defined by NEW_TERMINAL_LINE). 
      * Then we need to clear the buffer and make a new line 
      * to start off printing again! 
      */ 
      print_current_characters(char_equivalents); 
      int j; 
      for (j = 0; j < sizeof(char_equivalents)/sizeof(char_equivalents[0]); j++) { 
      char_equivalents[j] = 0; /* Clear the filled up buffer */ 
      i = 0; 
      } 
      printf("\n\n"); 
     } 
     /* Print the character itself (we will print the ASCII when the buffer fills up) */ 
     char_equivalents[i] = c; 
     if(char_equivalents[i] == '\n') { 
      printf("\\n\t"); 
     } else if (char_equivalents[i] == '\t') { 
      printf("\\t\t"); 
     } else if (char_equivalents[i] == ' ') { 
      printf("[space]\t"); 
     } else { 
      printf("%c\t", c); 
     } 
     final_position = i; 
     i++; 
    } 

    /* Print any remaining characters in the buffer */ 
    print_current_characters(char_equivalents); 

    fclose(file); 
    } 
    printf("\n"); 
    return 0; 
} 
void print_current_characters(char char_equivalents[]) { 
    printf("\n"); 
    int i; 

    for(i = 0; i < NEW_TERMINAL_LINE; i++) { 
    if (char_equivalents[i] == 0 || NULL) { 
     break; /* Don't print if there is nothing but 0s in the buffer */ 
    } 
    if(char_equivalents[i] == '\n') { 
     printf("\\n\t\t"); 
    } else if (char_equivalents[i] == '\t') { 
     printf("\\t\t"); 
    } else { 
     printf("%d\t", (int)char_equivalents[i]); /* Print the ASCII character */ 
    } 
    } 
} 

Mit meiner vorherigen bearbeiten, Jonathan Leffler und ich besprachen, was passieren würde, wenn der Puffer, da die ursprüngliche Plakat gefüllt sagte in einem Kommentar :

Ich gehe davon aus, dass die Eingabedatei maximal 1000 Zeichen haben wird.

würde der Ausgang eine sehr lange Linie sein, wenn es Zeilenumbrüche nach einer bestimmten Anzahl von Zeichen sind.

Wir könnten nur ein Array mit einem maximalen Puffer von 1000 haben, aber wir könnten auch mehr Speicher speichern, indem Sie nur die Datei jede x Menge an Zeichen verarbeiten. Hier, nach jeder NEW_TERMINAL_LINE Anzahl von Zeichen, können wir eine neue Zeile erstellen und den aktuellen Puffer ausdrucken. Schließlich können wir den Puffer leeren und die Verarbeitung der Zeichen fortsetzen. Bei Verwendung dieses Ansatzes wird der Puffer nur durch den verfügbaren Speicher auf dem Computer begrenzt.

Sagen wir die maximale Anzahl der Zeichen (und die entsprechenden ASCII-Werte) auf einer Linie als 10. Die Textdatei angezeigt werden soll enthält die Zeichenfolge: random random random random random random random random [enter] (Hypothetisch könnte die Zeichenfolge viel länger sein und das Programm würde es immer noch sauber anzeigen). Die Ausgabe dieses Programms sieht aus wie :

 
r a n d o m [space] r a n 
114 97 110 100 111 109 32  114 97 110 

d o m [space] r a n d o m 
100 111 109 32  114 97 110 100 111 109 

[space] r a n d o m [space] r a 
32  114 97 110 100 111 109 32  114 97 

n d o m [space] r a n d o 
110 100 111 109 32  114 97 110 100 111 

m [space] r a n d o m [space] r 
109 32  114 97 110 100 111 109 32  114 

a n d o m \n 
97 110 100 111 109 \n 

wenn NEW_TERMINAL_LINE-10 gesetzt.

1. Wir speichern die ASCII-Entsprechungen in einem Array namens char_equivalents. Für jedes Zeichen, das wir finden, speichern wir es im Array, und dann drucken wir es aus, gefolgt von einem Tab.

2. Sobald der Puffer-Array voll ist, bewegen wir eine Linie, eine Schleife durch die Anordnung nach unten, und die ASCII-Werte mit Formatierung ausdrucken:

   Da char s Wesentlichen int s in Verkleidung als ASCII sind, wir einfach typecast die char als int. Dies wird den entsprechenden ASCII-Wert ausgeben. Danach fügen wir eine Registerkarte hinzu, um sicherzustellen, dass alles mit der darüber liegenden Zeile übereinstimmt. Mit dieser Information ist es nicht schwierig, das Array durchzulaufen und die entsprechende Information auszudrucken.

3. Wir schließlich den Puffer zurücksetzen, und drucken Sie die leere neue Zeile nach NEW_TERMINAL_LINE Zeichen aus Gründen der Klarheit.

4. Der Puffer wird gefüllt und zurückgesetzt, bis alle Zeichen in der Datei gedruckt sind (die vorherigen Schritte werden wiederholt).

5. Am Ende ist manchmal der Puffer nicht voll, so dass wir nie die restlichen ASCII-Äquivalente für die letzte Zeile in der Ausgabe ausgedruckt haben. Wir rufen einfach wieder print_current_characters() an.

---

Ich glaube nicht wirklich, dies der beste Weg war, den Code zu formatieren, aber zugleich wollte ich das Format zu ehren, die die original post gefragt.

Answer 3

Es wird bequemer, wenn Sie einzelne Wörter anstelle von jedem Zeichen verarbeiten. Auf diese Weise können Sie jedes einzelne Zeichen der Wörter zuerst drucken und dann die ASCII-Werte der einzelnen Zeichen als nächstes ausdrucken.

Sie können so etwas versuchen.

int main(int argc, char* argv[]) { 
    FILE *fp; 
    int c; 
    char line[100]; /* Buffer to hold each line */ 
    fp = fopen(argv[1], "r"); 
    /* get each line, and print each word of the line */ 
    while (fgets(line, 100, fp) != NULL) { 
      line[strlen(line) - 1] = '\0'; 
      print_words(line); 
    } 
    fclose(fp); 
    return 0; 
} 

/* print_words: print each word from line */ 
void print_words(char *line) 
{ 
    char *word; 

    /* get each word, and print them with ascii values */ 
    if ((word = strtok(line, " ")) != NULL) 
      ascii_print(word); 
    while ((word = strtok(NULL, " ")) != NULL) 
      ascii_print(word); 
} 

/* ascii_print: print each char and its ascii values for a word*/ 
void ascii_print(char *word) 
{ 
    int i, len; 

    len = strlen(word); 

    /* print the word */ 
    for(i = 0; i < len; i++) 
      printf("%-4c", word[i]); 
    printf("\n"); 

    /* print ascii values */ 
    for(i = 0; i < len; i++) 
      printf("%-4d", word[i]); 
    printf("\n"); 
} 

---

Hinweis über Programm, das nicht ganz richtig ist, und kann Buggy Ergebnisse in einigen Testfälle erzeugen. Es zeigt jedoch, dass es einfacher ist, wenn Sie Wort für Wort statt Zeichen für Zeichen verarbeiten.

Obwohl der Code ist einfach, müssen Sie möglicherweise die Handbücher von fgets() und strtok() sehen, wenn Sie nicht mit ihnen vertraut sind.

kurz sagen, fgets() ein line aus einer Datei bekommt, und strtok() bekommt jeden word von einer Linie. Für weitere Informationen müssen Sie man 3 strtok und man 3 fgets in Google (oder in der Befehlszeile, wenn Unix-ähnliche Maschine verwenden) tun.