Interpunktionszeichen

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Token (Übersicht) - Index

Interpunktionszeichen (auch Trennzeichen genannt) sind wie folgt definiert:

  • [ ]
  • ( )
  • { }
  • ,
  •  ;
  •  :
  • ...
  • *
  • =
  • #

Die meisten dieser Interpunktionszeichen sind ebenfalls Operatoren.

Eckige Klammern

Öffnende und schließende eckige Klammern [ ] beinhalten einfache und mehrdimensionale Array-Indizes:



 char ch, str[] = "Stan";
 int mat[3][4];           /* 3 x 4 Matrix */
 ch = str[3];             /* 4. Element */
   .
   .
   .



Runde Klammern

Öffnende und schließende runde Klammern ( ) fassen Ausdrücke zusammen, isolieren konditionale Ausdrücke und repräsentieren Funktionsaufrufe und Funktionsparameter:



 d = c * (a + b);/* Ändern der normalen Reihenfolge */
 if (d == z) ++x;/* Erforderlich bei einer bedingten Anweisung */
 func();/* Funktionsaufruf ohne Argumente */
 int (*fptr)();/* Funktionszeiger-Deklaration */
 fptr = func;/* keine () bedeutet Funktionszeiger */
 void func2(int n);/* Funktionsdeklaration mit Argumenten */



Runde Klammern müssen in Makrodefinitionen verwendet werden, damit potentielle Rangfolgeprobleme bei der Erweiterung ausgeschlossen sind:



 #define CUBE(x) ((x) * (x) * (x))



Der Einsatz von runden Klammern zur Änderung der normalen Operator-Rangfolge und der Assoziativitätsregeln werden unter dem Thema Ausdrücke erläutert.

Geschweifte Klammern

Öffnende und schließende geschweifte Klammern { } markieren den Beginn und das Ende eines Anweisungsblocks:



 if (d == z)
 {
    ++x;
    func();
 }



Die schließende Klammer dient als Endekriterium für den Anweisungsblock; aus diesem Grund darf nach } kein Semikolon (; ) mehr stehen, außer bei Struktur- oder Klassendeklarationen. Häufig ist ein Semikolon unzulässig, wie z.B.



 if (Anweisung)
    {};                  /* unzulässiges Semikolon */
 else



Komma-Operator

Das Komma (,) trennt die Elemente in einer Funktions-Argumentliste:



 void func(int n, float f, char ch);



Außerdem wird das Komma auch als Operator in Kommaausdrücken verwendet. Es ist zulässig, diese beiden Verwendungsarten zu mischen, aber es müssen dann Klammern zur Klarstellung gesetzt werden. Bitte beachten Sie, dass (exp1, exp2) beide auswertet, aber dem zweiten entspricht.



 func(i, j);                             /* Funktionsaufruf mit zwei Argumenten */
 func((exp1, exp2), (exp3, exp4, exp5));  /* ruft func auch mit zwei Argumenten auf! */



Semikolon

Der Semikolon (;) dient als Endekriterium einer Anweisung. Jeder gültige C- oder C++ Ausdruck (auch der leere Ausdruck), an dessen Ende ein Semikolon steht, wird als Anweisung (Ausdruck-Anweisung) interpretiert. Der Ausdruck wird nur ausgewertet und sein Wert wird verworfen. Wenn der Ausdruck keine Nebeneffekte hat, wird er möglicherweise vom Compiler ignoriert.



 a + b;    /* a + b wird ausgewertet, aber der Wert wird verworfen */
 ++a;      /* Nebeneffekt auf a, aber der Wert von ++a wird verworfen */
 ;        /* leerer Ausdruck = leere Anweisung */



Semikola werden oft zur Erstellung einer leeren Anweisung verwendet:



 for (i = 0; i < n; i++)
 {
    ;
 }



Doppelpunkt

Mit dem Doppelpunkt (:) wird ein Label gekennzeichnet.



 start:    x=0;
 ...
 goto start;



Labels werden unter dem Thema Anweisungen mit Sprungmarken erörtert.

Ellipsen

Die Ellipse (...) besteht aus drei aufeinander folgenden Punkten ohne Whitespace. Ellipsen kennzeichnen in den formalen Argumentlisten der Funktionsprototypen eine variable Anzahl von Argumenten oder Argumente mit nicht festgelegten Typen.



 void func(int n, char ch,...);



Diese Deklaration besagt, dass Aufrufe von func mindestens zwei Argumente haben müssen, ein int und ein char. Daneben können beliebig viele Argumente vorhanden sein.

In C++ ist das Komma vor den Ellipsen optional.

Sternchen (Zeigerdeklaration)

Das Sternchen (*) in einer Variablendeklaration zeigt an, dass ein Zeiger auf einen Typ generiert wird:



 char *char_ptr;  /* es wird ein Zeiger auf char deklariert */



Zeiger mit mehrfachen Indirektionsebenen werden durch mehrere Sternchen gekennzeichnet:



 int **int_ptr;         /* ein Zeiger auf einen integer Array */
 double ***double_ptr;  /* ein Zeiger auf eine double-Matrix */



Ein Sternchen kann auch als Operator, der einen Zeiger dereferenziert, oder als Multiplikationsoperator dienen.



 i = *int_ptr;
 a = b * 3.14;



Gleichheitszeichen (Initialisierer)

Das Gleichheitszeichen (=) trennt Variablendeklarationen von Initialisierungslisten:



 char array[5] = { 1, 2, 3, 4, 5 };
 int  x = 5;



In C++ können – mit wenigen Einschränkungen – alle Deklarationstypen an jeder beliebigen Stelle im Programm stehen. In einer C-Funktion darf vor den Variablendeklarationen kein Quelltext stehen.

In der Argumentliste einer C++ Funktion kennzeichnet das Gleichheitszeichen den Vorgabewert für einen Parameter:



 int f(int i = 0) { ... }  /* Parameter i hat den Standardwert Null */



Das Gleichheitszeichen wird auch als Zuweisungsoperator in Ausdrücken verwendet:



 int a, b, c;
 a = b + c;
 float *ptr = (float *) malloc(sizeof(float) * 100);



Nummernzeichen (Präprozessor-Anweisung)

Das Nummernzeichen (#) fungiert als Präprozessor-Anweisung, wenn es als erstes Nicht-Whitespace-Zeichen in einer Zeile steht. Es gibt eine Compileraktion an, die nicht notwendigerweise mit der Codegenerierung verknüpft ist. Weitere Informationen über Anweisungen für den Präprozessor finden Sie unter Präprozessor-Direktiven.

Die Zeichen # und ## (doppeltes Nummernzeichen) werden auch als Operatoren eingesetzt, die den Präprozessor anweisen, Symbole zu ersetzen bzw. zu verschmelzen. Siehe Symbole einfügen.