1. 静态成员
1.1 静态成员变量
在一个类中，若将一个成员变量声明为static，这种成员称为静态成员变量。与一般的数据成员不同，无论建立了多少个对象，都只有一个静态数据的拷贝。静态成员变量，属于某个类，所有对象共享。
静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间。
- 静态成员变量必须在类中声明，在类外定义
- 静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间
- 静态数据成员可以通过类名或者对象名来引用
// 静态成员变量
class Maker
{
public:
// 1.生命周期是整个程序，作用域在类内
static int a;
public:
Maker(){};
~Maker(){};
};
// 2.静态成员变量要在类内声明，类外初始化
int Maker::a = 100;
void test02()
{
// 3.静态成员变量是属于类，不属于对象，是所有对象共享
// 4.静态成员变量可以用类访问，也可以用对象访问
cout << Maker::a << endl;
Maker m;
cout << m.a << endl;
}
1.2 静态成员函数
在类定义中，前面有static说明的成员函数称为静态成员函数。静态成员函数使用方式和静态变量一样，同样在对象没有创建前，即可通过类名调用。静态成员函数主要为了访问静态变量，但是，不能访问普通成员变量。
静态成员函数的意义，不在于信息共享，数据沟通，而在于管理静态数据成员，完成对静态数据成员的封装。
- 静态成员函数只能访问静态变量，不能访问普通成员变量
- 静态成员函数可以通过类名或者对象名来引用
- 静态成员函数也有访问权限
// 静态成员函数
class Maker2
{
public:
static int a2;
int a1;
public:
Maker2(){};
// 5.静态成员函数只能访问静态成员变量
static void setA(int a)
{
a2 = a;
// a1 = a; // 报错 静态成员函数不能访问普通成员变量
cout << "a2 = " << a2 << endl;
}
~Maker2(){};
};
int Maker2::a2 = 200;
void test03()
{
Maker2 m;
m.setA(200);
Maker2::setA(300);
}
// 6.静态成员也有权限，如果为私有，类外也不可以访问，但静态成员变量可以在类外初始化
class Maker3
{
private:
static int a3;
private:
Maker3(){};
static void func()
{
cout << "a3 = " << a3 << endl;
}
~Maker3(){};
};
int Maker3::a3 = 300;
void test04()
{
// Maker3::func(); //报错
// cout << Maker3::a3 << endl; //报错
}
1.3 const静态成员属性
如果一个类的成员，既要实现共享，又要实现不可改变，那就用 static const 修饰。
定义静态const数据成员时，最好在类内部初始化。
// 7.const 修饰的静态成员变量，最好在类内初始化
class Maker4
{
private:
public:
const static int a = 20; // 只读区
const static int b;
};
// 类外也可以初始化
const int Maker4::b = 30;
1.4 普通成员函数可以访问静态成员变量
// 8.普通成员函数可以访问静态数据成员
class Maker5
{
public:
void func()
{
cout << "a = " << a << endl;
printMaker();
}
public:
static int a;
public:
static void printMaker()
{
cout << "hello world" << endl;
}
};
int Maker5::a = 50;
void test05()
{
Maker5 m;
m.func();
}
1.5 总结
- 1. 静态成员变量的生命周期是整个程序，作用域在类内
- 2. 静态成员变量要在类内声明，类外初始化
- 3. 静态数据成员属于类，不属于对象，是所有对象共享
- 4. 静态数据成员可以用类访问，也可以用对象访问
- 5. 静态成员函数只能访问静态成员变量
- 6. 静态数据成员也有权限，如果为私有，类外也不可以访问
- 7. const修饰的静态成员变量，最好在类内初始化
- 8. 普通成员函数可以访问静态数据成员
2. 单例模式
单例模式是一个类只能实例化一个对象
实现单例的思路
- 1. 将构造函数 拷贝构造函数私有化
- 2. 定义一个类内的静态成员指针
- 3. 在类外初始化，new一个对象
- 4. 将静态成员指针的权限设置为私有，然后提供一个静态成员函数，让外面可以获取指针
class Maker {
// 1.把构造函数 拷贝构造函数私有化
private:
Maker() {
}
Maker(const Maker &m){
}
private:
// 2.定义一个类内的静态成员指针
static Maker *pMaker;
public:
// 4.静态成员函数 访问静态成员变量
static Maker* getMaker() {
return pMaker;
}
};
// 3. 在类外初始化时，new一个对象
Maker* Maker::pMaker = new Maker; // 这里可以new是因为有Maker::作用域，编译器这时把它当成在类内
网友评论