Unarmische Betreiber in C

Unarmische Betreiber sind die Betreiber, die ihre Arbeit nur an einem Operanden durchgeführt haben. Ein binärer Betreiber benötigt zwei Operanden. Der ternäre Bediener benötigt drei Operanden. + Und - Bediener bezeichnet nur das Zeichen. Zum Beispiel: +5, -7. Diese bezeichnen nur das Zeichen der Nummer. ++ Und - werden als Inkrement- und Dekrement -Operatoren bezeichnet.

Programmierbeispiel 1

In diesem Programm-Beispiel wird zeigen.

#enthalten
int main ()

int x = 3; // eine Variable deklarieren und initialisieren
x ++; // Post -Increment -Operator arbeitet
printf ("%d", x);
Rückkehr 0;

Ausgang

Erläuterung

Hier deklarieren wir eine Variable x. Die Initialisierung erfolgt zum Zeitpunkt der Deklaration der Variablen x. 3 wird der Variablen zugeordnet. Jetzt haben wir x gemacht++. Anwenden des Post-Increment-Operators auf die Variable x. Der Wert von x wird also um 1 erhöht, und der Wert von x beträgt 4.

Programmierbeispiel 2

In diesem Programm-Beispiel wird zeigen, wie unarte Operatoren nach der Inkrement- und Vor-Inkrement-Betreiber mit einem Wert arbeiten.

#enthalten
int main ()

int x = 3;
x ++;
printf ("%d", x); // Post -Inkrement (niedrigste Priorität)
printf ("\ n");
++ X; // Vorinkrement (höchste Priorität)
printf ("%d", x);
printf ("\ n");
Rückkehr 0;

Ausgang

Notiz: Die Priorität der Postinkremente hat bei allen Betreibern, auch Zuordnungsbetreibern in der C -Sprache, die geringste Priorität.

Erläuterung

Hier deklarieren wir eine Variable x, und 3 wird ihr zugewiesen. Jetzt wenden wir den Unary Operator nach der Inkrements auf die Variable X an. Wie wir x ++ getan haben, wird der Wert von x also durch 1 erhöht. Die erste Ausgabe des Programms beträgt also 4.

Anschließend werden wir den Vor-Inkrement-Operator auf dieselbe Variable x anwenden, x. Wie wir ++ x getan haben, wird der Wert von x also durch 1 erhöht. Die zweite Ausgabe des Programms beträgt also 5.

Programmierbeispiel 3

Dieses Programmprogrammbeispiel zeigt, wie Inkrement- und Zuordnungsbetreiber bei einem bestimmten Ausdruck zusammenarbeiten.

#enthalten
int main ()

int x = 3, y;
y = x ++;
printf (" %d, %d \ n", x, y);
Rückkehr 0;

Ausgang

Erläuterung

y = x ++;

Hier sind zwei Betreiber anwesend. Sie sind Zuordnungsbetreiber und Operatoren nach der Inkrement. AS, Zuordnungsbetreiber haben eine größere Priorität als der Post-Increment-Operator. Der Zuordnungsbetreiber führt also zunächst aus. Also der Wert von "y = 3". Dann arbeitet der Post-Increment-Operator im Ausdruck. Dann wird der Wert von x durch 1 erhöht. Also "x = 4".

Programmierbeispiel 4

#enthalten
int main ()

int x = 3, y;
y = ++ x;
printf (" %d, %d \ n", x, y);
Rückkehr 0;

Ausgang

Erläuterung

y = ++ x;

In der obigen Expression des Programmiers sind zwei Operatoren vorhanden. Einer ist ein Vorinkrement -Operator, ein anderer ist der Zuordnungsbetreiber. Der Pre-Increment-Operator hat eine höhere Priorität als der Zuordnungsbetreiber, so. Der Wert von x wird durch eins erhöht. Die Ausgabe des x beträgt also 4.

Jetzt wird dieser Wert von x mit Hilfe des Zuweisungsoperators Y zugewiesen. Der Wert von y ist also jetzt 4. Sowohl die Ausgabe dieses Programms beträgt 4.

