C++类中静态成员的理解

点3【静态成员】static修饰的成员
成员:成员变量 成员函数
static 修饰成员变量 修饰成员函数
static声明为静态的，称为静态成员。 不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享。
静态成员 属于类 而不是对象。

1、static 修饰成员变量
静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。
静态成员变量必须在类中声明，在类外定义。
静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。
class Data
{
public:
int num;//普通成员变量
static int data;//静态成员变量(类内声明)
};
//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化


void test01()
{
//data是静态成员变量 是属于类 可以通过类名称::直接访问
cout<<Data::data<<endl;//100
//赋值
Data::data = 200;
cout<<Data::data<<endl;//200


//data静态变量 是所有对象 共享的 可以通过对象名访问
Data ob1;
ob1.data = 300;
cout<<Data::data<<endl;//300


Data ob2;
cout<<ob2.data<<endl;//300


//普通成员变量 属于对象的 只能通过对象名访问
ob1.num = 100;
cout<<"ob2.num = "<<ob2.num<<endl;//随机值
//cout<<Data::num<<endl;//普通成员变量不能通过类名称访问
}
2、static修饰静态成员函数
引出：
class Data
{
private:
int num;//普通成员变量
static int data;//静态成员变量(类内声明)
public:
//普通成员函数 依赖于 对象的 必须对象调用
int getData(void)
{
return data;
}
};


//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化


void test01()
{
//cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
//cout<< Data::getData()<<endl;//err getData() 必须对象调用


Data ob;
cout<<ob.getData()<<endl;
//存在问题：data静态的 在创建对象之前 就已经存在
//如果类没有实例化对象 难道 就不能使用data了吗？
//解决上述问题 就要用到静态成员函数
}
静态成员函数：
class Data
{
private:
int num;//普通成员变量
static int data;//静态成员变量(类内声明)
public:
//普通成员函数 依赖于 对象的 必须对象调用
int getData(void)
{
return data;
}


//静态成员函数 属于类 而不属于对象
static int getDataStatic(void)
{
return data;
}
};


//定义的时候 不需要加static
int Data::data=100;//类外定义+初始化


void test01()
{
//cout<<Data::data<<endl;//err 静态data是私有的 类外不能直接访问
//cout<< Data::getData()<<endl;//err getData() 必须对象调用


Data ob;
cout<<ob.getData()<<endl;
//存在问题：data静态的 在创建对象之前 就已经存在
//如果类没有实例化对象 难道 就不能使用data了吗？
//解决上述问题 就要用到静态成员函数


//1、静态成员函数 属于类 就可以通过类名称直接访问
cout<<Data::getDataStatic()<<endl;


//2、也可以通过对象名访问（对象共享静态成员函数）
cout<<ob.getDataStatic()<<endl;
}
注意：
1、静态成员函数的目的 操作静态成员数据。
2、静态成员函数 不能访问 非静态成员数据。（静态成员函数内部没有this指针）

3、普通成员函数 可以操作 静态成员数据 非静态成员数据。

4、静态成员变量 和 静态成员函数 都有权限之分。


3、const 修饰静态成员
如果一个类的成员，既要实现共享，又要实现不可改变，那就用 static const 修饰
class Data
{
public:
const static int data;//静态成员变量(类内声明)
public:
//静态成员函数 属于类 而不属于对象
static int getDataStatic(void)
{
//num = 200;//err 静态成员函数 不能访问普通成员变量
return data;
}
};


//定义的时候 不需要加static
const int Data::data=100;//类外定义+初始化


void test02()
{
//访问
cout<<Data::data<<endl;
//赋值
//Data::data = 200;//err data静态成员只读
cout<<Data::data<<endl;
}
知识点4【静态成员案例】
案例1：静态成员 统计类 实例化对象的 个数
#include <iostream>


using namespace std;
class Data
{
public:
Data()
{
cout<<"无参构造"<<endl;
count++;
}
Data(const Data &ob)
{
cout<<"拷贝构造函数"<<endl;
count++;
}


~Data()
{
count--;
cout<<"析构函数"<<endl;
}


static int count;
};


int Data::count = 0;


int main(int argc, char *argv[])
{
Data ob1;
Data ob2;
{
Data ob3;
Data ob4;
cout<<"对象的个数:"<<Data::count<<endl;
}
cout<<"对象的个数:"<<Data::count<<endl;
return 0;
}


运行结果：

案例2：单例模式设计--打印机（重要）
步骤1：在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例
步骤2：提供一个公共静态的方法，让客户可以访问它的唯一实例。
步骤3：为了防止在外部对实例化其他对象，将其默认构造函数和拷贝构造函数设计为私有
#include <iostream>


using namespace std;
class Printer
{
public:
//2、提供一个方法 获得单例指针
static Printer* getSignlePrint(void)
{
return signlePrint;
}


//4、设置功能函数(自定义)
void printText(char *str)
{
cout<<"打印"<<str<<endl;
count++;


}
int count;
private:
//1、定义一个静态的 对象指针变量 保存唯一实例地址
static Printer *signlePrint;
private:
//3、防止 该类实例化其他对象 将构造函数全部 私有
Printer(){count=0;}
Printer(const Printer &ob){}


};
Printer *Printer::signlePrint = new Printer;


int main(int argc, char *argv[])
{
//打印任务1
Printer *p1 = Printer::getSignlePrint();
p1->printText("入职报告1");
p1->printText("体检报告2");
p1->printText("离职证明3");


//打印任务2
Printer *p2 = Printer::getSignlePrint();
p2->printText("入职报告1");
p2->printText("体检报告2");
p2->printText("离职证明3");


cout<<"打印任务数量:"<<p2->count<<endl;
return 0;
}




运行结果：

知识点5【this指针】（重要）
c++的封装性：将数据 和 方法 封装在一起
数据 和 方法 是分开存储。
每个对象 拥有独立的数据.
每个对象 共享同一个方法。
1、this指针的引入
class Data
{
public:
int m_num;


void setNum(int num)
{
m_num = num;
}


};


void test01()
{
Data ob1;
ob1.setNum(10);
cout<<"ob1.m_num = "<<ob1.m_num<<endl;


Data ob2;
ob2.setNum(20);
cout<<"ob2.m_num = "<<ob2.m_num<<endl;


Data ob3;
ob3.setNum(30);
cout<<"ob3.m_num = "<<ob3.m_num<<endl;
}
运行结果：

值得思考：

class Data
{
public:
int m_num;


void setNum(int num)
{
//m_num = num;
this->m_num = num;
}
};


void test01()
{
Data ob1;
ob1.setNum(10);
cout<<"ob1.m_num = "<<ob1.m_num<<endl;


Data ob2;
ob2.setNum(20);
cout<<"ob2.m_num = "<<ob2.m_num<<endl;


Data ob3;
ob3.setNum(30);
cout<<"ob3.m_num = "<<ob3.m_num<<endl;
}
运行结果：

注意：
1、this指针是隐含在对象成员函数内的一种指针
2、成员函数通过this指针即可知道操作的是那个对象的数据
3、静态成员函数内部没有this指针，静态成员函数不能操作非静态成员变量
（静态成员函数 是属于类 函数内部 没有this指针）


知识点6【this指针的使用】
1、当形参和成员变量同名时，可用this指针来区分
class Data
{
public:
int num;


//形参 和成员名相同
void setNum(int num)
{
//形参num
//成员num this->num
//num= num;//就近原则 形参num 赋值给 形参num
this->num = num;
//将形参num 赋值给 对象中成员num
}
};
2、在类的普通成员函数中返回对象本身（*this）（重要）
class MyCout
{
public:
MyCout& myCout(char *str)
{
cout<<str;
return *this;//*this 代表就是 当前调用该函数的对象
}
};
int main(int argc, char *argv[])
{
MyCout ob;
/*
ob.myCout("hehe");
ob.myCout("haha");
ob.myCout("xixi");*/

ob.myCout("hehe").myCout("haha").myCout("xixi");//ob.myCout("hehe") == ob


return 0;
}
运行结果：