Mit const definierte Konstanten geben ihren Speicher frei, nachdem ihr Gültigkeitsbereich überschritten wurde, während mit static definierte statische Konstanten ihren Speicherplatz nach Ausführung der Funktion nicht freigeben.

static bedeutet statisch. Die statischen Memberfunktionen und statischen Membervariablen einer Klasse sind mit der Klasse verbunden, nicht mit bestimmten Objekten der Klasse. Selbst ohne ein bestimmtes Objekt können die statischen Memberfunktionen und Membervariablen der Klasse aufgerufen werden. Im Allgemeinen ist eine statische Funktion einer Klasse fast eine globale Funktion, mit der Ausnahme, dass ihr Gültigkeitsbereich auf die Datei beschränkt ist, die sie enthält.

In C++ können statische Membervariablen nicht innerhalb der Klasse initialisiert werden. Innerhalb der Klasse steht nur eine Deklaration; die Definition muss außerhalb des Klassendefinitionskörpers erfolgen, normalerweise initialisiert in der Implementierungsdatei der Klasse, wie z. B.:double Account::Rate = 2.25;

Das Schlüsselwort static kann nur in der Deklaration innerhalb des Klassendefinitionskörpers verwendet werden; bei der Definition kann es nicht als static gekennzeichnet werden.

In C++ können auch const-Membervariablen nicht bei der Klassendefinition initialisiert werden; sie können nur über die Initialisierungsliste des Konstruktors initialisiert werden, und es muss ein Konstruktor vorhanden sein.

Ein const-Datenelement ist nur während der Lebensdauer eines bestimmten Objekts konstant, für die gesamte Klasse jedoch variabel. Da eine Klasse mehrere Objekte erzeugen kann, können verschiedene Objekte unterschiedliche Werte für ihre const-Datenelemente haben. Daher können const-Datenelemente nicht in der Klassendeklaration initialisiert werden, weil der Compiler, wenn noch kein Objekt der Klasse erzeugt wurde, nicht weiß, welchen Wert das const-Datenelement hat.

Die Initialisierung von const-Datenmembern kann nur in der Initialisierungsliste des Konstruktors der Klasse erfolgen. Um eine Konstante festzulegen, die in der gesamten Klasse konstant ist, sollten Sie eine enum-Konstante in der Klasse oder static const verwenden.

class Test{ public: Test():a(0){} enum {size1=100,size2=200}; private: const int a;//Kann nur in der Initialisierungsliste des Konstruktors initialisiert werden static int b;//In der Implementierungsdatei der Klasse definieren und initialisieren conststatic int c;//Entspricht static const int c; }; int Test::b=0;//static-Membervariablen können nicht in der Initialisierungsliste des Konstruktors initialisiert werden, weil sie nicht zu einem bestimmten Objekt gehören. cosnt intTest::c=0;//Hinweis: Beim Zuweisen eines Werts an eine statische Membervariable wird der static-Modifizierer nicht benötigt, aber const muss hinzugefügt werden.

Der Hauptzweck von const-Memberfunktionen besteht darin, zu verhindern, dass Memberfunktionen den Inhalt des Objekts ändern. Das heißt, eine const-Memberfunktion kann die Werte von Membervariablen nicht ändern, aber sie kann auf Membervariablen zugreifen. Wenn eine Memberfunktion für ein const-Objekt aufgerufen wird, kann diese Funktion nur eine const-Memberfunktion sein.

Der Hauptzweck von static-Memberfunktionen besteht darin, als globale Funktionen innerhalb des Klassenbereichs zu dienen. Sie können nicht auf nicht-statische Datenmember der Klasse zugreifen. Statische Memberfunktionen einer Klasse besitzen keinen this-Zeiger, was zu Folgendem führt:

