Funktion mit char-array-parameter

Ich versuche zu schreiben, eine Funktion für das drucken von text in C für PIC-mikrocontroller (ich denke, es basiert auf gcc).

void print(char[] text);

void print(char[] text)
{
    for(ch = 0; ch < sizeof(text); ch ++)
    {
        do_something_with_character(text[ch]);
    }
}

- und nennen es wie folgt:

print("some text");

Ich bin immer compiler-Beschwerden über falsche Klammern.

Was ist Los mit diesem?
Wie kann ich ein char-array-Zeiger in diesem Fall?

mögliche Duplikate von Wie benutze ich arrays in C++?
eigentlich char[] text ist keine gültige C-syntax. Es sollte char text[] oder char *text

InformationsquelleAutor Kamil | 2014-05-12

arrays c parameter-passing pointers

Ich würde es so machen:

void print(char *text);

void print(char *text)
   {
   while(*text)
      {
      do_something_with_character(*text);
      ++text;
      }
   }

Warten... die Leute tatsächlich verwenden, dass die Einrückung Stil? Meine Augen...
meist alte Hasen, aus der 'alten Schule'.

InformationsquelleAutor Mahonri Moriancumer

4

Die korrekte syntax ist
```
void print(char text[])
```
oder
```
void print(char *text)
```
In print() verwenden, können Sie sizeof Betreiber, um herauszufinden, die Länge der Zeichenkette text verwenden, benötigen Sie strlen() (gehören <string.h> ersten) oder testen, ob text[ch] ist \0.

InformationsquelleAutor Lee Duhem
4

Wie bereits in anderen Antworten, deine syntax ist falsch. Die Klammern gehören nach text.

Ebenfalls von besonderer Bedeutung, sizeof hat nicht tun, was Sie erwarten sind hier:
```
void print(char[] text)
{
    for(ch = 0; ch < sizeof(text); ch ++)
                     ^^^^^^
```
Erinnern, sizeof ist ein compile-Zeit Betreiber - der compiler ersetzt Sie mit der Größe, während der code aufgebaut wird. Es kann nicht wissen, die Größe zur Laufzeit.

In diesem Fall sizeof(text) ist immer wieder sizeof(void*) oder 4 auf den meisten 32-bit-Systeme. Auf Ihrer Plattform können variieren.

Haben Sie zwei Möglichkeiten:
- Übergeben Sie die Länge, die in einem anderen parameter zu drucken.
- Behandlung der char[] als "C-string", wo die Länge ist unbekannt, aber die Zeichenkette NUL-Zeichen.
Letzteres ist Ihre beste Wette, und Sie sollten wahrscheinlich ersetzen char[] mit char*.

Hier verwenden wir einen NUL-terminierten string, und Durchlaufen Sie es mit einem Zeiger:
```
void print(const char* text)
{
    const char* p;

    //Iterate over each character of `text`,
    //until we reach the NUL terminator
    for (p = text; *p != '\0'; p++) {

        //Pass each character to some function
        do_something_with_character(*p);
    }
}
```
- Wie kann ich dynamisch die Größe des char-array?
- Siehe strlen. Aber Achtung: Beim Umgang mit typischen C-strings, werden Sie selten um das, was die tatsächliche Länge der Zeichenfolge ist.
- Ich brauche, um zu beurteilen, dass text...
- Natürlich. Hast du mein letztes Beispiel?
InformationsquelleAutor Jonathon Reinhart
2

Müssen Sie die eckigen Klammern in der richtigen Stelle:

~~void print(char[] text); void print(char[] text)~~
```
void print(char text[]);

void print(char text[])
```
oder verwenden Sie Zeiger notation:
```
void print(char *text);

void print(char *text)
```
Beachten Sie auch, dass, selbst wenn Sie die array-Schreibweise der parameter ist wirksam neu geschrieben, um einen Zeiger, und dann den code in den Körper der Funktion:
```
for(ch = 0; ch < sizeof(text); ch ++)
```
ist falsch. Sie fast sicher wollen nicht, die 4 oder 8 bytes, die die Größe des Zeigers. Sie wollen wahrscheinlich:
```
size_t len = strlen(text);
for (size_t ch = 0; ch < len; ch++)
```
Wenn Sie sich nicht deklarieren Sie Variablen in der Schleife (C99 oder neuer erforderlich), deklarieren Sie Sie separat. Sie zeigen nicht die Erklärung der ch im code. Wenn es kompiliert, das bedeutet, dass ch ist eine Globale variable, die — und das ist ziemlich schrecklich.

Beachten Sie, dass die ++ operator bindet sich fest und sollten nicht getrennt werden von Ihren Operanden durch ein Leerzeichen.
- Was ist der Sinn darin, eine anschauliche Erklärung? Gib einfach meh teh sampl codez plz.
- 'Tis die Weise der Welt. Es gibt keinen Punkt in immer verärgert darüber, obwohl von den meisten Punkten der Ansicht, es wäre vertretbar.
InformationsquelleAutor Jonathan Leffler
1

Pass C-Stil-string-Pointern oder Klammern nach der variable name:
```
void print(char *text);
                ^
```
oder
```
void print(char text[]);
                    ^^
```
Berechnen Sie die Länge einer Zeichenfolge, verwenden Sie strlen nicht sizeof.
```
int len = strlen(text);
for(ch = 0; ch < len; ch ++)
                 ^^^^
```
- Beachten Sie, dass die Verwendung strlen() in der Schleifenbedingung konvertiert einen linearen Algorithmus in einen quadratischen Algorithmus als Länge ausgewertet wird, die bei jeder iteration es sei denn, der compiler ist wirklich schlau und kann feststellen, dass sich nichts ändert die Länge des Strings.
- Guter Punkt, bearbeitet. Ich komme aus der C++ - Reich, die Berufung string::length() in der Schleife ist nicht schlecht.
InformationsquelleAutor deepmax
1

Beurteilung auf Ihre Frage und die Beobachtung, dass Sie wahrscheinlich ein Anfänger in C, werde ich versuchen, Ihre Frage zu beantworten, ohne Verwendung von Zeigern wie den anderen Antworten hier.

First off, Jonathon Reinhart macht einen ausgezeichneten Punkt, dass sizeof ist nicht die richtige Verwendung hier. Auch, wie andere darauf hingewiesen, dass der korrekte syntax für eine array von Zeichen, das ist, was Sie verwenden, in Ihrem code wie folgt:
```
//empty character array
//cannot be changed or given a value
char text[];

//character array initialized to the length of its content
char text[] = "This is a string";

//character array with length 1000
//the elements may be individually manipulated using indices
char text[1000];
```
In deinem Fall würde ich etwas wie das hier tun:
```
#include <string.h>

void print(char text[]);

int main()
{
    char text[] = "This is a string";
    print(text);

    return 0
}

void print(char text[])
{
    //ALWAYS define a type for your variables
    int ch, len = strlen(text);

    for(ch = 0; ch < len; ch++) {
        do_something_with_character(text[ch]);
    }
}
```
Die standard library header string.h bietet die strlen Funktion gibt einen integer-Wert (eigentlich ein unsigned long) von der Länge der Zeichenfolge ohne des abschließenden NULL-Zeichens \0. In C sind strings nur arrays von Zeichen, und die Art und Weise, die Sie angeben, das Ende der Zeichenkette ist durch die Einbeziehung \0 am Ende.

InformationsquelleAutor samrap

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.