3.2. Konstanten

Integer-Konstanten

Eine integer-Konstante ist eine ganze Zahl, die positiv, negativ oder null sein kann. Drei Schreibweisen für integer-Konstanten sind zulässig: dezimal, oktal und hexadezimal.

Eine dezimale integer-Konstante ist eine Kombination aus Ziffern von 0 bis 9, wobei die erste nicht Null sein darf. Die Werte

34563			4			909			 56

sind gültige, dezimale integer-Konstanten.

Oktale integer-Konstanten bestehen aus oktalen Ziffern, also aus den Ziffern von 0 bis 7. Das erste Zeichen einer oktalen integer-Konstanten muß eine Null sein. Beispiele für gültige oktale integer-Konstanten:

007			01			0043			 00

Eine hexadezimale integer-Konstante schließlich ist eine Kombination aus hexadezimalen Ziffern (0 bis 9 und a bis f), die mit 0x bzw. 0X beginnen muß. Die Buchstaben a bis f stehen für die dezimalen Werte 10 bis 15.

0x12			0x2ae4		0Xff			 0X3e2

sind Beispiele für hexadezimale integer-Konstanten.

Oktale und hexadezimale Schreibweisen sind relativ selten und finden am ehesten bei der Systemprogrammierung Anwendung.

Im allgemeinen ordnet der Compiler einer numerischen, ganzzahligen Konstanten den kleinstmöglichen Datentyp zu. Sobald ihr Wert aber den Bereich übersteigt, der vom Datentyp integer aufgenommen werden kann, nimmt der Compiler selbständig eine Modifizierung zum Typ long int vor (Modifizierung der elementaren Datentypen siehe Abschnitt 3.3.4.). Dem Programmierer steht es aber frei, bei der Festlegung des Datentyps durch Anfügen der Suffixe L, U oder UL einzugreifen und einen bestimmten Datentyp zu erzwingen. Integer-Konstanten können auf diese Weise zu long, unsigned oder unsigned long verändert werden.

Beispiele:

0L	0x2aU	007ul	0X1A2l
(0 long)	(0x2a unsigned)	(007 unsigned long)	(0x1a2 long)

Fließkomma-Konstanten

Zahlen mit Nachkommastellen können als Fließkomma-Konstanten dargestellt werden. Dabei existieren zwei verschiedene Schreibweisen; die erste und einfachste besteht in der Abfolge von dezimalen Ziffern, die einen Dezimalpunkt (kein Komma!) enthalten.

Beispiele:

3.14159			13.0			0.0		 0.0021

Der Dezimalpunkt muß sich nicht notwendigerweise innerhalb der Zahl befinden, sondern kann auch am Anfang oder Ende stehen. Die zweite Fließkommazahl könnte auch als 13. geschrieben werden, die dritte als .0. Zugunsten der Lesbarkeit ist aber jeweils die erste Variante vorzuziehen. Es ist jedoch darauf zu achten, daß beim zweiten und dritten Beispiel der Dezimalpunkt unbedingt geschrieben werden muß, da der Compiler diesen Konstanten sonst den Typ integer zuordnet.

Die zweite mögliche Darstellung von Fließkommazahlen erfolgt in der Exponentialschreibweise. Diese Form kombiniert eine ganze Zahl oder eine Fließkommazahl mit einer Potenz von 10. In einer von vielen möglichen Varianten sähen die vier Beispielzahlen von oben in der Exponentialschreibweise wie folgt aus:

31415.9E-4			0.13E2			0e0		 0.21E-2

Während der C-Compiler ganzzahligen Konstanten den kleinstmöglichen Datentyp zuordnet, geht er bei Fließkommazahlen immer davon aus, daß es sich bei ihnen um den Typ double handelt. Wie schon bei den ganzen Zahlen sieht C auch bei den Fließkommazahlen die Möglichkeit vor, durch Anfügen eines Suffixes Einfluß auf die Vergabe des Datentyps zu nehmen. Die Endung F‘ bzw. f informiert den Compiler darüber, daß es sich bei der vorliegenden Fließkommazahl um den Typ float handelt. Der an eine Fließkommazahl angehängte Buchstabe l (ebenfalls in Groß- oder Kleinschreibung) gibt an, daß der Datentyp long double vorliegt.

Zeichenkonstanten

Eine Zeichenkonstante ist ein einzelnes Zeichen, das innerhalb von einfachen Anführungszeichen (Apostrophen) geschrieben wird. Zeichenkonstanten haben nicht, wie man erwarten könnte, den Datentyp char, sondern int. Das könnten wir mit Hilfe einer angepaßten Version unseres sizeof.c-Programmes ohne weiteres belegen:

/*******************************************************
 * sizeof1.c                                           *
 * informiert darüber, wieviele Byte unser Compiler    *
 * für eine Zeichenkonstante vergibt                   *
 *******************************************************/
#include <stdio.h>


int main(void)
{
printf("Zeichenkonstante 'x' belegt %d Byte\n", sizeof('x'));

return 0;
}

Beispiele für Zeichenkonstante sind

'x'	'Y'	'2'	' '	'*'

