本博文源于C++基础，类中的特殊成员函数是对特殊数据成员的扩展实现，比如static如果定义在public里，那就增加外部访问风险，非常不安全。如果定义在private里，只通过成员函数访问那就非常不错了。本博文基于此，讲解：1、静态成员函数;2、用const修饰的成员函数 3、类中的内联函数

1、 静态成员函数

将静态数据成员定义在private中，用成员函数访问，静态成员函数就应运而生。静态成员函数的定义形式如下所示：

class 类名{
	static 函数返回值 函数名(形参列表){
		函数体
	}
};

如果想要访问：

类名::静态成员函数(实参);

通常静态数据成员函数访问静态数据成员，也可访问其他静态数据成员函数局。但是，若静态成员函数想访问非静态数据成员时，必须通过参数传递的方式得到对象名，然后在静态成员函数中通过对象名访问非静态成员。

1.1 案例1–静态成员函数操作静态与非静态数据成员

代码中我们定义学生类，先将静态成员定义在private里，然后我们定义静态成员函数无参类型特地操作静态成员变量，然后重载静态成员函数，操作非静态数据成员。

\

#include<iostream>
#include<string>

using namespace std;
class Student {
public:
    Student(string con_name,int con_id);
    ~Student();
    string get_stdname();
    //静态成员函数get_totalnum();访问静态数据成员
    static int get_totalnum();
    //静态成员函数get_totalnum(),为了访问非静态数据成员,带有对象引用参数
    static int get_totalnum(Student &stdref);

private:
    static int s_nTotalNum;  //静态数据成员s_nTotalNum
    string m_strName;
    int m_nID;
};

//定义Student构造函数，每创建一个对象，记录学生总人数的s_nTotalNum 自增1
Student::Student(string con_name,int con_id):m_strName(con_name) {
    s_nTotalNum++;
    m_nID = con_id;
}
//定义析构函数，每析构一个对象，s_nTotalNum减1
Student::~Student()
{
    s_nTotalNum --;
    cout << "destructor,totalnum = " << s_nTotalNum << endl;
    if(s_nTotalNum == 0)
        system("pause");
}

string Student::get_stdname() {
    return m_strName;
}

//定义静态成员函数，获取s_nTotalNum值并显示了某个学生的姓名
int Student::get_totalnum(Student &stdref) {
    cout << stdref.m_strName << " entered the school!" << endl;
    return s_nTotalNum;
}
//定义静态成员函数，获取静态数据成员s_nTotalNum的值
int Student::get_totalnum() {
    return s_nTotalNum;
}

int Student::s_nTotalNum = 0;

int main()
{
    cout << "access to static func \" get_totalnum()\": totalnum = " << Student::get_totalnum() << endl;
    Student std_tom("Tom",20);
    //通过对象访问静态成员
    cout << std_tom.get_stdname() << ",totalnum = " << std_tom.get_totalnum(std_tom) << endl;
}

代码中先访问静态成员，然后访问非静态成员。通过上面的案例，总结静态数据成员操作的特点：

1. 类的普通成员函数可以访问类的非静态及静态数据成员
2. 在类外可以直接访问类的公有静态数据成员和公有普通数据成员，访问方式不同：公有普通数据成员只可通过对象访问，公有静态数据成员既可以通过对象访问也可通过类访问
3. 在类外部可以直接访问类的公有静态成员函数和公有普通成员函数，访问方式不同：公有普通成员函数只可通过对象访问，公有静态成员函数既可以通过对象访问也可以通过类访问

2、 用const修饰的成员函数

加上const主要为了对数据进行保护，如果是const的函数那就对数据只能读取，无法修改。常成员函数定义形式如下：

class 类名
{
	public:
		函数返回值类型函数名(形参列表) const
		{
			函数体
		}
}

常成员函数可访问类中的const数据成员和非const数据成员，但不可改变它们，常成员函数不可调用非const成员函数。非const成员函数可以读取常数据成员，但不可修改。

2.1 案例–常成员功能

定义了常成员函数，以及普通成员函数，普通成员函数当然可以修改数据成员m_strName,而常成员函数就不可以.

#include<iostream>
#include<string>
using namespace std;

class Student {
public:
    Student(string con_name,int con_id);
    ~Student();
    string get_stdname() const; //用const声明成员函数
    void print_stdname();
private:
    string m_strName; // const string m_strName;
    int m_nID;
};
//定义Student的构造函数
Student::Student(string con_name,int con_id):m_strName(con_name){
    m_nID = con_id;
}

Student::~Student() {

}
string Student::get_stdname() const {
    //定义常成员函数,获取学生姓名
    return m_strName;
}

void Student::print_stdname() {
    //普通成员函数，显示学生姓名
    cout << "std's name:" << m_strName << endl;
}

int main()
{
    Student std_tom("Tom",20);
    std_tom.print_stdname();
    cout << std_tom.get_stdname() << endl;
    return 0;

}

由上面的例子，总结常成员函数的使用规则有如下几点：

1. 若类中某些数据成员的值允许改变，另外的数据成员不可改变，则可将不需改变的成员声明为const修饰的常数据成员，可用非const成员函数获取常数据成员的值，访问或修改普通数据成员
2. 若类中所有的数据成员均不改变，则可将所有数据成员用const修饰，然后常成员函数获取数据成员，保证数据不被修改
3. 若定义的是常对象，则只能调用常成员函数.

3、 类中的内敛函数

内联函数一般在一个函数不断被调用，而且代码非常简单，比如a+b，不涉及循环等复杂结构。

3.1 案例–用inline打印变量

//
// Created by Administrator on 2021/11/24/024.
//

#include<iostream>
using namespace std;
class Test {  //定义Test类
public:
    Test():m_nX(10){}
    inline void print(); //声明内联函数
    void display(int y);
private:
    int m_nX;
};

void Test::print(){ //定义内联函数
    cout << m_nX << endl;
}

void Test::display(int y) {
    cout << m_nX * y << endl;
}
int main()
{
    Test obj; //定义类对象
    obj.display(10); //调用内敛函数
    obj.print();
    return 0;

}

4. 总结

博文源于学习生活，通过几个简单案例讲解了类中内联函数、const成员函数、static成员函数，代码通俗，方便收藏，并对知识点进行了相关总结，可为读者进行扩展。