this和static和const关键字

1. this指针

1.1 基本认识

C++中成员函数的特性，在类的非静态成员函数中都会存在一个this指针，来指向当前类，它是隐式的不可见的，是作为函数的第一个参数可以通过this指针来解决二义性的问题

是的，this指针是与类的实例相关联的。在C++中，this指针是一个指向当前对象的指针，它在类的成员函数内部自动存在。它允许在类的成员函数中引用当前对象的成员变量和成员函数。当你调用一个类的成员函数时，编译器会隐式传递一个指向当前对象的this指针给该成员函数。这使得成员函数可以访问和操作当前对象的成员。

this指针原型：
	类名    *   const   this ； //this指针的原型
例如：
	People  *  const  this；

1.2 将this指针作为函数返回值使用：

格式：

类名     &  函数名 （[参数列表]）

{

//函数具体实现

return   *this;   //通过该函数将当前对象进行返回

}

main6.cpp

#include "iostream"
using namespace std;

//this指针
class People
{
public:
	People(int a)//构造函数
	{
		this->a = a;
	}
	//成员函数
	void print()
	{
		cout << "a=" << this->a << endl;
		cout << "hello world" << endl;
	}

	//得到对象
	People& get_duiXiang()
	{
		this->a = 60;
		return *this;
	}

private:
	int a = 10;
};


int main()
{
	//直接调用对象输出
	People people(10);
	people.print();
	cout << endl;

	//使用this 返回获得对象，输出
	People p2 = people.get_duiXiang();
	p2.print();
	return 0;
}

2. static关键字

重点

它们不是与特定对象相关联的，而是与整个类相关联的，当static用于类的成员变量时，它表明这个变量是与整个类相关联，而不是与类的每个实例关联。

因为C++编译器必须确保只有一个唯一的静态成员变量存在，而不是为每个类的实例都有一个副本

C++提供的static关键字主要应用于类的成员，对于不是类的成员与C语言的作用是类似

对于类的静态成员讲，它是类的所有对象共享一份，它不是某个对象所特有的

2.1 static声明成员变量

2.1.1 静态成员变量初始化细节

用static声明的成员变量是存储在静态全局区，即全局变量

在C++中不能直接对静态成员变量进行初始化，在类外对它进行初始化

变量的初始化
类外初始化格式：
	类型   类名  ：：  变量名  =  初始值； //在类外初始化
例如：
	int   People ::  number = 10;   //在类外初始化


static声明静态成员函数
格式：
	static   返回值类型   函数名 （参数列表）
	{
		
	}
例如：
	static  int  get_value()
	{

	}

详解

在C++中，静态成员变量（使用static关键字修饰的成员变量）是类的成员，而不是类的实例成员。因此，它们不是与特定对象相关联的，而是与整个类相关联的。由于静态成员变量不属于特定对象，不能在类的内部初始化它们。

相反，你需要在类的外部（通常是在源文件中）对静态成员变量进行初始化。这是因为C++编译器必须确保只有一个唯一的静态成员变量存在，而不是为每个类的实例都有一个副本。

通常，静态成员变量的初始化会在源文件中进行，如下所示：

main5.cpp

//static 修饰的成员变量的初始化
class MyClass {
public:
	static int staticVar;
};

// 在类的外部初始化静态成员变量
int MyClass::staticVar = 42;

int main() {
	cout << MyClass::staticVar << endl;
	return 0;
}

2.2 类的静态成员的访问方式及其特性

2.2.1 可以通过类的对象进行访问

例如：

People people;

people.function（）；//这种方式访问

2.2.2 可以通过类进行访问

符号：“  ：：  ”

格式：

类名  ：： 静态成员名 ；

例如：

People  ::   function（）；

main5.cpp

//static关键字，成员的访问方式
class People1
{
public:

	void get_value()//非静态成员函数
	{
		cout << "非静态成员函数访问非静态成员变量a=" << this->a << endl;
		get_static_value();// 非 静态成员函数 可以 访问 静态成员函数
		this->a = 100;
		cout << "非静态成员函数访问变量a=" << this->a << endl;
	}

	static void get_static_value()//静态成员函数
	{
		cout << "静态成员函数" << endl;
		//cout << "非静态成员变量a=" << a << endl; //静态成员函数 不可以 访问 非静态成员变量
		cout << "静态成员变量b=" << b << endl; //静态成员函数 可以 访问 静态成员变量
		b = 100;//修改静态成员的值
		cout << "静态成员变量b=" << b << endl; //静态成员函数 可以 访问 静态成员变量
	}


	int a = 10;
	static int b;//类中定义了静态成员变量

};
int People1::b = 50;//在类的外部初始化静态成员变量


