Domanda È possibile convertire char [] in char * in C?


Sto facendo un incarico in cui dobbiamo leggere una serie di stringhe da un file in un array. Devo chiamare un algoritmo di cifratura sull'array (cifrario traspone array 2D). Quindi, in un primo momento ho messo tutte le informazioni dal file in un array 2D, ma ho avuto molti problemi con i tipi in conflitto nel resto del mio codice (in particolare cercando di impostare char [] su char *). Così, ho deciso di passare a una serie di puntatori, il che ha reso tutto molto più semplice nella maggior parte del mio codice.

Ma ora ho bisogno di convertire char * in char [] e di nuovo indietro, ma non riesco a capirlo. Non sono stato in grado di trovare nulla su google. Sto iniziando a chiedermi se è anche possibile.


44
2018-03-09 02:01


origine


risposte:


Sembra che tu sia confuso tra i puntatori e gli array. Puntatori e array (in questo caso char * e char []) siamo non è la stessa cosa

  • Un array char a[SIZE] dice che il valore nella posizione di a è una matrice di lunghezza SIZE
  • Un puntatore char *a; dice che il valore nella posizione di a è un puntatore a a char. Questo può essere combinato con l'aritmetica del puntatore per comportarsi come un array (es. a[10] sono 10 voci passate ovunque a punti)

In memoria, sembra questo (esempio preso da le FAQ):

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

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

 char *p = "world"; // pointer

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

È facile essere confusi sulla differenza tra puntatori e array, perché in molti casi, un riferimento di matrice "decade" a un puntatore al suo primo elemento. Ciò significa che in molti casi (come quando passati a una chiamata di funzione) gli array diventano puntatori. Se vuoi saperne di più, questa sezione della FAQ C descrive le differenze nei dettagli.

Una delle principali differenze pratiche è che il compilatore sa quanto è lungo un array. Usando gli esempi sopra:

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)

Senza vedere il tuo codice, è difficile consigliare la migliore linea d'azione, ma ho il sospetto che il passaggio a utilizzare i puntatori ovunque risolverà i problemi che stai attualmente riscontrando. Prendi nota che ora:

  • Avrete bisogno di inizializzare la memoria ovunque fossero gli array. Per esempio, char a[10]; diventerà char *a = malloc(10 * sizeof(char));, seguito da un controllo a != NULL. Nota che in realtà non hai bisogno di dire sizeof(char) in questo caso, perché sizeof(char) è definito come 1. L'ho lasciato per completezza.

  • Ovunque hai avuto in precedenza sizeof(a) per la lunghezza dell'array dovrà essere sostituita dalla lunghezza della memoria che hai assegnato (se stai usando le stringhe, potresti usare strlen(), che conta fino al '\0').

  • Avrai bisogno di fare una chiamata corrispondente a free() per ogni chiamata a malloc(). Questo dice al computer che hai finito di usare la memoria che hai richiesto malloc(). Se il tuo puntatore è a, Scrivi e basta free(a); in un punto del codice in cui sai che non hai più bisogno di niente a punta a.

Come indicato da un'altra risposta, se si desidera ottenere l'indirizzo dell'inizio di un array, è possibile utilizzare:

char* p = &a[0] 

Puoi leggerlo come "puntatore char" p diventa l'indirizzo dell'elemento [0] di a".


93
2018-03-09 02:53



Se hai char[] c allora puoi farlo char* d = &c[0]e accedi all'elemento c [1] facendo *(d+1), eccetera.


10
2018-03-09 02:08



Non è necessario dichiararli come array se si desidera utilizzarli come puntatori. Puoi semplicemente fare riferimento a puntatori come se fossero array multidimensionali. Basta crearlo come puntatore a un puntatore e usarlo 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));

e quindi puoi fare riferimento buf[3][5] o qualsiasi altra cosa


2
2018-03-09 02:17



Beh, non sono sicuro di capire la tua domanda ...

In C, Char [] e Char * sono la stessa cosa.

Modifica: grazie per questo link interessante.


-4
2018-03-09 02:09