Programmierbeispiel 5

In diesem Programm -Beispiel werden wir die Nützlichkeit des Vordekrements -Operators kennenlernen.

#enthalten
int main ()

Int p, q, x, y;
x = 10;
p = --x;
printf ("Pre -Decrement -Operator");
printf ("\ n Der Wert von p ist %d ist.", P);
printf ("\ n Der Wert von x ist %d.", X);
y = 20;
q = y--;
printf ("\ n \ n post Decrement Operator");
printf ("\ n Der Wert von Q ist %d.", Q);
printf ("\ n Der Wert von y ist %d. \ n ", y);
Rückkehr 0;

Ausgang

Erläuterung

Hier beträgt der Wert von x 10. Jetzt ist ein Ausdruck im Programm angegeben. P = -x;

In diesem Ausdruck bedeutet dies sowohl der Vordekrement -Operator als auch der Zuordnungsoperator zusammen. Als Vorab des Dekrements hat Operator eine höhere Priorität als der Zuordnungsbetreiber. Der Operator vor dem Dekrement führt zuerst aus. Der Wert von x wird durch 1 abgeschlossen und erhält 9. Diese 9 wird der Variablen P mit Hilfe des Zuordnungsoperators zugewiesen.

In der nächsten Phase des Programms war der Ausdruck q = y-. Und der Wert von y beträgt 20.

In diesem Ausdruck bedeutet dies sowohl nach dem Dekrement -Operator als auch des Zuordnungsoperators zusammen zusammen. Als Post -Decrement -Operator hat eine höhere Priorität als der Zuordnungsbetreiber. Post -Decrement -Operator führt zuerst aus. Der Wert von x wird durch 1 abgeschlossen und erhält 19. Diese 19 wird der Variablen Q mit Hilfe des Zuweisungsoperators zugeordnet.

Programmierbeispiel 6

In diesem Programm -Beispiel erfahren wir die Nützlichkeit eines anderen Unary Operator ( -) Operators.

#enthalten
int main ()

int a = 20;
int b = -(a);
int x = 12;
int y = -42;
printf ("Wert von a ist: %d \ n", a);
printf ("Wert von B ist: %d \ n", b);
printf ("Wert von x ist: %d \ n", -x);
printf ("Wert von y ist %d \ n", -y);
Rückkehr 0;

Ausgang

Erläuterung

Hier verwenden wir einen anderen Ausdruck int b = -(a);

In diesem Ausdruck verwenden wir einen unartigen Operator- und Zuordnungsbetreiber. Dieser unary Operator verwandelt den Wert von A in einen negativen Wert und weist diesen Wert dann der Variablen B zu. Also der Wert der Variablen a = 20 und des Werts von b = -20.

Ein weiterer Ausdruck, der hier verwendet wird, ist int y = -42;

Der gleiche Mechanismus wird hier wie der obige Ausdruck verfolgt.

Programmierbeispiel 7

Hier verwenden wir einen anderen wichtigen unartigen Operator. Dieser Bediener wird als sizeof () operator bezeichnet. Jetzt werden wir den Operator der Größe () kennenlernen.

#enthalten
int main ()

int x;
printf ("Größe von x = %d \ n", Größe (x)); // Verwendungen von sizeof () operator.
Rückkehr 0;

Ausgang

Erläuterung

In diesem Programm -Beispiel deklarieren wir eine Variable X, die ein ganzzahliger Typ ist, und weisen einen Wert 4 darin zu. Jetzt möchten wir die Größe der Variablen x kennen. Wir verwenden einfach sizeof () operator. Wir erhalten eine Ausgabe Größe von x = 4.

Abschluss

Wir haben alle unären Operatoren auf sehr einfache Weise abgedeckt. Aus dieser Diskussion über die unären Operatoren kamen wir zu dem Schluss, dass Unary -Operatoren ein wichtiges Element für die Verwaltung verschiedener Arten von mathematischen Daten oder Operanden in unserer C -Sprache sind.