  • 1. Kann nicht direkt auf die nicht-statischen Membervariablen der Klasse zugreifen oder nicht-statische Memberfunktionen aufrufen.
  • 2. Können nicht als virtual deklariert werden.

Zur Initialisierung von static-, const-, static const- und const static-Mitgliedern

1. Initialisierung von const-Mitgliedern in einer Klasse:

Wenn man in einer Klasse ein const erstellt, kann man ihm keinen Anfangswert geben.

class foo{ public: foo():i(100){} private: const int i=100;//Fehler!!! }; //Oder auf diese Weise initialisieren foo::foo():i(100){}

2. Initialisierung von static-Mitgliedern in einer Klasse:

Statische Variablen in einer Klasse gehören zur Klasse, nicht zu einem bestimmten Objekt. Sie haben während der gesamten Ausführung des Programms nur eine einzige Kopie. Daher können sie nicht beim Definieren eines Objekts initialisiert werden; das heißt, sie können nicht mit einem Konstruktor initialisiert werden. Die korrekte Initialisierungsmethode ist:

data type class name::static data member name = value;
class foo{ public: foo(); private: staticint i; }; intfoo::i=20;

Dies zeigt:

  • 1. Die Initialisierung erfolgt außerhalb des Klassenkörpers, und static wird nicht davor gesetzt, um Verwechslungen mit gewöhnlichen static-Variablen oder -Objekten zu vermeiden.
  • 2. Fügen Sie bei der Initialisierung keine Zugriffsmodifizierer des Mitglieds wie private, public usw. hinzu.
3. Verwenden Sie bei der Initialisierung den Bereichsauflösungsoperator, um die Klasse anzugeben, zu der es gehört. Daher sind statische Datenelemente Elemente der Klasse, nicht Elemente eines Objekts.

3. Initialisierung von static const- und const static-Membern in einer Klasse

Diese beiden Schreibweisen haben denselben Effekt. Zur leichteren Merkbarkeit wird hier nur eine allgemeine Initialisierungsmethode erläutert:

class Test{ public: static const int mask1; conststatic int mask2; }; constTest::mask1=0xffff; constTest::mask2=0xffff; //Ihre Initialisierung unterscheidet sich nicht, obwohl das eine eine statische Konstante und das andere eine konstante statische ist. Statische werden im Bereich für globale Variablen gespeichert; tatsächlich ist das Endergebnis dasselbe. Verschiedene Compiler können sie unterschiedlich behandeln, aber das Endergebnis ist dasselbe.

Vollständiges Beispiel

Beispiel

#ifdef A_H_ #define A_H_ #include <iostream> usingnamespace std; class A{ public: A(int a); staticvoid print();//Statische Memberfunktion private: static int aa;//Deklaration eines statischen Datenelements staticconst int count;//Konstantes statisches Datenelement (kann im Konstruktor initialisiert werden) const int bb;//Konstantes Datenelement }; int A::aa=0;//Definition + Initialisierung eines statischen Members const int A::count=25;//Definition + Initialisierung eines statischen const-Members A::A(int a):bb(a){//Initialisierung eines konstanten Members aa+=1; } void A::print(){ cout<<"count="<<count<<endl; cout<<"aa="<<aa<<endl; } #endif void main(){ A a(10); A::print();//Zugriff auf eine statische Memberfunktion über die Klasse a.print();//Zugriff auf eine statische Memberfunktion über ein Objekt }

Initialisierungsort

Statische Member können nicht in der Klassendefinition initialisiert werden (außer bei int). Sie können nicht in der Header-Datei initialisiert werden.

Zum Beispiel wird, wenn myclass.h definiert ist, sie im Allgemeinen in myclass.cpp initialisiert.


Statische Member von C++-Klassen (static)

Statische Member werden vorgeschlagen, um das Problem der gemeinsamen Datennutzung zu lösen. Es gibt viele Wege, die gemeinsame Nutzung zu erreichen, z. B. das Festlegen globaler Variablen oder Objekte als eine Methode. Globale Variablen oder Objekte haben jedoch Einschränkungen. In diesem Kapitel diskutieren wir hauptsächlich die Verwendung statischer Member einer Klasse, um gemeinsame Datennutzung zu erreichen.

Statisches Datenelement

In einer Klasse können statische Member die gemeinsame Datennutzung zwischen mehreren Objekten erreichen, und die Verwendung statischer Datenelemente durchbricht nicht das Prinzip der Verbergung, wodurch Sicherheit gewährleistet wird. Daher sind statische Member Member, die von allen Objekten der Klasse gemeinsam genutzt werden, nicht Member eines bestimmten Objekts.

Die Verwendung statischer Datenelemente kann Speicher sparen, weil sie allen Objekten gemeinsam sind. Daher werden statische Datenelemente bei mehreren Objekten nur an einer Stelle gespeichert und von allen Objekten gemeinsam genutzt. Der Wert eines statischen Datenelements ist für jedes Objekt derselbe, aber sein Wert kann aktualisiert werden. Wenn der Wert des statischen Datenelements einmal aktualisiert wird, ist garantiert, dass alle Objekte auf denselben aktualisierten Wert zugreifen, was die Zeiteffizienz verbessert.

Die Verwendung und die zu beachtenden Punkte für statische Datenelemente sind wie folgt:

1. Wenn Sie ein statisches Datenelement definieren oder deklarieren, stellen Sie das Schlüsselwort static voran.

2. Die Initialisierung statischer Member unterscheidet sich von der Initialisierung gewöhnlicher Datenelemente. Das Format zum Initialisieren statischer Datenelemente ist wie folgt:

 
<data type><class name>::<static data member name>=<value>

Dies zeigt:

