MIN- und MAX-Funktion in C

Dieses Tutorial behandelt die Verwendung von Makros oder Schleifen zur Implementierung der Funktionen MIN und MAX in C.

die MIN- und MAX-Funktion in C

Die Funktionen MIN und MAX werden verwendet, um die minimale und maximale Anzahl aus zwei Werten zu finden, und sind in der Sprache C nicht vordefiniert. Wenn wir die Funktionen MIN und MAX verwenden wollen, müssen wir sie in C definieren.

Wir können Makros verwenden, um die Funktionen MIN und MAX in der Sprache C zu definieren. Ein Makro ist ein Codesegment, das verwendet wird, um variable Werte und Funktionen zu definieren.

Wenn wir ein Makro aufrufen, wird es durch seinen Wert oder seine Funktion ersetzt. Beispielsweise können wir den Wert einer Variablen wie PI definieren, und wenn wir den Namen PI in unserem Code verwenden, wird der Name durch seinen Wert ersetzt.

Wir können ein Makro auch als eine Funktion definieren, die aufgerufen wird, wenn wir ihren Namen in den Code schreiben. Wir verwenden das Schlüsselwort #define, um Makros in der Sprache C zu definieren.

Lassen Sie uns zum Beispiel die Funktionen MIN und MAX mit Makros der Sprache C definieren. Siehe Code unten.

#include <stdio.h>
#define MIN(i, j) (((i) < (j)) ? (i) : (j))
#define MAX(i, j) (((i) > (j)) ? (i) : (j))
int main() {
  printf("Min = %d\n", MIN(0, 10));
  printf("Max = %d", MAX(0, 10));
  return 0;
}

Ausgabe:

Min = 0
Max = 10

Im obigen Code ist das ? symbol ist der ternäre Operator und wird anstelle der if-else-Anweisung verwendet. Wenn die Bedingung vor dem ternären Operator wahr ist, entspricht die Ausgabe der linken Seite des Doppelpunkts :, und wenn die Bedingung falsch ist, entspricht die Ausgabe der rechten Seite des Doppelpunkts :.

Im obigen Code haben wir Klammern verwendet, da die Eingabe auch ein Ausdruck wie a+b sein kann und sich die Ausgabe ändert, wenn wir keine Klammern verwenden. Anstelle des ternären Operators können wir auch die if-else-Anweisung verwenden.

Der obige Code verursacht Probleme im Falle eines Nebeneffekts der doppelten Auswertung, bei dem wir einen Ausdruck innerhalb einer Funktion übergeben. Wir können den Befehl __typeof__ verwenden, um die Funktionen MIN und MAX zu definieren, um das obige Problem zu vermeiden, was uns mehr Sicherheit und weniger Fehler gibt.

Der Befehl __typeof__ bezieht sich auf den Typ eines Ausdrucks. Wir können den Befehl typeof mit Ausdrücken und einem Typ verwenden.

Lassen Sie uns zum Beispiel die obigen Funktionen MIN und MAX mit dem Befehl __typeof__ definieren. Siehe Code unten.

#include <stdio.h>
#define MAX(x, y)       \
  ({                    \
    typeof(x) _x = (x); \
    typeof(y) _y = (y); \
    _x > _y ? _x : _y;  \
  })

#define MIN(x, y)       \
  ({                    \
    typeof(x) _x = (x); \
    typeof(y) _y = (y); \
    _x < _y ? _x : _y;  \
  })
int main() {
  printf("Min = %d\n", MIN(0, 10));
  printf("Max = %d", MAX(0, 10));
  return 0;
}

Ausgabe:

Min = 0
Max = 10

Im obigen Code haben wir den Befehl __typeof__ verwendet, um auf den Typ der Eingaben zu verweisen, und dann haben wir den ternären Operator verwendet, um die Anweisung if-else zu definieren. Wir können sehen, dass die Ausgabe dieselbe ist wie im vorherigen Beispiel.

Der obige Code kann das Problem der doppelten Auswertung vermeiden, da das obige Makro die Argumente nur einmal auswertet. Die obigen Methoden funktionieren nur bei zwei ganzzahligen Eingängen.