int main()
{
	People1::get_static_value(); //使用 ：： 访问静态成员函数
	cout << "静态成员变量b=" << People1::b << endl;
	cout << endl;

	//以下是研究静态成员的一些特性
	People1 people1;
	//观察以下两次打印非静态的a地址变了，而静态的b虽然对象不同但是地址还是一样，说明静态成员只针对类说话 而不针对 对象
	cout << "变量a的地址：" << &people1.a << endl;//变量a的地址：00000058B67AFB04
	cout << "变量b的地址：" << &people1.b << endl; //变量b的地址：00007FF7D0D6E000
	cout << endl;
	People1 people2;
	cout << "变量a的地址：" << &people2.a << endl;//变量a的地址：00000058B67AFB04
	cout << "变量b的地址：" << &people2.b << endl; //变量b的地址：00007FF7D0D6E000

	return 0;
}

2.3 静态函数的注意事项知识点（面试高频）：

2.3.1 静态成员函数中是否有this指针？

答案：没有

为什么？

我的回答

因为静态成员存存储在静态全局区，可以理解为跟类都不在一个地方存储，而this又是针对类的实列，static只与类本身关联，所以静态成员函数中不可能有this指针

专业回答

在C++中，静态成员函数没有隐式的 this 指针。这是因为静态成员函数是与类本身关联，而不是与类的实例（对象）关联的。this 指针是用于指向调用成员函数的对象的指针，但是在静态成员函数中，并没有特定的实例对象，因此没有 this 指针。

2.3.2 静态成员函数调用非静态成员？静态成员？

答案：不能调用非静态成员，可以调用静态成员

专业回答

静态成员函数可以调用静态成员，但不能直接访问非静态成员，这是因为它们都属于类而不是特定的对象实例，静态成员函数不依赖于特定的对象实例，非静态成员变量和非静态成员函数在静态成员函数内部是不可访问的，因为它们需要一个具体的对象实例来操作。

main5.cpp

//静态成员不能调用非静态成员，可以调用静态成员
class MyClass {
public:
    static int staticVar;  // 静态成员变量

    int regularVar;        // 非静态成员变量

    MyClass() : regularVar(60) //构造
    {

    }

    //静态函数
    static void staticFunction() {
        // 静态成员函数可以调用静态成员变量
        cout << "静态成员函数 可以调用 静态成员变量: " << staticVar << endl;

        // 但不能直接访问非静态成员变量
         //std::cout << "非 静态成员变量 " << regularVar << std::endl;
    }

    //非 静态成员函数
    void regularFunction() {
        // 非静态成员函数可以调用静态成员变量和非静态成员变量
        std::cout << "非静态成员函数 可以调用 静态成员变量: " << staticVar << std::endl;
        std::cout << "非静态成员函数 可以调用 非静态成员变量 " << regularVar << std::endl;

        cout << endl;
        // 可以调用静态成员函数
        staticFunction();
    }
};

// 静态成员变量的初始化
int MyClass::staticVar = 42;

int main() {

    MyClass obj;

    // 调用静态成员函数
    MyClass::staticFunction();

    // 调用非静态成员函数
    obj.regularFunction();

    return 0;
}

2.3.3非静态成员函数调用非静态成员？静态成员？

非静态成员函数可以调用非静态成员和静态成员，因为非静态成员函数是与类的实例相关联的，可以访问该实例的所有成员（包括非静态和静态成员）。

3. const关键字

用const修饰类的成员，就表示成员是不可变，例如：修饰成员变量 , 变量是常量属性

C++中用const修饰类的成员函数，表示成员函数是对类的成员以只读的性质（保护数据成员）

格式：
	函数返回值类型     函数名  （[参数列表]） const
	{

	}
例如：
	void   function（） const
	{

	}

main7.cpp

#include <iostream>
using namespace std;

//用const修饰类的成员函数，表示成员函数是对类的成员以只读的性质（保护数据成员）
class MyClass {
public:
    //构造
    MyClass() : dataMember(60) 
    {

    }

    // 非常量成员函数，可以修改数据成员
    void modifyDataMember(int newValue) {
        dataMember = newValue;
    }

    // 带有const修饰符的成员函数，只读访问数据成员
    void readDataMember() const {

        // 不能在const成员函数中修改数据成员
        //dataMember = 10;
        cout << "Data member value: " << dataMember << endl;
    }

private:
    int dataMember;
};

int main() {
    MyClass obj;  // 创建一个常量对象

    //使用不带const修饰的函数修改成员变量的值
    obj.modifyDataMember(10);

    // 通过常量对象调用只读成员函数
    obj.readDataMember();

    // 不能通过常量对象调用非常量成员函数
    // const MyClass obj2; 
    // obj2.modifyDataMember(10);

    return 0;
}