  • (1) Die Initialisierung erfolgt außerhalb des Klassenkörpers, und static wird nicht vorangestellt, um Verwechslungen mit gewöhnlichen statischen Variablen oder Objekten zu vermeiden.
  • (2) Fügen Sie beim Initialisieren keine Zugriffssteuerungsbezeichner des Members wie private, public usw. hinzu.
  • (3) Verwenden Sie beim Initialisieren den Bereichsauflösungsoperator, um die Klasse anzugeben, zu der es gehört. Daher sind statische Datenelemente Member der Klasse, nicht Member eines Objekts.

3. Statische Datenmember werden statisch gespeichert; sie haben eine statische Lebensdauer und müssen initialisiert werden.

4. Beim Referenzieren eines statischen Datenmembers verwenden Sie das folgende Format:

<class name>::<static member name>

Wenn die Zugriffsberechtigung des statischen Datenmembers dies zulässt (d. h., es ist ein öffentliches Member), kann das statische Datenmember im Programm mit dem obigen Format referenziert werden.

Das folgende Beispiel veranschaulicht die Anwendung statischer Datenmember:

Beispiel

#include … class Myclass{ public: Myclass(int a, int b, int c); void GetNumber(); void GetSum(); private: int A, B, C; static int Sum; }; int Myclass::Sum = 0; Myclass::Myclass(int a, int b, int c){ A = a; B = b; C = c; Sum += A+B+C; } void Myclass::GetNumber(){ cout<<"Number="<<a<<","<<b<<","<<c<<endl; } void Myclass::GetSum(){ cout<<"Sum="<<sum<<endl; } void main(){ Myclass M(3, 7, 10),N(14, 9, 11); M.GetNumber(); N.GetNumber(); M.GetSum(); N.GetSum(); }

Aus der Ausgabe ist ersichtlich, dass der Wert von Sum für Objekt M und Objekt N gleich ist. Das liegt daran, dass beim Initialisieren von Objekt M die Werte der drei int-Datenelemente von Objekt M summiert und Sum zugewiesen werden, sodass Sum diesen Wert speichert. Beim Initialisieren von Objekt N werden die Werte der drei int-Datenelemente von Objekt N summiert und dann zum vorhandenen Wert von Sum addiert, sodass Sum den neuen Wert speichert. Daher ist der Wert, auf den entweder über Objekt M oder über Objekt N verwiesen wird, derselbe, nämlich 54.

Statische Memberfunktion

Wie statische Datenmember gehören statische Memberfunktionen zu den statischen Membern der Klasse; sie sind keine Objektmember. Daher erfordert das Referenzieren statischer Member nicht die Verwendung eines Objektnamens.

In der Implementierung einer statischen Memberfunktion können nicht-statische, in der Klasse deklarierte Member nicht direkt referenziert werden, aber statische, in der Klasse deklarierte Member können referenziert werden. Wenn eine statische Memberfunktion nicht-statische Member referenzieren muss, kann sie dies über ein Objekt tun. Das folgende Beispiel veranschaulicht dies.

Beispiel

#include … class M{ public: M(int a){ A=a; B+=a; } static void f1(M m); private: int A; static int B; }; void M::f1(M m) { cout<<"A="<<m.a<<endl; cout<<"B="<<b<<endl; } int M::B=0; void main() { M P(5),Q(10); M::f1(P); //Beim Aufruf ist kein Objektname erforderlich M::f1(Q); }

Leser können das Ergebnis selbst analysieren. Es ist zu erkennen, dass der Aufruf einer statischen Memberfunktion das folgende Format verwendet:

  
<class name>::<static member function name>(<parameter list>);

Initialisierungsmethoden für verschiedene Typen von Membervariablen in C++

Verschiedene Typen von Membern in C++ haben unterschiedliche Initialisierungsmethoden, je nachdem, ob sie static oder const sind. Die Syntax von Java ist nicht so kompliziert; kein Wunder, dass so viele Leute Java lernen. Früher wurde mir diese Frage in einem Interview gestellt und ich konnte sie nicht beantworten. Beim Schreiben von Code habe ich es oft vermasselt. Hier habe ich ein Buch durchgesehen und es zusammengefasst.

//-----------------Test.h---------------------------- #pragma once class Test { private : int var1; // int var11= 4; inkorrekte Initialisierungsmethode const int var2 ; // const int var22 =22222; inkorrekte Initialisierungsmethode static int var3; // static int var3333=33333; Fehler: Nur statische const int-Member können durch direkte Zuweisung initialisiert werden static const int var4=4444; // Korrekt, statische const-Member können direkt initialisiert werden static const int var44; public: Test(void); ~Test(void); }; //--------------------Test.cpp----------------------------------- #include ".\test.h" int Test::var3 = 3333333; // Korrekte Initialisierungsmethode für statische Member // int Test::var1 = 11111;; Fehler: Nur statische Member können initialisiert werden // int Test::var2 = 22222; Fehler // int Test::var44 = 44444; // Falsche Methode, führt zu einem Redefinitionsfehler Test::Test(void):var1(11111),var2(22222)Korrekte Initialisierungsmethode//var3(33333) kann hier nicht initialisiert werden { var1 =11111; // Korrekt, gewöhnliche Variablen können hier ebenfalls initialisiert werden //var2 = 222222; Fehler, weil einer Konstanten nichts zugewiesen werden kann; sie kann nur im "Konstruktor-Initialisierer (Konstruktor-Initialisierungsliste)" initialisiert werden var3 =44444; // Diese Zuweisung ist korrekt, aber da alle Objekte dasselbe statische Member teilen, wirkt sie sich auf andere aus; das kann kaum als Initialisierung bezeichnet werden } Test::~Test(void){} //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Einige Membervariablen haben spezielle Datentypen, und ihre Initialisierungsmethoden unterscheiden sich auch von Membervariablen gewöhnlicher Datentypen. Zu diesen speziellen Typen von Membervariablen gehören:

