Fassen Sie den Inhalt zusammen, der sich auf const in C++ bezieht
Der von const modifizierte Typ ist ihm am nächsten, und der Rest ist das, was er modifiziert hat
1. Die Beziehung zwischen Konstante und Zeiger
1.1 Das Problem der erzwungenen Konvertierung von konstanter Konstante und Zeiger
①Wird einer Variablen eine konstante Variable zugewiesen, so wendet C++ beim Kompilieren das Substitutionsprinzip an und weist den Wert der konstanten Variablen direkt der Variablen zu.
Das folgende Beispielproblem (fügen Sie den Code in das Zeichenbrett ein):
Weisen Sie in der ersten Hauptfunktion, unserem Code, die konstante Variable a der Variablen b zu, dann wird beim Kompilieren von C++ a durch 10 ersetzt und dann b zugewiesen Abbildung oben, Dann wird ausgegeben: a = 10, b = 10, * p = 100.
Die Kompilierungsregeln von .c unterscheiden sich jedoch von denen von C++: .C weist den Wert nach der erzwungenen Konvertierung b zu, wenn also *p 100 wird, dann ist a auch 100, also ist b gleich dem Wert, der danach geändert wurde eine erzwungene Umwandlung 100 , die Endausgabe: a=100,b=100,*p=100.
Frage: Woher wissen Sie, ob unser Programm mit der C-Methode oder mit der C++-Methode kompiliert wurde?
Welche Methode zum Importieren über __cplusplus
: Welche Methode
zum Drucken:
②Permanenz entfernen und Änderung erzwingen
Erklärung: Permanenz der Variablen entfernen
1.2 Tiefes Verständnis
Das Verständnis von "Fähigkeit kann kontrahiert, aber nicht erweitert werden", welche der folgenden Sätze können zusammengestellt werden und können nicht zusammengestellt werden?
int a=10,b=20;
const int *p=&a;//这里的const修饰之后，p的指向可以改变，但是*P不能改变
//下面四句话中，s0，s3不可以编译通过，因为这两行会把*p的能力进行扩展
int *s0=p;
const int *s1=p;
int *const s2=p;
const int * const s3=p;
int a=10,b=20;
int* const p=&a;//这里的const修饰之后，p的指向不能进行改变，但是*p可以改变
//下面四句话都可以编译通过，因为p的指向被限制了，但是其他指针可以指向p，也可以指向其他的地址，并不会因为p的指向固定而被限制
int *s0=p;
const int *s1=p;
int * const s2=p;
const int * const s3=p;
2. Die Beziehung zwischen Konstante und Referenz
2.1 Grundlegende Konzepte:
Fähigkeit kann zum Beispiel kontrahiert werden:
int main()
{
int a=10;
int& b=a;
const int&c=a;
a+=100;//编译通过
b+=100;//编译通过
//c+=100;//编译出错，因为前面有const进行修饰，所以c不能改变
}
Die Fähigkeit kann nicht erweitert werden, zum Beispiel:
int main()
{
const int a=10;
//int& b=a;//这里编译不通过
}
2.2 Die Beziehung zwischen Pointer-Referenz und const
①Beispiel:
Für den Code im grünen Kästchen oben, wenn s=&b, zeigt p2 auch auf b, sodass der Wert von b 20 ist.
②Übung:
Für die folgenden Aussagen, welche sind kompilierbar und welche nicht?
(Die Antwort ist bereits im Bild unten gegeben)
2.3 Die Art der Zitate
①Erklärung:
Der Code vor der Kompilierung lautet wie folgt: Der Code nach der Kompilierung lautet wie folgt:
Unterschied zwischen Referenz und Zeiger?
Syntax: Referenz ist ein Alias für eine Variable (referenzsicher)
Assembly/Low-Level: Referenz ist äquivalent zu einem Zeiger, der selbst konstant ist
②Welche der folgenden Ausgaben x, y, z ist richtig?
Antwort: Nur x ist wahr.
Obwohl y auch 20 druckt, wird der Wert der lokalen Variablenadresse nicht gestört. Wenn die Adresse der lokalen Variablen vollständig zugewiesen und der lokalen Variablenadresse neu zugewiesen wird, ist das gedruckte y nicht mehr 20.
z gibt einen zufälligen Wert aus. weil cout die von funref zurückgegebene Stack-Frame-Space-Referenz stört, bevor die
Adresse der lokalen Variablen freigegeben wird, und diese Adresse wird freigegeben, um einen zufälligen Wert zu erhalten. (Die Adresse kann nicht aus dem ungültigen Leerzeichen abgerufen werden)
Zusammenfassung: Wie kann die Variable als Referenz zurückgegeben werden?
Diese Variable ist von der Lebensdauer der Funktion nicht betroffen
Globale Variablen
Statische lokale Variablen Per
Referenz eingegebene
Variablen Zum Beispiel:
2.4 Kann eine Funktion verwendet werden, um sowohl get als auch set zu implementieren?
//实现双向函数
class Object
{
private:
int value;
public:
Object(int x = 0) :value(x)
{
}
~Object()
{
}
void SetValue(int x)
{
value = x;
}
int GetValue()
{
return value;
}
// 使用一个函数实现 SetValue 和 GetValue() 函数的功能
int& Bidirectional_function()
{
return value;
}
const int& Bidirectional_function()const//常对象调用常方法
{
return value;
}
//上面两个成员方法是函数重载。因为虽然函数名称一样，形参个数一样，但是形参的类型不一样
};
void fun(const Object& obj)
{
const int& x = obj.Bidirectional_function();
}
int main()
{
Object obj(10);
int x = 0;
x = obj.Bidirectional_function();//获取成员变量的值
obj.Bidirectional_function () += 100;//改变成员变量的值
}
3. Die Beziehung zwischen Mitgliedsmethoden, die in Klassen und Konstanten definiert sind
class CGoods
{
private:
char Name[21];
int Amount;
float Price;
float Total_value;
public:
void RegisterGoods(char[],int,float);
void CountTotal(void);
void GetName(char[]);
int GetAmount(void);
float GetPrice(void);
float GetTotal_value(void);
}
①Wenn Sie für die obige Klasse const zu einer der Mitgliedsmethoden hinzufügen, dann ist diese Methode eine reguläre Methode, denn nachdem die Konstante eingefügt wurde, bedeutet dies, dass die Mitgliedsattribute in der Mitgliedsmethode des Objekts nicht wie folgt geändert werden können :
void CountTotal(void)const
②Wenn Sie den this-Zeiger nicht ändern möchten, müssen Sie wie folgt eine Konstante hinzufügen:
//为了和常方法的const进行区别，这里加上this指针,所以为了使得this指针不改变，给this前面加上const
//所以第一个const表示常方法，这个类的成员属性只能读，不能改
//第二个const表示这个this指针指向当前的对象，不能指向其他的对象
void CountTotal(const CGoods* const this)
③Fügen Sie const vor der Methode hinzu, um anzuzeigen, dass der zurückgegebene Wert konstant ist
const float GetPrice(void);
④Warum einige Mitgliedsmethoden zu regulären Methoden machen?
Grund: Sie können normale Objekte verwenden, um reguläre Methoden aufzurufen, und Sie können reguläre Objekte verwenden, um reguläre Methoden aufzurufen, sodass eine Funktion an einem breiteren Bereich von Stellen verwendet werden kann.