Präfixoperatoren - Versionsgeschichte

Satyria: /* Beispiel für die Verwendung von Präfixoperatoren */

2024-09-24T06:49:15Z

Beispiel für die Verwendung von Präfixoperatoren

← Nächstältere Version		Version vom 24. September 2024, 07:49 Uhr
Zeile 96:		Zeile 96:
	</syntaxhighlight>		</syntaxhighlight>
	Dieses Beispiel zeigt die Verwendung der verschiedenen Präfixoperatoren und wie sie in einem einfachen Programm verwendet werden können.		Dieses Beispiel zeigt die Verwendung der verschiedenen Präfixoperatoren und wie sie in einem einfachen Programm verwendet werden können.

			-----

			{\| style="width: 100%;
			\| style="width: 33%;" \| [[Präprozessor-Direktiven\|< Zurück (Präprozessor-Direktiven)]]
			\| style="width: 33%; text-align:center;" \| [[Hauptseite\|< Hauptseite >]]
			\| style="width: 33%; text-align:right;" \| [[Infix-Operatoren\|Weiter (Infix-Operatoren) >]]
			\|}

Satyria am 19. September 2024 um 12:39 Uhr

2024-09-19T12:39:48Z

← Nächstältere Version		Version vom 19. September 2024, 13:39 Uhr
Zeile 1:		Zeile 1:
	~~== Präfixoperatoren ==~~
	Präfixoperatoren sind Operatoren, die vor ihren Operanden stehen und verschiedene Arten von Operationen durchführen können. In der C-Programmierung, und somit auch im Kontext des GNU C Compilers (GCC), gibt es mehrere Präfixoperatoren, die eine wichtige Rolle spielen. Hier sind einige der wichtigsten Präfixoperatoren, die in C verwendet werden:		Präfixoperatoren sind Operatoren, die vor ihren Operanden stehen und verschiedene Arten von Operationen durchführen können. In der C-Programmierung, und somit auch im Kontext des GNU C Compilers (GCC), gibt es mehrere Präfixoperatoren, die eine wichtige Rolle spielen. Hier sind einige der wichtigsten Präfixoperatoren, die in C verwendet werden:

	=== Inkrement (++) und Dekrement (--) ===		== Inkrement (++) und Dekrement (--) ==
	Inkrement (++): Erhöht den Wert einer Variablen um 1.		Inkrement (++): Erhöht den Wert einer Variablen um 1.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 13:		Zeile 12:
	--b; // b ist jetzt 4		--b; // b ist jetzt 4
	</syntaxhighlight>		</syntaxhighlight>
	=== Dereferenzierungsoperator (*) ===		== Dereferenzierungsoperator (*) ==
	Dereferenzierungsoperator (*): Wird verwendet, um auf den Wert zuzugreifen, auf den ein Zeiger zeigt.		Dereferenzierungsoperator (*): Wird verwendet, um auf den Wert zuzugreifen, auf den ein Zeiger zeigt.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 20:		Zeile 19:
	int y = *ptr; // y ist jetzt 10		int y = *ptr; // y ist jetzt 10
	</syntaxhighlight>		</syntaxhighlight>
	=== Adressoperator (&) ===		== Adressoperator (&) ==
	Adressoperator (&): Gibt die Adresse einer Variablen zurück.		Adressoperator (&): Gibt die Adresse einer Variablen zurück.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 26:		Zeile 25:
	int *ptr = &z; // ptr enthält die Adresse von z		int *ptr = &z; // ptr enthält die Adresse von z
	</syntaxhighlight>		</syntaxhighlight>
	=== Logisches Nicht (!) ===		== Logisches Nicht (!) ==
	Logisches Nicht (!): Negiert einen logischen Wert. Wenn der Operand wahr ist, wird er falsch und umgekehrt.		Logisches Nicht (!): Negiert einen logischen Wert. Wenn der Operand wahr ist, wird er falsch und umgekehrt.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 34:		Zeile 33:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	=== Bitweises Nicht (~) ===		== Bitweises Nicht (~) ==
	Bitweises Nicht (~): Invertiert alle Bits eines Wertes.		Bitweises Nicht (~): Invertiert alle Bits eines Wertes.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 40:		Zeile 39:
	unsigned int result = ~num; // Binär: 0101 (in 4-Bit-Darstellung)		unsigned int result = ~num; // Binär: 0101 (in 4-Bit-Darstellung)
	</syntaxhighlight>		</syntaxhighlight>
	=== Vorzeichenwechsel (-) ===		== Vorzeichenwechsel (-) ==
	Vorzeichenwechsel (-): Ändert das Vorzeichen eines Wertes.		Vorzeichenwechsel (-): Ändert das Vorzeichen eines Wertes.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 46:		Zeile 45:
	int negative = -positive; // negative ist jetzt -5		int negative = -positive; // negative ist jetzt -5
	</syntaxhighlight>		</syntaxhighlight>
	=== Größe des Operators (sizeof) ===		== Größe des Operators (sizeof) ==
	Größe des Operators (sizeof): Gibt die Größe eines Datentyps oder einer Variable in Bytes zurück.		Größe des Operators (sizeof): Gibt die Größe eines Datentyps oder einer Variable in Bytes zurück.
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">
Zeile 52:		Zeile 51:
	size_t size = sizeof(a); // size ist die Anzahl der Bytes, die ein int belegt		size_t size = sizeof(a); // size ist die Anzahl der Bytes, die ein int belegt
	</syntaxhighlight>		</syntaxhighlight>
	=== Beispiel für die Verwendung von Präfixoperatoren ===		== Beispiel für die Verwendung von Präfixoperatoren ==
	Hier ist ein einfaches Beispiel, das verschiedene Präfixoperatoren kombiniert:		Hier ist ein einfaches Beispiel, das verschiedene Präfixoperatoren kombiniert:
	<syntaxhighlight lang="C">		<syntaxhighlight lang="C">