Zeichenkonstanten werden intern als ganzzahliger Wert abgelegt; es handelt sich dabei einfach um jenen Wert, der dem Zeichen innerhalb des Zeichensatzes zukommt. Unser Beispiel ’2’ wird bei Verwendung des ASCII-Zeichensatzes intern durch 50 repräsentiert, weil dies der ASCII-Wert von '2' ist. Anstatt mit '2' könnte man genauso mit dem numerischen Wert 50 arbeiten: '2' ist jedoch besser, weil man sich dadurch nicht vom verwendeten Zeichensatz abhängig macht und damit die Portabilität des Programms erhöht.

Um in einem Programm Zeichen darzustellen, die einzugeben mühsam oder unmöglich wäre, existieren sogenannte Escape-Sequenzen (genaugenommen handelt es sich um Backslash-Sequenzen, weil sie durch einen führenden Backslash charakterisiert werden). Beispielsweise wäre es nicht möglich, mit Hilfe der Funktion printf() einen Zeilenvorschub auszugeben, gäbe es dafür nicht eine entsprechende Escape-Sequenz: Das Einfügen des ASCII-Zeichens mit dem Wert 10 (durch Betätigen der (␍)-Taste) zieht einen Zeilenvorschub im Quellcode und anschließend eine Fehlermeldung des Compilers nach sich, anstatt beim Programmablauf dafür zu sorgen, daß der Cursor in die nächste Zeile springt.

Folgende Escape-Sequenzen sind definiert:

Zeichen	Bedeutung
\a	Alarmglocke
\n	Zeilenvorschub (Unter DOS bewirkt \n einen Zeilenvorschub kombiniert mit einem Wagenrücklauf.)
\r	Wagenrücklauf
\t	horizontaler Tabulator
\v	vertikaler Tabulator
\b	Rücktaste (backspace)
\f	Seitenvorschub
\ '	einzelnes Anführungszeichen
\"	doppeltes Anführungszeichen
\\	Backslash
\?	Fragezeichen

Escape-Sequenzen eignen sich nicht nur zur Darstellung von Sonderzeichen: Es besteht prinzipiell die Möglichkeit, jedes beliebige Zeichen in dieser Form zu einzugeben. Dabei muß auf den führendenen Backslash der oktale oder hexadezimale Wert des Zeichens folgen. ’X’ kann bei der Verwendung des ASCII-Zeichensatzes entweder oktal als ’\130’ oder hexadezimal als ’\x58’ geschrieben werden.

Zeichenketten-Konstanten

Eine Zeichenketten-Konstante ist eine Folge von beliebigen Zeichen, die innerhalb von doppelten Anführungszeichen steht. Beispielsweise handelte es sich in unserem "Hello-world"-Programm beim Argument für printf(), "Hello world\n", um eine Zeichenketten-Konstante. Eine solche String-Konstante (vom englischen "String" für "Zeichenkette") darf auch leer sein: Sie wird dann einfach durch 2 aufeinanderfolgende Anführungszeichen dargestellt (""). Die Anführungszeichen sind nicht Bestandteil der Zeichenkette, sondern begrenzen diese nur.

In Zeichenketten können die gleichen Escape-Sequenzen verwendet werden, die schon zur Darstellung von Zeichenkonstanten erlaubt waren. Das abschließende \n in "Hello world\n" bewirkt erwartungsgemäß, daß printf() nach der Ausgabe von "Hello world" den Cursor an den Anfang der nächsten Zeile setzt.

Der Backslash am Zeilenende dient dazu, lange Zeichenketten über mehrere Zeilen zu verteilen. Dabei ist zu beachten, daß die Zeilenschaltung unmittelbar nach dem Backslash erfolgen muß.

/* Hello world mit 2zeiliger Schreibweise für das 
Argument von printf() */

#include <stdio.h>


int main(void){

printf("Hello \
world\n");

return 0;
}

Zwei benachbarte Zeichenketten-Konstanten werden beim Compilieren zu einer Zeichenkette zusammengefügt:

"Zwei benachbarte"  "Zeichenketten-Konstanten" werden zu "Zwei benachbarte Zeichenketten-Konstanten" 

Rückblickend erhebt sich beim Vergleich von Zeichenkonstanten und String-Konstanten die Frage, warum man nicht gleich alle einzelnen Zeichen als Zeichenkette darstellen und auf Zeichenkonstanten verzichten könnte. Dagegen spricht, daß in C Zeichenketten intern generell mit einer binären Null ('\0') - also dem Zeichen mit dem ASCII-Wert 0 - abgeschlossen werden. Deshalb sind "X" und 'X' nicht das gleiche: Ersteres ist eine null-terminierte Zeichenketten-Konstante (bestehend aus ’X’ und ’\0’), zweiteres eine Zeichenkonstante mit dem Wert 'X'.

Definition von Konstanten mit Hilfe des Preprozessors und des Schlüsselworts const

Konstanten können unter Verwendung der Preprozessor-Anweisung #define vereinbart werden:

#define TRUE 1

veranlaßt den Preprozessor, alle Vorkommnisse von TRUE gegen 1 auszutauschen.

Schließlich kann mit Hilfe des Modifizierers const der Wert einer Variablen als unveränderlich und damit eine Konstante definiert werden.

Beide Varianten werden in den Abschnitten über den Preprozessor (Kapitel 12) und über die Modifizierung der elementaren Datentypen (Kapitel 3.3.) ausführlicher besprochen.