Unterschied zwischen Const Int und Int Const in C++

1. Unterschied zwischen const int und int const in C++
2. C++ Schlüsselwort const
3. const int und int const mit Variablen
4. const int und int const mit Zeigern
5. Verwenden Sie in C++ int * const
6. Verwenden Sie const int * in C++
7. Fazit

Die beliebtesten und kniffligsten Fragen jeder Programmiersprache sind diejenigen, bei denen kleine Änderungen einen großen Unterschied in der Ausführung des Programms und der Ausgabe machen.

In diesem Artikel werden wir diskutieren, ob const int dasselbe ist wie int const in C++ oder nicht.

Unterschied zwischen const int und int const in C++

Code:

int const a = 1000;
const int a = 1000;

Hier sind zwei Codezeilen, die fast gleich aussehen. Sind diese beiden Codezeilen jetzt gleich?

Bevor wir diese Frage beantworten, wollen wir uns noch einmal mit den Grundlagen des Schlüsselworts const von C++ befassen.

C++ Schlüsselwort const

Das Schlüsselwort const von C++ hilft dabei, bestimmte Dinge konstant zu halten. Das bedeutet, wenn Sie das Schlüsselwort const vor eine Variable, einen Zeiger oder eine Methode setzen, dann kann der Wert der Datenelemente dieser Variablen, Zeiger und Methoden nicht geändert werden, während das Programm ausgeführt wird.

Angenommen, wir versuchen, den Wert einer Variablen, eines Zeigers oder einer Methode zu ändern, die mit dem Schlüsselwort const initialisiert wird, was uns einen Fehler liefert.

Code:

#include <iostream>
using namespace std;

int main() {
  const int demo = 1;  // constant variable
  cout << demo;
  demo = 2  // changing the value of constant variable
         cout
         << demo;
  return 0;
}

Ausgabe:

In function 'int main()': error: assignment of read-only variable 'demo'
    9 |     demo = 2
    |     ~~~~~^~~

Im obigen Beispiel deklarieren wir eine const-Variable demo und weisen ihr den Wert 1 zu. Dann weisen wir derselben konstanten Variablen einen anderen Wert, 2, zu.

Dies führt zu einem Fehler, wie Sie in der Ausgabe sehen können.

Code:

#include <iostream>
using namespace std;

int main() {
  int demo = 1;
  cout << "The initial value is: " << demo << endl;

  // changing the value of the variable
  demo = 2;

  cout << "The changed value is: " << demo << endl;
  return 0;
}

Ausgabe:

The initial value is: 1
The changed value is: 2

Diesmal initialisieren wir die Variable demo nicht mit dem Schlüsselwort const. Daher können wir den Wert dieser Variablen ändern, ohne dass Fehler auftreten.

So funktioniert im Wesentlichen das Schlüsselwort const. Unter diesem Link erfahren Sie mehr über das Schlüsselwort const.

Kommen wir zurück zu der Frage, die wir beantworten mussten.

const int und int const mit Variablen

Die Standardmethode zum Anhängen von const an eine Variable in C++ besteht darin, dieses Schlüsselwort vor den Datentyp der Variablen zu setzen. Wenn wir es jedoch vor die Variable selbst setzen, dient es demselben Zweck und funktioniert ähnlich.

Das bedeutet, dass die folgenden Codezeilen äquivalent und korrekt sind.

const int demo = 1000;

int const demo = 1000;

Wenn Sie solche Erklärungen lesen, besteht der Trick darin, von rechts nach links zu gehen. Daher würde die erste Codezeile gelesen werden als - Demo ist eine konstante Ganzzahl.

Während die zweite Zeile gelesen wird als - Demo ist eine konstante Ganzzahl. Zweifellos bedeuten diese beiden Aussagen dasselbe.

Wir können dies anhand eines funktionierenden Beispiels überprüfen. In diesem folgenden Beispiel stellen wir das Schlüsselwort const vor den Datentyp, also int, und geben dann die Variable demo aus.

Code:

#include <iostream>
using namespace std;

int main() {
  const int demo = 1000;  // const keyword before the data type
  cout << demo;
}

Ausgabe:

1000

Versuchen wir dasselbe mit dem Schlüsselwort const vor der Variablen demo selbst.

#include <iostream>
using namespace std;

int main() {
  int const demo = 1000;  // const keyword before the variable itself
  cout << demo;
}

Ausgabe:

1000

Sehen Sie, wie diese Anweisungen auf die gleiche Weise funktionieren, ohne dass es zu Fehlern kommt. Wir können jede dieser Anweisungen verwenden, wenn wir eine konstante Variable deklarieren müssen.

Daraus können wir schließen, dass int const dasselbe ist wie const int, aber es gibt einen Haken. Dies gilt für Variablen, bis keine Zeiger mehr eingehen.

Bei Zeigern ändert sich die Bedeutung des Schlüsselworts const je nach Position. Lassen Sie uns diskutieren, wie das Schlüsselwort const mit Zeigern funktioniert.

const int und int const mit Zeigern

Die Verwendung des Schlüsselworts const mit Zeigern ist sehr einfach. Entweder können wir den Zeiger unveränderlich machen oder den Inhalt, der auf unveränderlich zeigt.

Sehen Sie sich die folgende Codezeile an. Der Zeiger demo ist ein konstanter Zeiger, dessen Wert nicht verändert werden kann.