Satyria: Die Seite wurde neu angelegt: „== Präfixoperatoren == Präfixoperatoren sind Operatoren, die vor ihren Operanden stehen und verschiedene Arten von Operationen durchführen können. In der C-Programmierung, und somit auch im Kontext des GNU C Compilers (GCC), gibt es mehrere Präfixoperatoren, die eine wichtige Rolle spielen. Hier sind einige der wichtigsten Präfixoperatoren, die in C verwendet werden: === Inkrement (++) und Dekrement (--) === Inkrement (++): Erhöht den Wert einer V…“

2024-09-19T12:38:47Z

Die Seite wurde neu angelegt: „== Präfixoperatoren == Präfixoperatoren sind Operatoren, die vor ihren Operanden stehen und verschiedene Arten von Operationen durchführen können. In der C-Programmierung, und somit auch im Kontext des GNU C Compilers (GCC), gibt es mehrere Präfixoperatoren, die eine wichtige Rolle spielen. Hier sind einige der wichtigsten Präfixoperatoren, die in C verwendet werden: === Inkrement (++) und Dekrement (--) === Inkrement (++): Erhöht den Wert einer V…“

Neue Seite

== Präfixoperatoren ==
Präfixoperatoren sind Operatoren, die vor ihren Operanden stehen und verschiedene Arten von Operationen durchführen können. In der C-Programmierung, und somit auch im Kontext des GNU C Compilers (GCC), gibt es mehrere Präfixoperatoren, die eine wichtige Rolle spielen. Hier sind einige der wichtigsten Präfixoperatoren, die in C verwendet werden:

=== Inkrement (++) und Dekrement (--) ===
Inkrement (++): Erhöht den Wert einer Variablen um 1.
<syntaxhighlight lang="C">
int a = 5;
++a; // a ist jetzt 6
</syntaxhighlight>
Dekrement (--): Verringert den Wert einer Variablen um 1.
<syntaxhighlight lang="C">
int b = 5;
--b; // b ist jetzt 4
</syntaxhighlight>
=== Dereferenzierungsoperator (*) ===
Dereferenzierungsoperator (*): Wird verwendet, um auf den Wert zuzugreifen, auf den ein Zeiger zeigt.
<syntaxhighlight lang="C">
int x = 10;
int *ptr = &x;
int y = *ptr; // y ist jetzt 10
</syntaxhighlight>
=== Adressoperator (&) ===
Adressoperator (&): Gibt die Adresse einer Variablen zurück.
<syntaxhighlight lang="C">
int z = 20;
int *ptr = &z; // ptr enthält die Adresse von z
</syntaxhighlight>
=== Logisches Nicht (!) ===
Logisches Nicht (!): Negiert einen logischen Wert. Wenn der Operand wahr ist, wird er falsch und umgekehrt.
<syntaxhighlight lang="C">
int flag = 0;
if (!flag) {
// Dieser Block wird ausgeführt, da !0 wahr ist
}
</syntaxhighlight>
=== Bitweises Nicht (~) ===
Bitweises Nicht (~): Invertiert alle Bits eines Wertes.
<syntaxhighlight lang="C">
unsigned int num = 0b1010; // Binär: 1010
unsigned int result = ~num; // Binär: 0101 (in 4-Bit-Darstellung)
</syntaxhighlight>
=== Vorzeichenwechsel (-) ===
Vorzeichenwechsel (-): Ändert das Vorzeichen eines Wertes.
<syntaxhighlight lang="C">
int positive = 5;
int negative = -positive; // negative ist jetzt -5
</syntaxhighlight>
=== Größe des Operators (sizeof) ===
Größe des Operators (sizeof): Gibt die Größe eines Datentyps oder einer Variable in Bytes zurück.
<syntaxhighlight lang="C">
int a = 5;
size_t size = sizeof(a); // size ist die Anzahl der Bytes, die ein int belegt
</syntaxhighlight>
=== Beispiel für die Verwendung von Präfixoperatoren ===
Hier ist ein einfaches Beispiel, das verschiedene Präfixoperatoren kombiniert:
<syntaxhighlight lang="C">
#include <stdio.h>

int main() {
int a = 5;
int b = 10;
int *ptr = &a;

// Inkrement und Dekrement
++a; // a ist jetzt 6
--b; // b ist jetzt 9

// Dereferenzierungs- und Adressoperator
int c = *ptr; // c ist jetzt 6 (Wert von a)
int *ptr_b = &b;

// Logisches Nicht
int flag = 0;
if (!flag) {
printf("Flag ist falsch\n");
}

// Bitweises Nicht
unsigned int num = 0b1010;
unsigned int result = ~num;

// Vorzeichenwechsel
int positive = 5;
int negative = -positive;

// Größe des Operators
size_t size_of_int = sizeof(int);

// Ausgabe der Ergebnisse
printf("a: %d, b: %d, c: %d\n", a, b, c);
printf("result (bitweises Nicht): %u\n", result);
printf("negative: %d\n", negative);
printf("Größe eines int: %zu Bytes\n", size_of_int);

return 0;
}
</syntaxhighlight>
Dieses Beispiel zeigt die Verwendung der verschiedenen Präfixoperatoren und wie sie in einem einfachen Programm verwendet werden können.