静态成员变量
被static修饰的成员变量、函数,可以通过对象，对象指针，类访问，静态成员变量在数据段，类似于全局变量，整个程序运行中只有一份内存。但是静态成员变量可以通过类设定它的访问权限，比如public、protected、private来修饰达到局部共享的目的。static成员变量必须初始化，而且必须在类外面初始化，初始化时不能带static。
#include <iostream>
using namespace std;
class Person {
public:
static int ms_count;
};
class Student : public Person {
};
int Person::ms_count = 0;
int main() {
Person p;
Person *p1 = new Person();
Student s;
Student *s1 = new Student();
Person::ms_count = 20;
Student::ms_count = 10;
cout << Person::ms_count << endl; //10
cout << Student::ms_count << endl; //10
cout << p.ms_count << endl;//10
cout << p1->ms_count << endl;//10
cout << s.ms_count << endl;//10
cout << s1->ms_count << endl;//10
return 0;
}
静态成员由于是存在全局区，不会跟着对象销毁而释放，下面我们结合static函数来看下。
#include <iostream>
using namespace std;
class Car {
private:
static int m_count;
public:
Car() {
m_count++;
}
~Car() {
m_count--;
}
static int getCount() {
return m_count;
}
};
int Car::m_count = 0;
int main() {
Car car1;
Car car2;
Car *p = new Car();
delete p;
//3次构造和一次析构，Car::getCount() = 2
cout << Car::getCount() << endl;
return 0;
}
静态成员函数
静态成员函数内部不能使用this指针，this指针只能在非静态成员函数内部使用,虚函数也不能是静态成员函数,虚函数只能是非静态成员函数，静态成员函数内部不能访问非静态成员变量、函数，只能访问静态成员变量、函数,非静态成员函数内部可以访问静态成员变量、函数,构造函数、析构函不能是静态成员函数，当静态成员函数声明与实现分离时，实现部分不能带static。
#include <iostream>
using namespace std;
class Car {
private:
static int m_count;
public:
//静态成员声明
static int getCount();
//构造函数
Car(int count){
//访问static成员m_count
m_count = count;
}
};
//静态成员实现
int Car::getCount(){
return m_count;
}
int Car::m_count = 0;
int main() {
Car car1(100);
//100
cout << Car::getCount() << endl;
return 0;
}
单例模式
在开发中我们经常有这种需求，在运行程序中，我们对象保持一份，不允许重复创建，而且外部拿到的对象保证只有一份，这时用static成员和static成员函数构成的单例模式非常实用。下面我们来看看这个经典的单例模式的应用:
#include <iostream>
using namespace std;
/*
单例模式：
在程序运行过程中，可能会希望某些类的实例对象永远只有一个
1.把构造函数私有化
2.定义一个私有的静态成员变量指针，用于指向单例对象
3.提供一个公共的返回单例对象的静态成员函数
*/
class Rocket {
public:
// C++：静态成员函数
static Rocket * sharedRocket() {
// 严格来说这里需要考虑线程安全
if (ms_rocket == NULL) {
ms_rocket = new Rocket();
cout << ms_rocket << endl;
}
return ms_rocket;
}
static void deleteRocket() {
//单例模式一般不用考虑析构函数，如果非要析构这里也要考虑线程安全。
if (ms_rocket == NULL) return;
delete ms_rocket;
ms_rocket = NULL;
}
static Rocket *ms_rocket;
private:
Rocket() {
cout << "Rocket()" << endl;
}
~Rocket() {
cout << "~Rocket()" << endl;
}
};
Rocket *Rocket::ms_rocket = NULL;
int main() {
Rocket *p1 = Rocket::sharedRocket();
Rocket::deleteRocket();
Rocket *p2 = Rocket::sharedRocket();
Rocket *p3 = Rocket::sharedRocket();
Rocket *p4 = p3->sharedRocket();
cout << p1 << endl;
cout << p2 << endl;
cout << p3 << endl;
cout << p4 << endl;
return 0;
}
我这里得到的是p1和p2、p3、p4相等，p1指向的对象被销毁了一次，相等属于巧合。而p2、p3、p4相等是因为他们指向同一个对象。
const
类里面的const成员：被const成员修饰的成员变量，非静态成员函数，const成员变量:必须初始化,在类内部初始化，可以在申明的时候初始化赋值,非static的const成员变量还可以在初始化列表中初始化。const成员函数:const放在函数参数列表后面，函数的声明和实现都必须带const，内部不能修饰非static成员变量，其内部只能调用const函数和static成员函数，非const成员函数可以调用const成员函数，const成员函数和非const成员函数可以构成重载,非const成员函数优先调用非const成员函数，而const成员函数只能调用const或者static成员函数。示例如下:
#include <iostream>
using namespace std;
class Car {
public:
int m_price;
//被static和const同时修饰表示这份成员变量存在静态全局区且不可修改
static const int msc_wheelsCount = 4;
Car() :m_price(0) {
cout << "Car() :m_price(0)" << endl;
}
static void test3() {
cout << "static void test3()" << endl;
}
void test4() {
test1();
}
void test2() const {
// this->m_price = 20;
}
// 不能在这个函数内部修改当前对象的成员变量
void test1() const {
// this->m_price = 10;
test2();
test3();
}
void test() {
cout << "test()" << endl;
}
void test() const {
cout << "test() const" << endl;
}
};
int main() {
Car car;
car.test();
car.test1();
Car *p = new Car();
p->test();
const Car car2;
car2.test();
const Car *p2 = new Car();
p2->test();
return 0;
}
引用类型成员
引用类型成员变量必须初始化,在声明的时候直接初始化，或者在初始化列表的时候初始化。
#include <iostream>
using namespace std;
class Car {
public:
int age;
int &m_pAge = age;
int &m_pHeight;
Car(int &height):m_pHeight(height){}
};
int main() {
int age = 100;
int &p_age = age;
Car car(p_age);
car.age = 10;
cout << car.m_pAge << endl;
cout << car.m_pHeight << endl;
return 0;
}
