Frank am 13. September 2006 um 14:31 Uhr

2006-09-13T14:31:55Z

SprinterSB_alt am 18. Juli 2006 um 07:07 Uhr

2006-07-18T07:07:10Z

SprinterSB_alt am 18. Juli 2006 um 07:02 Uhr

2006-07-18T07:02:38Z

SprinterSB_alt am 18. Juli 2006 um 07:00 Uhr

2006-07-18T07:00:18Z

SprinterSB_alt am 18. Juli 2006 um 06:59 Uhr

2006-07-18T06:59:32Z

SprinterSB_alt am 18. Juli 2006 um 06:57 Uhr

2006-07-18T06:57:37Z

SprinterSB_alt am 18. Juli 2006 um 06:55 Uhr

2006-07-18T06:55:31Z

Neue Seite

Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.

Einfache Beispiele für Ausdrücke sind also z.B.:
1
a
'a'
1 + a
a == 1

Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,
und wie man damit neue Ausdrücke aufbauen kann.

==Lvalues==

Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.

Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie
a+1 = 2;
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> wird an die Adresse 4 im Speicher eine 3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.
* ((unsigned int *) 4) = 3;
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, sobald das Ergebnis feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet. Ein oft anzutreffendes Codestück sieht so aus, dabei sei <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> einen Wert ungleich Null hat, also ob er überhaupt einen gültigen Wert enthält. Es ist weit verbreitete Konvention in C, daß Zeiger, die keinen gültigen Wert haben, die Adresse 0 enthalten. '''Nur dann, wenn ein Zeiger nicht ein Null-Pointer ist, darf überhaupt ein Zugriff über ihn erfolgen!'''

==Vergleich von Variablen==
Skalare Variablen (also ganze Zahlen, Gleitkommazahlen, Zeiger) können miteinander verglichen werden. Dazu gibt es die folgenden Operatoren in C:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
Das Ergebnis der Auswertung ist eine ganze Zahl. Ist die Bedingung erfüllt, dann ist der Wert ungleich 0. Ist die Bedingung nicht erfüllt, dann ist ihr Wert gleich 0.
Meistens wird man diese Operatoren in <tt>if</tt>-Konstrukten finden wie zum Beispiel
if (x >= 10)
x = 10;
oder in Abbruchbedingungen von Schleifen, wie sie weiter unten erklärt werden.

Es ist auch möglich, das Ergebnis der Auswertung in einer <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn <tt>z1</tt> kleiner oder gleich <tt>z2</tt> ist. Ist <tt>z1</tt> jedoch größer als <tt>z2</tt>, dann ist <tt>i</tt> gleich 0 ("unwahr").

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung

==Komponenten-Auswahl bei Structs und Unions==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

Der Adressoperator & kann auf Variablen angewendet werden und
gibt die Startadresse der Variablen im Speicher zurück.

Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente eine abkürzende Schreibweise möglich:

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

'''Achtung!'''
:Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu einer Änderung '''irgendeiner''' Speicherstelle!

int *z; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"Erhoehe einen Integer _irgendwo_ im Speicher um 1" -> CRASH !!!}}
*z = *z + 1;

Viele C-Compiler erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!

==Cast-Operator==

Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.

Um zum Beispiel aus einem Float ein Integer zu machen:
var = (int) 5.60;
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.

Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:
int * addr;
addr = (int*) 0x1234;
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' durch, sondern unterdrückt nur die Compilerwarnungen oder
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in
eine Zahl oder umgekehrt zu wandeln:

<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int)text;

printf("%d\n", zahl);

return 0;
}
</pre>

Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.
}}

==Komma-Operator==
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.
Die Auswertung erfolgt von links nach rechts.

Solche Konstrukte sieht man manchmal in Abfragen wie
FILE *file;
if (file = fopen ("foo.exe", "r"), file != NULL)
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

==Boolsche Logik==
Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird).

b1= b2 && b3;

Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).

b1= b2 || b3;

Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.

b1= !b2;

Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".

← Nächstältere Version		Version vom 13. September 2006, 14:31 Uhr
Zeile 307:		Zeile 307:

	Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".		Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".
		+
		+
		+
		+	[[Kategorie:Software]]

← Nächstältere Version		Version vom 18. Juli 2006, 07:07 Uhr
Zeile 307:		Zeile 307:

	Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".		Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".
−
−	~~[[Kategorie:Software]]~~
−	~~[[Kategorie:Quellcode C]]~~

← Nächstältere Version		Version vom 18. Juli 2006, 07:00 Uhr
Zeile 1:		Zeile 1:
		+	Dieser Artikel ist Teil des [[C-Tutorial]]s.
		+
	Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.		Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.
	Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.		Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.

@@ Zeile 1: / Zeile 1: @@
 Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.
 Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.
@@ Zeile 308: / Zeile 307: @@
 [[Kategorie:Software]]

← Nächstältere Version		Version vom 18. Juli 2006, 06:57 Uhr
Zeile 306:		Zeile 306:

	Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".		Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".
		+
		+	[[Kategorie:Software]]

@@ Zeile 18: / Zeile 18: @@
 Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.
-das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.
+das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in aller Regel nicht.
-Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:
+Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist. Ihr kann ein Wert zugewiesen werden:
   a = 1;
 Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie