C++进阶学习----静态成员

static成员变量

• 静态成员为所有类的对象所共有
• 内存是程序运行时分配
• 使用前必须初始化且只能初始化一次
• 初始化不能在类定义中，通过作用域限定符初始化

类型 类名:：变量名=值；

• 类似全局变量，和全局变量相比
  • 作用域在类中，可以避免与其他类成员或者全局对象的名字冲突
  • 可以封装，static成员可以是私有的，而全局对象不可以
  • 直观表现出与某个类的关联，清晰地反映程序员的意图

static成员函数

• 静态成员函数为所有类对象所共有，不再属于对象，不需要通过对象访问
• static成员函数没有this指针，所以静态成员函数不可以访问非静态成员。只能访问静态成员（静态成员和静态变量）
• 非静态成员函数可以访问静态成员

静态成员示例：

银行账户管理（含利率）

#include<iostream>
#include<string>
using namespace std;
class ACCOUNT
{
	string m_name;		//户名
	string m_account;	//账号
	double m_balance;	//余额
	static double m_rate; //利率
public:
	ACCOUNT(string name, string account, double balance)
	{
		m_name = name;
		m_account = account;
		m_balance = balance;
	}
	void save(double money)	//存钱
	{
		m_balance += money;
	}
	void draw(double money)	//取钱
	{
		if (money > m_balance)
		{
			cout << "余额不足" << endl;
		}
		m_balance -=money;
	}
	void query() const	//查询
	{
		cout << "户名:" << m_name << endl;
		cout << "账号:" << m_account << endl;
		cout << "余额:" << m_balance << endl;
	}
	void collect()	//汇总
	{
		m_balance *= (1 + m_rate / 100);//加利息
	}
	static void adjust(double rate)	//设置利息
	{
		if (rate > 0)
		{
			m_rate = rate;
		}
	}
};
//类外初始化(定义)
double ACCOUNT::m_rate = 0.2;
int main()
{
	ACCOUNT man("梦凡", "622848-888888-888888", 6666);
	man.draw(2000);	//取钱
	man.query();	//业务查询

	ACCOUNT man2("梦爱", "622848-666666-6666666", 8888);
	man2.save(1000);	//存钱
	man2.query();		//业务查询
	cout << "------------" << endl;
	man.collect();		//按月结算利息
	man.query();		//业务查询
	man2.collect();		//按月结算利息
	man2.query();		//业务查询
	//ACCOUNT::adjust(0.5);	//设置利率
	man.adjust(0.4);		//设置利率
	return 0;
}
//打印结果
户名:梦凡
账号:622848-888888-888888
余额:4666
户名:梦爱
账号:622848-666666-6666666
余额:9888
------------
户名:梦凡
账号:622848-888888-888888
余额:4675.33
户名:梦爱
账号:622848-666666-6666666
余额:9907.78

静态成员函数内访问对象私有成员

#include<iostream>
using namespace std;

typedef int(*CALLBACK)(void*pUser);
class Base;
int test(CALLBACK callback,void* pUser){
    Base* bas = (Base*)pUser;
    callback(pUser);
}

class Base{
private:
    int privateVal;
    void privateFun(){
        cout << "privateFun" << endl;
    }
public:
    Base(){
        privateVal = 1;
        publicVal = 10;
    }
    int publicVal;
    void publicFun()
    {
        cout << "privateFun" << endl;
    }
    void fun(){
        // 有些需求需要进入一个库内进行数据处理再回调出来
        // test(callFunc,(void*)this);
        callFunc(this);
    }
    static int callFunc(void*pUser)
    {
        Base* base = (Base*)pUser;
        cout << base->publicVal<<","<<base->privateVal<<endl;
        base->privateFun();
        base->publicFun();
    }
};
int main(){
    Base b;
    b.fun();
    return 0;
}

在Base的成员函数fun内将静态成员函数和this指针传给一个外部函数，在外部函数内调用回调函数回到静态成员函数内访问this的私有成员