Pass char-pointer-array-Funktion

Ich versuche, um eine initialisierte char-pointer-array an eine Funktion. Ich kann nicht scheinen, um herauszufinden, warum die Funktion wird nur drucken Sie die Ziffern von jedem element im array.

Weiß jemand, wie ich drucken kann jedes string-element aus der übergebenen pointer array?

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

void sort(char *);

int main()
{
   char *states[4] = {"Florida", "Oregon", "California", "Georgia"};

   sort(*states);

   return 0;
}

void sort(char *states)
{
   int x;

   for (x = 0; x < 4; x++) {
      printf("\nState: %d\n", states[x]); //only this will compile
      //printf("\nState: %s\n", states[x]); //need to print this.
   }

}

Übergeben Sie einen Zeiger auf Florida für die Funktion, und drucken Sie dann aus den entsprechenden zahlen zu den ersten vier Buchstaben des Strings. War es nicht das, was Sie soll?
sort(states); und void sort(char *states[])
Ok, ich sehe. So war ich nicht akzeptieren das array von Zeigern.

InformationsquelleAutor Andrew Hummel | 2015-12-21

6

Ihre sort Funktion muss akzeptieren das array von Zeigern wenn Sie möchten, drucken Sie den Inhalt des Arrays.
```
void sort (char *states[], size_t num_states) {
    int x;

    for (x = 0; x < num_states; ++x) {
        printf("\nState: %s\n", states[x]); /* Note %s instead of %d */
    }
}
```
Und Sie müssen übergeben Sie das array an die Funktion.
```
sort(states, 4);
```
- Ok, ich sehe. So war ich nicht akzeptieren das array von Zeigern.
- sort Funktion übernehmen muss, ein Zeiger auf Zeiger. Letztlich char *states[] entspricht char **states als eine Funktion parameter, daher char *states[] ist nicht ein array von Zeigern.
- Sind Sie richtig. Das argument von der Anrufer war der name eines Arrays, und das sort - Funktion muss ein Prototyp, der es ermöglicht, das argument übergeben werden. Ein array-name zerfällt zu einem Zeiger mit dem Wert gleich die Adresse des ersten Elements, so sort muss akzeptieren, dass ein Zeiger auf eine char *.
- Ja. Genau.
- Also die char-array-pointer in der main ist immer nur anfangs zeigt auf das erste element im array, richtig?
- Kein char-array-Zeiger in main. states ist ein array von Zeigern auf char. Im Funktionsaufruf sort(states, 4);, states umgewandelt char ** (Zeiger auf erstes element des Arrays states ich.e Zeiger auf state[0]).
InformationsquelleAutor jxh
3

Müssen Sie analysieren, ein array von Zeigern auf char zu sort (statt nur Zeiger auf char).

Als jhx wies darauf hin, Sie müssen übergeben Sie die Größe des array. Sie können sizeof damit nicht die hart-Codierung 4. Auch das auslassen der array-Größe bei der Initialisierung.
```
void sort( char *states[], int arr_size )
{
    int x;

    for (x = 0; x < arr_size; x++) 
    {
        printf( "\nState: %s\n", states[x] );
    }
}

int main()
{
    char *states[] = {"Florida", "Oregon", "California", "Georgia"};     //array of pointers to char

    sort( states, sizeof( states ) / sizeof( char * ) );

    return 0;
}
```
- Können Sie erklären, was der sizeof(Staaten) / sizeof(char *) tut?
- states ist ein array von pointer auf char. char * ist ein Zeiger auf char. So, dass die division gibt die Anzahl der Elemente (dh, die Anzahl von char-Zeigern) in der states array von Zeigern.
InformationsquelleAutor artm

Du musst den char-pointer-array für die Funktion:

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

    void sort(char *args[], int n);

    int main()
    {
       char *states[4] = {"Florida", "Oregon", "California", "Georgia"};

       sort(states, 4);

       return 0;
    }

    void sort(char *states[], const int N)
    {
       int x;

       for (x = 0; x < N; x++) {
          printf("\nState: %s\n", states[x]); 
       }

    }

InformationsquelleAutor seleciii44

1

Dem Grund, dass nur numerische Werte, die Sie bekommen ist, dass nur Zeiger auf erstes element string states[0] des Arrays states übergeben, d.h. Sie übergeben &states[0][0]. Ja, die Erklärung
```
printf("\nState: %d\n", states[x]);  
```
wird nur dann gedruckt wird, wird der numerische Wert der ersten 4 Zeichen von string "Florida".

Muss man den Zeiger auf erstes element des Arrays states, d.h. &states[0].

Dies kann durch ändern der Feststellung der Funktion sort zu
```
void sort(char **, size_t size); //You need to pass the size of array too. 
```
und rufen Sie es als
```
sort(states, sizeof(states)/sizeof(char *));
```
InformationsquelleAutor haccks
0

Den Sie senden states was ist ein array of pointers. So müssen Sie zum senden der Basis-Adresse des Arrays an die Funktion
```
sort(*states);
```
Dann erhalten Sie ein array von Zeiger nur
```
void sort(char* states[])
{
   int x;

   for (x = 0; x < 4; x++) {
      printf("\nState: %s\n", states[x]);
   }

}
```
Hartzucodieren die Größe, wenn auch keine gute Idee, so besser fügen Sie einen weiteren parameter size um die Funktion aufrufen.
```
sort(states, sizeof(states)/sizeof(char*));
```
dann später zur Iteration über das array
```
void sort(char* states[], int size)
{
   int x;

   for (x = 0; x < size; x++) {
      printf("\nState: %s\n", states[x]);
   }

}
```
- sort(states, sizeof(states)); ist falsch.
- danke, editiert. 🙂
InformationsquelleAutor Haris

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.