  • a. Konstante Membervariablen
  • b. Referenz-Membervariablen
  • c. Statische Membervariablen
  • d. Integrale statische konstante Membervariablen
  • e. Nicht-integrale statische konstante Membervariablen

Für konstante Membervariablen und Referenz-Membervariablen muss die Initialisierung über die Initialisierungsliste des Konstruktors erfolgen. Das Zuweisen von Werten zu konstanten Membervariablen und Referenz-Membervariablen innerhalb des Konstruktorkörpers ist nicht möglich.

Die Initialisierung statischer Membervariablen ist ebenfalls recht speziell.

Siehe den folgenden Code und seine Kommentare:

// Initialisierung einer speziellen Daten-Membervariable #include <iostream> using namespace std; class BClass { public: BClass() : i(1),ci(2), ri(i) // Bei konstanten Membervariablen und Referenz-Membervariablen muss die Initialisierung über die parametrisierte Liste erfolgen. Das Zuweisen von Werten innerhalb des Konstruktorkörpers ist nicht möglich. { // Normale Membervariable } voidprint_values() { cout<< "i =\t" << i << endl; cout<< "ci =\t" << ci << endl; cout<< "ri =\t" << ri << endl; cout<< "si =\t" << si << endl; cout<< "csi =\t" << csi << endl; cout<< "csi2 =\t" << csi2 << endl; cout<< "csd =\t" << csd << private; } inti: // Konstante Mitgliedsvariable; // Constant member variable constint ci; // Referenz-Mitgliedsvariable int&ri; // Statische Mitgliedsvariable staticint si; //staticint si2 = 100; // Fehler: Nur statische konstante Mitgliedsvariablen können auf diese Weise initialisiert werden // Statische konstante Mitgliedsvariable staticconst int csi; // Initialisierung einer statischen konstanten Mitgliedsvariable (Integraltyp) (1) staticconst int csi2 = 100; // Statische konstante Mitgliedsvariable (Nicht-Integraltyp) staticconst double csd; //staticconst double csd2 = 99.9; // Fehler: Nur statische konstante integrale Datenelemente können innerhalb der Klasse initialisiert werden // Initialisierung einer statischen Membervariable (integraler Typ) }; // Initialisierung einer statischen konstanten Membervariable (integraler Typ) int BClass::si = 0; // Initialisierung einer statischen konstanten Membervariable (nicht-integraler Typ) const int BClass::csi = 1; // Bei der Initialisierung von csi2 in (1) ist gemäß Stanley B. Lippman die folgende Zeile erforderlich. const double BClass::csd = 99.9; // In VC2003 führt das Vorhandensein der folgenden Zeile jedoch zu einem Fehler, während die folgende Zeile in VC2005 optional ist; dies hängt vom Compiler ab. C++: Zusammenfassung statischer Member, C++, static const int BClass::csi2; int main(void) { BClassb_class; b_class.print_values(); return0; }

C++: Zusammenfassung statischer Member, C++, static

Danach habe ich tief darüber nachgedacht und beschlossen, die Kernpunkte zu statischen Klassenelementen gründlich zusammenzufassen, damit ich in zukünftigen Interviews bei solchen Themen nicht passiv bin.

Statische Klassenelemente umfassen zwei Teile: statische Datenelemente und statische Memberfunktionen.

Statische Datenelemente

Statisches Datenelement

1. Definition statischer Datenelemente.

Statische Datenelemente sind eigentlich globale Variablen im Klassenbereich. Daher sollte die Definition (Initialisierung) statischer Datenelemente nicht in Header-Dateien platziert werden. (Deklaration vs. Definition (Initialisierung)) Ihre Definitionsweise ist dieselbe wie bei globalen Variablen. Beispiel:

Datei

xxx.h// Deklaration. Standard-C++ unterstützt die Initialisierung integraler Typen im Klassenrumpf, aber VC6 nicht.class base{ private: static const int _i;File }; xxx.cpp// Die Definition (Initialisierung) wird nicht durch die Zugriffsbeschränkungen von private und protected eingeschränkt.const int base::_i=10;Hinweis:

Versuchen Sie nicht, statische Datenelemente in Header-Dateien zu definieren (zu initialisieren). In den meisten Fällen führt dies zu Fehlern wie einer Neudefinition. Selbst wenn Sieoder#ifndef #define #endifhinzufügen, wird es trotzdem nicht funktionieren.#pragma once2. Statische Datenelemente werden von allen Objekten der Klasse gemeinsam genutzt, einschließlich der Objekte abgeleiteter Klassen dieser Klasse. Das heißt, Objekte abgeleiteter Klassen und Objekte der Basisklasse teilen sich die statischen Datenelemente der Basisklasse. Beispiel:

// Deklaration

class base{ public : static int _num;// Tatsächliche Definition des statischen Datenelements }; int base::_num=0;// Das Ergebnis ist 1,2; daran ist zu erkennen, dass die abgeleitete Klasse und die Basisklasse sich ein statisches Datenelement teilen. class derived:public base{ }; main() { base a; derived b; a._num++; cout<<"Basisklasse statische Daten number_num ist"<<a._num<<endl; b._num++; cout<<"abgeleitete Klasse statische Datennummer _num ist"<<b._num<<endl; } 3. Statische Datenelemente können als Standardargumente von Memberfunktionen verwendet werden, während gewöhnliche Datenelemente dies nicht können. Beispiel:

// Korrekt, _staticVar ist ein statisches Datenelement

class base{ public : static int _staticVar; int _var; void foo1(int i=_staticVar);// Fehler, _var ist ein gewöhnliches Datenelement void foo2(int i=_var);4. Der Typ eines statischen Datenelements kann der Typ seiner eigenen Klasse sein, während ein gewöhnliches Datenelement dies nicht kann. Ein gewöhnliches Datenelement kann nur als Zeiger oder Referenz auf den Typ seiner eigenen Klasse deklariert werden. Beispiel: };

// Korrekt, statisches Datenelement

class base{ public : static base_object1;// Fehler base _object2;// Richtig, Zeiger base *pObject;// Richtig, Referenz base &mObject;5. Ich weiß nicht, ob diese Eigenschaft zum Standard-C++ gehört oder eine VC6-spezifische Eigenschaft ist. };

Der Wert eines statischen Datenmembers kann in einer const-Memberfunktion legal geändert werden. Beispiel:

// const-Memberfunktion

class base{ public: base(){ _i=0; _val=0; } mutable int _i; static int _staticVal; int _val; void test() const{// Richtig, veränderliches Datenmember _i++;// Richtig, statisches Datenmember _staticVal++;// Fehler _val++;Statische Memberfunktionen } }; int base::_staticVal=0;

Statische Memberfunktion

1. Die Adresse einer statischen Memberfunktion kann in einem gewöhnlichen Funktionszeiger gespeichert werden, während die Adresse einer gewöhnlichen Memberfunktion in einem Klassen-Memberfunktionszeiger gespeichert werden muss. Beispiel:

// Gewöhnlicher Funktionszeiger

class base{ static int func1(); int func2(); }; int (*pf1)()=&base::func1;// Memberfunktionszeiger int (base::*pf2)()=&base::func2;2. Statische Memberfunktionen können keine nicht-statischen Member der Klasse aufrufen, weil statische Memberfunktionen keinen this-Zeiger enthalten.

3. Statische Memberfunktionen können nicht gleichzeitig als virtual-, const- oder volatile-Funktionen deklariert werden. Beispiel:

// Fehler

class base{ virtual static void func1();// Fehler static void func2() const;// Fehler static void func3() volatile;Der letzte Punkt ist, dass auf statische Member unabhängig zugegriffen werden kann, das heißt, auf sie kann zugegriffen werden, ohne eine Objektinstanz zu erzeugen. };

Autor: SDMrFeng

Original: https://blog.csdn.net/tobefxz/article/details/14109697

Pycharm: Importieren von Python-Paketen, Modulen