Wenn wir die minimale und maximale Anzahl in einem Array von Zahlen finden möchten, können wir die obigen Methoden nicht verwenden, da wir in den obigen Methoden nur zwei Zahlen vergleichen. Im Fall eines Arrays müssen wir alle Elemente miteinander vergleichen, um den minimalen oder maximalen Wert zu finden, der im Array vorhanden ist.

Wir können das erste Element des Arrays in einer Variablen speichern und dann eine Schleife verwenden, um dieses Element mit anderen Elementen des Arrays zu vergleichen.

Wenn im Fall der maximalen Anzahl das nächste Element größer als das nächste im Array vorhandene Element ist, bedeutet dies, dass das gespeicherte Element nicht das maximal im Array vorhandene Element ist, und wir werden das gespeicherte Element durch das nächste ersetzen Element, und wir werden diesen Vorgang wiederholen, bis das gespeicherte Element mit allen im Array vorhandenen Elementen verglichen ist.

Im Falle einer Mindestanzahl ersetzen wir das gespeicherte Element nur dann durch das nächste Element, wenn das nächste Element kleiner als das gespeicherte Element ist, und wir wiederholen diesen Vorgang, bis das gespeicherte Element mit allen im Array vorhandenen Elementen verglichen ist.

#include <stdio.h>

int MAX(int My_array[], int len);
int MIN(int My_array[], int len);
int main() {
  int My_array[] = {6, 3, 15, 9, 10, 50, 99, 11};
  int len = sizeof(My_array) / sizeof(My_array[0]);
  int numMax = MAX(My_array, len);
  int numMin = MIN(My_array, len);
  printf("Max number = %d\n", numMax);
  printf("Min number = %d", numMin);
  return 0;
}

int MAX(int My_array[], int len) {
  int num = My_array[0];
  for (int i = 1; i < len; i++) {
    if (My_array[i] > num) {
      num = My_array[i];
    }
  }
  return num;
}

int MIN(int My_array[], int len) {
  int num = My_array[0];
  for (int i = 1; i < len; i++) {
    if (My_array[i] < num) {
      num = My_array[i];
    }
  }
  return num;
}

Ausgabe:

Max number = 99
Min number = 3

Im obigen Code haben wir zwei Funktionen erstellt, MAX() und MIN(), die zwei Eingabeargumente haben. Das erste Argument ist das angegebene Array und das zweite die Länge des Arrays.

Wir haben die Funktion sizeof() verwendet, um die Größe des gesamten Arrays zu ermitteln, und sie durch die Größe des ersten Elements des Arrays dividiert, um die Länge des gegebenen Arrays zu erhalten.

Innerhalb der Funktionen MAX() und MIN() haben wir das erste Element des Arrays in einer Variablen gespeichert und es dann mit allen anderen Elementen des Arrays verglichen, indem wir eine Schleife verwendet haben, die stoppt, wenn die ganze Zahl i wird gleich der Länge des Arrays, was bedeutet, dass die Schleife das Ende des Arrays erreicht hat.

Innerhalb der Schleife haben wir eine if-Anweisung verwendet, um das nächste Element des Arrays mit dem von uns gespeicherten Wert zu vergleichen, und wir haben seinen Wert ersetzt, wenn das nächste Element größer als das gespeicherte Element im Fall von MAX() ist. Funktion, und in der Funktion MIN() ersetzen wir den Wert, wenn das nächste Element kleiner als das gespeicherte Element ist. Wir haben die Funktion printf() verwendet, um den von den Funktionen MIN() und MAX() zurückgegebenen Wert auszudrucken.

Der obige Code funktioniert nur für ein Array eines Integer-Datentyps, aber wir können den obigen Code auch ändern, um die minimalen und maximalen Zahlen bei anderen Datentypen wie float zu finden. Im obigen Code müssen wir den Datentyp int in float ändern, falls es sich um ein Array von float-Datentypen handelt.

Beispielsweise wird der Datentyp des Arrays zu float, und der Datentyp der Variablen, die zum Speichern des ersten Elements des Arrays verwendet wird, wird ebenfalls zu float, und der Datentyp der Länge bleibt gleich.