In diesem Artikel geht es um Zeigerarithmetik in C++. Zeiger sind Variablen, die die Speicheradresse der Daten speichern. Zeigerarithmetik ist ein leistungsstarkes Markenzeichen in der Welt der Programmiersprache C++, das es uns ermöglicht, mit verschiedenen arithmetischen Operationen umzugehen, bei denen Addition, Multiplikation, Division, Inkrementierung, Dekrementierung und Subtraktion einen Zeiger zum Entwickeln der neuen Speicheradresse in unseren Speicherpuffern beinhalten . Eine Zeigerarithmetik erstellt auf einfache Weise die dynamische Speicherzuweisung. In diesem C++-Artikel erfahren Sie, wie Sie die Speicheradresse mithilfe von Zeigern auf unterschiedliche Weise manipulieren können, und stellen entsprechende Richtlinien und Beispiele bereit.
Szenario 1: Zeiger führt die Inkrementierungs- und Dekrementierungsoperationen aus
Hier lernen wir die Zeigermanipulation kennen, um unterschiedliche Speicheradressen zu erzeugen, die unterschiedliche Zwecke haben. Die inkrementierenden und dekrementierenden Zeiger sind auch die Hebelwirkung der Zeigerarithmetik, die die Adresse um den Faktor eins multipliziert mit der Größe des Datentyps, auf den sie zeigen, erhöht oder verringert. Der Codeausschnitt zu diesem Szenario ist im Folgenden beigefügt:
#include
Verwenden des Namensraums std;
const int Arr_Max = 5 ;
int main ( ) {
int wo [ Arr_Max ] = { zwanzig , 150 , 270 } ;
int * ptr; // erklären Zeiger
ptr = var;
für ( int i = 0 ; ich < Arr_Max; i++ ) {
std::cout << „Speicheradresse des Elements ist: [“ << ich << '] = ' ;
std::cout << ptr << endl;
cout << „Wert für die Adresse ist [“ << ich << '] = ' ;
cout << * ptr << endl;
std::cout << „Zeiger erfolgreich erhöht“ << endl;
ptr++;
}
std::cout << „Zeigeradresse vor Dekrementierung“ << ptr << endl;
ptr--;
std::cout << „Zeigeradresse nach Dekrementierung“ << ptr << endl;
zurückkehren 0 ;
}
Hier definieren wir gleich zu Beginn eine erforderliche Bibliothek im Code: „
Wir übergeben das Array an den Zeiger, um auf die Adresse zuzugreifen. Wie wir alle wissen, enthalten Arrays immer mehrere Elemente an unterschiedlichen Orten. Wir brauchten also eine Schleife mit dem „help“-Zeiger, um auf jedes Element eines Arrays zuzugreifen. Jedes Mal, wenn die Schleife ausgeführt wird, erhalten wir die Speicheradresse und die Werte für diese Adresse mithilfe des Zeigerarithmetik-Inkrementierungsoperators „ptr++“, der die Speicheradresse zur nächsten Adresse des Speichers verschiebt. Der Schleifenausführungszyklus hängt von der Größe eines Arrays ab. Außerhalb der Schleife möchten wir den Zeiger auf die vorherige Speicheradresse zurückbringen, indem wir einfach den Dekrementzeiger „ptr- -“ verwenden.
Führen Sie diesen Code aus, indem Sie auf die Option „Ausführen“ > „Kompilieren und Ausführen“ klicken. Sie erhalten die folgende Ausgabe:
Hoffentlich ist diese Ausgabe leicht verständlich. Die Speicheradresse und der Wert werden geändert. Das Verschieben des Zeigers von einer Stelle aus ist nur mit der Inkrementzeigerarithmetik in C++ möglich.
Szenario 2: Subtrahieren zweier Zeiger in C++
In diesem Szenario lernen wir, wie man in C++ zwei oder mehr Zeiger subtrahiert. Alle arithmetischen Operationen, bei denen die Subtraktion erfolgt, sind lebenswichtige Prozesse, da wir nur dann zwei Zeiger gleichzeitig subtrahieren können, wenn sie denselben Datentyp haben.
Die anderen Operationen wie Addition, Multiplikation und Division sind im Zeiger nicht möglich, da sie bei der Speicheradressierung keinen Sinn ergeben. Der Codeausschnitt ist im Folgenden angehängt:
#includeint main ( ) {
Er winkt [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Dazu [ 3 ] ; // Zeiger auf das dritte Element ( 42 )
int * ptrr2 = & Dazu [ 6 ] ; // Zeiger auf das sechste Element ( 89 )
ptrdiff_t ptrsubtract = ptrr2 - ptrr1;
std::cout << „Der Unterschied zwischen diesen Adressen ist:“ << ptrsubtract << „Elemente“ << std::endl;
zurückkehren 0 ;
}
Die Subtraktionsoperation ermittelt den Unterschied zwischen den Speicheradressen in C++. In der Hauptfunktion nehmen wir ein Array, das verschiedene Werte an verschiedenen Indizes enthält. In einem Array hat jeder Index einen anderen Speicherort. Den Unterschied zwischen zwei Zeigern können wir nur mit Hilfe einer Zeigerarithmetik ermitteln. Hier verwenden wir einen speziellen Zeigertyp „ptrdiff_t“, der verwendet werden muss, um die Unterschiede zwischen zwei oder mehr Zeigern in C++ zu finden.
Die Ausgabe dieses Codes ist im Folgenden beigefügt:
Der Unterschied zwischen diesen Adressen liegt im Element Schraubstock, der 3 beträgt.
Szenario 3: Vergleichen Sie zwei oder mehr Zeiger in C++
In diesem Szenario lernen wir, wie man die verschiedenen Zeiger in C++ mit verschiedenen relationalen Operatoren wie „==“, „<=“, „>=“, „<“, „>“ vergleicht. Wir können die Zeiger nur vergleichen, wenn sie auf die Adresse von Elementen desselben Arrays zeigen. Denken Sie daran, dass der Vergleich zweier Zeiger mit unterschiedlichen Typen zu undefiniertem Verhalten führen kann. Der Codeausschnitt, der sich auf den Zeigervergleich bezieht, wird im Folgenden erwähnt:
#includeVerwenden des Namensraums std;
int main ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , elf , 14 , 16 , 18 , zwanzig , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
Wenn ( ptr1 ==ptr2 )
{
std::cout << „Zeiger sind gleich“ << endl;
}
anders Wenn ( ptr3 < =ptr4 )
{
std::cout << „ptr3 ist kleiner oder gleich ptr4“ << endl ;;
}
anders
{
std::cout << „Zeiger werden zu keinem Zeitpunkt verglichen“ << endl;
}
zurückkehren 0 ;
}
Hier nehmen wir ein Array mit 10 Elementen. Wir deklarieren vier Zeiger, die auf einen anderen Index des Arrays zeigen. Anschließend vergleichen wir diese vier Zeiger unter verschiedenen Bedingungen, wie im angegebenen Code dargestellt. Überprüfen Sie in der „if“-Bedingung, ob der „ptr1“-Zeiger gleich dem „ptr2“-Zeiger ist, und geben Sie dann die „Zeiger sind gleich“ aus. Wenn wir mehrere Bedingungen haben, verwenden wir die „else if“-Bedingung, um zu prüfen, ob der „ptr3“-Zeiger kleiner als gleich dem „ptr4“-Zeiger ist. Klicken Sie anschließend auf Ausführen > Kompilieren und ausführen Möglichkeit.
Die Ausgabe dieses Codes ist im Folgenden beigefügt:
Es zeigt eine gültige Bedingung auf dem Konsolenbildschirm an und beendet die Kompilierung. Der Zeiger „ptr3“ enthält einen Wert, der kleiner oder gleich dem Zeigerwert „ptr4“ ist.
Szenario 4: Zeigen Sie eine ungerade Zahl mit Zeigerarithmetik an
Hier sehen wir, wie wir den Speicher für ein Array einer Ganzzahl dynamisch zuweisen können. Der Codeausschnitt zu diesem Fall ist im Folgenden aufgeführt:
#includeint main ( ) {
int Zahlen [ ] = { 1 , 12 , 33 , 24 , fünfzehn , 776 , 71 , 18 , 29 , fünfzig } ;
int * ptrr = Zahlen;
std::cout << „Ungerade Zahlen in den Arrays:“ ;
für ( int i = 0 ; ich < 10 ; ++i ) {
Wenn ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
zurückkehren 0 ;
}
In der Hauptfunktion nehmen wir ein Array, das 10 Elemente enthält. Wir benötigen einen Zeiger, der auf alle Elemente im Array zeigt, um die ungerade Zahl im Array zu überprüfen. Überprüfen Sie in der „for“-Schleife die ungerade Zahl, indem Sie das aktuelle Element eines Arrays dividieren. Der Zeigerzähler wird erhöht, nachdem ein Element eines Arrays überprüft wurde.
Nach der Ausführung des Codes wird die Ausgabe auf dem Konsolenbildschirm wie folgt angezeigt:
Auf diese Weise können wir die ungeraden Zahlen mithilfe der Zeigerarithmetik auf dem Konsolenbildschirm anzeigen.
Abschluss
Wir kommen hier zu dem Schluss, dass die Zeigerarithmetik das effektivste Werkzeug ist, das verschiedene Operationen in C++ ausführt. Stellen Sie sicher, dass der Zeiger den Wert eines Arrays mit demselben Datentyp erhöht oder verringert. Mit Hilfe der Zeigerarithmetik in der Programmiersprache C++ können wir die Werte eines Arrays anhand ihrer Speicheradressen vergleichen. Mit Hilfe der Zeigerarithmetik können wir das Array durchlaufen und den Speicher einfach verwalten.