const und für flüchtigen verliert Zeiger

Die Konstante und veränderlichen Änderung Schlüsselwort wie Zeiger behandelt werden.Das const-Schlüsselwort gibt an, dass der Zeiger nach der Initialisierung nicht geändert werden kann. der Zeiger wird von der Änderung danach geschützt.

Das volatile-Schlüsselwort gibt an, dass der Wert, der dem Namen zugeordnet ist, der durch folgende Aktionen außer der in der Benutzer-Anwendung geändert werden kann.Daher ist das volatile-Schlüsselwort zum Deklarieren von Objekten im freigegebenen Speicher nützlich, der durch die mehrere Prozesse oder globale Datenbereiche zugegriffen werden kann, die für die Kommunikation mit routinen für Unterbrechungen verwendet werden.

Wenn ein Name als volatiledeklariert ist, wird vom Compiler umladen der Wert aus dem Arbeitsspeicher, wenn er durch das Programm zugegriffen wird.Dies reduziert die möglichen Optimierung erheblich.Wenn sich der Zustand eines Objekts unerwartet ändern kann, ist dies die einzige Möglichkeit, vorhersagbare Programm Leistung sicherzustellen.

Zum Deklarieren der sich das Objekt durch den Zeiger als const verwenden, volatileoder eine Deklaration des Formulars:

const char *cpch;
volatile char *vpch;

Um den Wert des Zeigers, also die tatsächliche Adresse gespeichert oder als const — Zeiger im volatileanzugeben, verwenden Sie eine Deklaration des Formulars:

char * const pchc;
char * volatile pchv;

Die Programmiersprache C++ Zuweisungen, verhindert die Änderung eines Objekts oder des Zeigers ermöglichen, die als constdeklariert wurden.Diese Zuweisungen werden die Informationen zu entfernen, der das Objekt oder der Zeiger deklariert wurden. Dadurch verstoßen sie mit den Zweck der ursprünglichen Deklaration.Betrachten Sie hierzu folgende Deklarationen:

const char cch = 'A';
char ch = 'B';

Wenn die vorherigen Deklarationen von zwei Objekten (cchvom Typ const charund chvom Typ char), die folgende Deklaration/Initialisierungen sind gültig:

const char *pch1 = &cch;
const char *const pch4 = &cch;
const char *pch5 = &ch;
char *pch6 = &ch;
char *const pch7 = &ch;
const char *const pch8 = &ch;

Die folgende Deklaration/die Initialisierungen sind beschädigt.

char *pch2 = &cch;   // Error
char *const pch3 = &cch;   // Error

Die Deklaration von pch2 deklariert einen Zeiger, mit dem ein konstantes Objekt möglicherweise geändert und ist daher nicht zulässig.Die Deklaration von pch3 gibt an, dass pointer konstant ist, nicht das Objekt an. Der Name der Deklaration aus demselben Grund die pch2 Deklaration wird nicht zulässig sind nicht zulässig.

Die nächsten acht Zuweisungen veranschaulichen das Zuweisen von Zeigern und Ändern des Zeigerwerts für die vorherigen Deklarationen auf. fürs Erste wird angenommen, dass die Initialisierung für pch1 von pch8richtig war.

*pch1 = 'A';  // Error: object declared const
pch1 = &ch;   // OK: pointer not declared const
*pch2 = 'A';  // OK: normal pointer
pch2 = &ch;   // OK: normal pointer
*pch3 = 'A';  // OK: object not declared const
pch3 = &ch;   // Error: pointer declared const
*pch4 = 'A';  // Error: object declared const
pch4 = &ch;   // Error: pointer declared const

Der Zeiger, die als volatileoder als Kombination aus const und volatiledeklariert werden, befolgen Sie die gleichen Regeln.

Zeiger auf const-Objekte sind in Funktionsdeklarationen oft wie folgt:

errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource );

Die vorangehende Anweisung deklariert eine Funktion, strcpy_s, in der zwei der drei Argumente vom Typ pointer zu charsind.Da es sich bei den Argumenten als Wert und nicht durch einen Verweis übergeben werden, wird die Funktion frei sein, strDestination und strSource zu ändern, wenn strSource nicht als constdeklariert wurden.Die Deklaration von strSource als const der Aufrufer gewährleistet, dass strSource nicht von der aufgerufenen Funktion geändert werden kann.

Hinweis
Da es sich um eine Standardkonvertierung des Typnamens* zu constTypnamen *gibt, ist es zulässig, ein Argument des Typs char * zu strcpy_szu übergeben.Dies stellt die Umkehrung ist jedoch nicht der Fall. keine implizite Konvertierung existiert, um das const-Attribut aus einem Objekt oder von einem Zeiger zu entfernen.

Ein const Zeiger eines angegebenen Typs kann in einen Zeiger des gleichen Typs zugewiesen werden.Allerdings kann ein Zeiger, der nicht const ist, nicht zu einem const Zeiger zugewiesen werden.Im folgenden Code wird die richtige und falsche Zuweisungen an:

// const_pointer.cpp
int *const cpObject = 0;
int *pObject;

int main() {
pObject = cpObject;
cpObject = pObject;   // C3892
}

Im folgenden Beispiel wird veranschaulicht, wie ein Objekt als Konstante deklariert, wenn Sie einen Zeiger auf einen Zeiger auf ein Objekt verfügen.

// const_pointer2.cpp
struct X {
   X(int i) : m_i(i) { }
   int m_i;
};

int main() {
   // correct
   const X cx(10);
   const X * pcx = &cx;
   const X ** ppcx = &pcx;

   // also correct
   X const cx2(20);
   X const * pcx2 = &cx2;
   X const ** ppcx2 = &pcx2;
}

Siehe auch

Referenz

Zeiger