Ist es möglich, char umzuwandeln?[] in C char*?

Ich mache eine Aufgabe, bei der wir eine Reihe von Zeichenfolgen aus einer Datei in ein Array einlesen müssen. Ich muss einen Verschlüsselungsalgorithmus für das Array aufrufen (Verschlüsselung transponiert 2D-Arrays). Also habe ich zuerst alle Informationen aus der Datei in ein 2D-Array eingefügt, aber ich hatte große Probleme mit widersprüchlichen Typen im Rest meines Codes (insbesondere beim Versuch, char[] zu char*). Also beschloss ich, zu einem Array von Zeigern zu wechseln, was den größten Teil meines Codes viel einfacher machte.

Aber jetzt muss ich char* in char umwandeln[] und wieder zurück, aber ich komme nicht drauf. Bei google habe ich nichts gefunden. Ich beginne mich zu fragen, ob es überhaupt möglich ist.

Es hört sich so an, als wären Sie zwischen Zeigern und Arrays verwechselt. Zeiger und Arrays (in diesem Fall char * und char []) sind nicht dasselbe.

• Eine Anordnung char a[SIZE] sagt, dass der Wert an der Stelle von a ist ein Array der Länge SIZE
• Ein Zeiger char *a; sagt, dass der Wert an der Stelle von a ist ein Zeiger auf a char. Dies kann mit Zeigerarithmetik kombiniert werden, um sich wie ein Array zu verhalten (z. B. a[10] ist 10 Einträge Vergangenheit wo auch immer a Punkte)

Im Speicher sieht es so aus (Beispiel aus die FAQ):

 char a[] = "hello";  // array

   +---+---+---+---+---+---+
a: | h | e | l | l | o |\0 |
   +---+---+---+---+---+---+

 char *p = "world"; // pointer

   +-----+     +---+---+---+---+---+---+
p: |  *======> | w | o | r | l | d |\0 |
   +-----+     +---+---+---+---+---+---+

Es ist leicht, den Unterschied zwischen Zeigern und Arrays zu verwechseln, da in vielen Fällen eine Array-Referenz in einen Zeiger auf ihr erstes Element “zerfällt”. Das bedeutet, dass Arrays in vielen Fällen (z. B. bei der Übergabe an einen Funktionsaufruf) zu Zeigern werden. Wenn Sie mehr wissen möchten, Dieser Abschnitt der C-FAQ beschreibt die Unterschiede im Detail.

Ein wesentlicher praktischer Unterschied besteht darin, dass der Compiler weiß, wie lang ein Array ist. Anhand der obigen Beispiele:

char a[] = "hello";  
char *p =  "world";  

sizeof(a); // 6 - one byte for each character in the string,
           // one for the '\0' terminator
sizeof(p); // whatever the size of the pointer is
           // probably 4 or 8 on most machines (depending on whether it's a 
           // 32 or 64 bit machine)

Ohne Ihren Code zu sehen, ist es schwierig, die beste Vorgehensweise zu empfehlen, aber ich vermute, dass die Umstellung auf die Verwendung von Zeigern überall die Probleme lösen wird, die Sie derzeit haben. Beachten Sie das jetzt:

• Sie müssen den Speicher dort initialisieren, wo sich früher die Arrays befanden. Z.B, char a[10]; wird werden char *a = malloc(10 * sizeof(char));gefolgt von einer Überprüfung, dass a != NULL. Beachten Sie, dass Sie es eigentlich nicht sagen müssen sizeof(char) in diesem Fall, weil sizeof(char) ist als 1 definiert. Ich habe es der Vollständigkeit halber belassen.

• Überall dort, wo Sie zuvor waren sizeof(a) für die Array-Länge muss durch die Länge des von Ihnen zugewiesenen Speichers ersetzt werden (wenn Sie Zeichenfolgen verwenden, könnten Sie verwenden strlen()was bis zum zählt '\0').

• Sie müssen einen entsprechenden Anruf tätigen free() für jeden Anruf an malloc(). Dies teilt dem Computer mit, dass Sie mit der Verwendung des angeforderten Speichers fertig sind malloc(). Wenn Ihr Zeiger ist aeinfach schreiben free(a); an einer Stelle im Code, an der Sie wissen, dass Sie nichts mehr brauchen a verweist auf.

Wie eine andere Antwort darauf hingewiesen hat, können Sie Folgendes verwenden, wenn Sie die Adresse des Anfangs eines Arrays abrufen möchten:

char* p = &a[0] 

Sie können dies als “Zeichenzeiger lesen p wird zur Adresse des Elements [0] von a“.

Wenn Sie haben
char[] c
dann kannst du das machen
char* d = &c[0]
und Zugriffselement c[1] durch tun *(d+1)etc.

Sie müssen sie nicht als Arrays deklarieren, wenn Sie sie als Zeiger verwenden möchten. Sie können einfach auf Zeiger verweisen, als wären sie mehrdimensionale Arrays. Erstellen Sie es einfach als Zeiger auf einen Zeiger und verwenden Sie es malloc:

int i;
int M=30, N=25;
int ** buf;
buf = (int**) malloc(M * sizeof(int*));
for(i=0;i<M;i++)
    buf[i] = (int*) malloc(N * sizeof(int));

und dann kannst du referenzieren buf[3][5] oder Wasauchimmer.

Nun, ich bin mir nicht sicher, ob ich deine Frage verstehe…

In C, Zeichen[] und Char* sind dasselbe.

Edit: Danke für diesen interessanten Link.