Dies bedeutet, dass es nicht geändert werden kann, um auf einen anderen Wert oder eine andere Variable zu zeigen. Wir lesen dies von rechts nach links als - demo ist ein konstanter Zeiger auf eine Ganzzahl.

int* const demo = &anyvalue;

In diesem zweiten unten angegebenen Codestück können die Daten, auf die der Zeiger demo zeigt, jedoch nicht geändert werden. Wir lesen dies als - demo ist ein Zeiger auf eine ganze Zahl, die konstant ist.

const int *demo = &anyvalue;

Lassen Sie uns diese beiden Codezeilen anhand von Beispielen verstehen.

Verwenden Sie in C++ int * const

Wie oben erwähnt, bedeutet das Platzieren des Schlüsselworts const vor der Zeigervariablen, dass wir den Zeiger nicht so ändern können, dass er auf einen anderen Wert oder eine andere Variable zeigt. Dies kann anhand eines Beispiels vertieft werden.

Die folgenden Punkte fassen zusammen, was im unten angegebenen Code passiert.

1. Hier weisen wir zunächst der Pointer-Variablen *demo den Wert der Variablen one zu. Das bedeutet, dass der Pointer *demo auf die Variable one zeigt.
2. Beim Drucken des Werts der Variablen eins erhalten wir die Ausgabe als 1, während wir beim Drucken von demo die Adresse erhalten, auf die sie zeigt. Dies ist die Adresse der Variablen one.
3. Später weisen wir der gleichen Zeigervariable demo eine weitere Variable two zu und geben die Werte aus. Diesmal gibt der Zeiger eine andere Adresse zurück.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;
  int two = 2;
  int *demo = &one;  // demo pointer points to variable one

  cout << one << endl;
  cout << demo << endl;

  demo = &two;  // assigning the variable two to demo variable

  cout << two << endl;
  cout << demo << endl;

  return 0;
}

Ausgabe:

1
0x7ffc22e802a8
2
0x7ffc22e802ac

Sie können sehen, wie wir derselben Zeigervariablen verschiedene Variablen zuweisen können. Diese Änderung ist nicht möglich, wenn Sie das Schlüsselwort const vor die Zeigervariable setzen.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;
  int two = 2;
  int* const demo = &one;  // attach const keyword before the pointer variable

  cout << one << endl;
  cout << demo << endl;

  demo = &two;  // this assignment will now give an error

  cout << two << endl;
  cout << demo << endl;

  return 0;
}

Ausgabe:

In function 'int main()': error: assignment of read-only variable 'demo'
   13 |     demo = &two;
      |     ~~~~~^~~~~~

Beachten Sie, dass wir diesmal, da der deklarierte Zeiger konstant ist, ihm keine andere Variable zuweisen können. Somit erhalten wir einen Fehler.

Dies bedeutet int const, wenn es mit einem Zeiger verwendet wird.

Verwenden Sie const int * in C++

Wir wissen bereits, dass wir einen Zeiger verwenden können, um den Wert einer Variablen zu ändern. Dies wird im folgenden Beispiel gezeigt.

Die folgenden Punkte fassen zusammen, was in diesem Code passiert.

1. Wir weisen zuerst der Variablen one den Wert 1 zu und der Pointer *demo zeigt auf die Variable one.
2. Dann geben wir die Werte der Variablen one und des Zeigers *demo aus. Beide geben den Ausgang als 1 aus.
3. Später weisen wir der Pointer-Variablen *demo den Wert 2 zu.
4. Zuletzt geben wir die Werte der Variablen one und des Zeigers demo aus, aber diesmal geben beide die Ausgabe als 2 aus.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;  // variable one holds the value 1
  int *demo = &one;

  cout << one << endl;
  cout << *demo << endl;

  *demo = 2;  // assign the value 2 to variable demo

  cout << one << endl;
  cout << *demo << endl;
}

Ausgabe:

1
1
2
2

Sehen Sie, wie sich der Wert der Variablen mit Hilfe des Zeigers ändert, dem die Variable zugewiesen wurde. Wenn Sie nun das Schlüsselwort const vor dem Datentyp des Zeigers verwenden, ist diese Art der Veränderlichkeit nicht möglich.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;
  const int *demo = &one;  // attach const keyword before data type

  cout << one << endl;
  cout << *demo << endl;

  *demo = 2;  // this assignment will give an error now

  cout << one << endl;
  cout << *demo << endl;
}

Ausgabe:

In function 'int main()': error: assignment of read-only location '* demo'
   12 |     *demo = 2;
      |     ~~~~~~^~~

Beachten Sie, dass wir einen Fehler erhalten, wenn wir versuchen, den Wert der Variablen zu ändern, auf die der Zeiger zeigt. Das bedeutet const int , wenn es mit einem Zeiger verwendet wird.

Fazit

In diesem Artikel haben wir erfahren, wie sich const int und int const voneinander unterscheiden. Außerdem haben wir gesehen, wie sie im Kontext von Variablen und Zeigern funktionieren.

Wir haben auch gelernt, dass diese beiden Formate für einfache Variablen dasselbe bedeuten, sich die Bedeutung von Zeigern jedoch erheblich ändert. Wir haben dies anhand verschiedener Arbeitsbeispiele verstanden und sind auch die Grundlagen des Schlüsselworts const von C++ durchgegangen.