静态成员
- 静态成员：被
static关键字修饰的成员变量或者函数；
- 可以通过
对象(对象.静态成员)，对象指针(对象指针->静态成员)，类访问(类名::静态成员)
- 静态成员变量：
- 存储在数据段(全局区，类似于全局变量)，整个程序运行过程中只有一份内存，不会占用实例对象的内存空间；
- 对比全局变量，它可以设置访问权限，达到局部共享的目的；
-
必须初始化，必须在类外面初始化，初始化时不能带static，如果类的声明与实现分离，在.cpp文件中初始化；
#include <iostream>
using namespace::std;
class Car {
public:
static int m_price;
void run(){
cout << "run()" << endl;
}
};
//初始化静态成员变量
int Car::m_price = 0;
int main(int argc, const char * argv[]) {
Car car1;
//通过对象访问
car1.m_price = 10;
Car car2;
car2.m_price = 20;
//通过类名访问
cout << car2.m_price << endl;
Car::m_price = 30;
cout << car2.m_price << endl;
//通过指针访问
Car *p = new Car();
cout << p->m_price << endl;
return 0;
}
- 静态成员函数：
- 内部不能使用
this指针，this指针只能用在非静态函数的内部；
- 不能是虚函数，虚函数只能是非静态成员函数；
- 内部不能访问非静态成员变量/函数，只能访问静态成员变量/函数；
- 非静态成员函数内部可以访问静态成员变量/函数；
- 构造函数与析构函数不能是静态函数，因为构造函数与析构函数需要访问非静态成员变量；
- 当声明与实现分离的时候，实现部分不能带
static关键字；
#include <iostream>
using namespace::std;
class Car {
private:g
//用来记录实例对象的个数
static int m_count;
public:
static int m_price;
Car(){
m_count++;
}
~Car(){
m_count--;
}
void run(){
cout << "run()" << endl;
}
static int getCount(){
return m_count;
}
};
//初始化静态成员变量
int Car::m_price = 0;
int Car::m_count = 0;
int main(int argc, const char * argv[]) {
Car car1;
//通过对象访问静态成员变量
car1.m_price = 10;
Car car2;
car2.m_price = 20;
//通过类名访问静态成员变量
cout << car2.m_price << endl;
Car::m_price = 30;
cout << car2.m_price << endl;
//通过指针访问静态成员变量
Car *p = new Car();
cout << p->m_price << endl;
//通过指针，类名，实例对象 调用静态成员函数
cout << p->getCount() << endl;
cout << Car::getCount() << endl;
cout << car1.getCount() << endl;
return 0;
}
单例模式
- 在程序运行过程中，可能会希望某些类的实例对象永远只有一个；
- 如何创建一个单例对象：
- 把构造函数私有化；
- 定义一个私有的静态成员变量指针，用于指向单例对象；
- 提供一个公共的返回单例对象的静态成员函数；
#include <iostream>
using namespace::std;
class Rocket {
private:
//静态成员变量
static Rocket *ms_rocket;
//构造函数私有
Rocket(){ }
//拷贝构造函数私有
Rocket(const Rocket &rocket) { }
//赋值私有
void operator=(const Rocket &rocket){ }
public:
//静态成员函数
static Rocket* sharedRocket(){
if (ms_rocket == NULL) {
ms_rocket = new Rocket();
}
return ms_rocket;
}
static void deleteRocket(){
if (ms_rocket == NULL) return;
delete ms_rocket;
ms_rocket = NULL;
}
};
//初始化静态成员变量
Rocket* Rocket::ms_rocket = NULL;
int main(int argc, const char * argv[]) {
Rocket *r1 = Rocket::sharedRocket();
Rocket *r2 = Rocket::sharedRocket();
Rocket *r3 = Rocket::sharedRocket();
cout << r1 << endl;
cout << r2 << endl;
cout << r3 << endl;
Rocket::deleteRocket();
return 0;
}
const成员
- const成员：被const修饰的成员变量，非静态成员函数；
- const成员变量：
- 必须初始化，类内部初始化，可以在声明的时候直接初始化赋值；
- 非static的const成员变量还可以在初始化列表中初始化；
- const成员函数(非静态)：
- const关键字写在参数列表的后面，函数的声明与实现都必须带上const；
- 函数内部不能修改非static的成员变量；
- 函数内部只能调用const成员函数与static成员函数；
- 非const成员函数可以调用const成员函数；
- const成员函数与非const成员函数构成函数重载；
- 非const对象(指针) 优先调用非const成员函数；
- const对象(指针)只能用const成员函数；
#include <iostream>
using namespace::std;
class Car {
public:
int m_price;
//静态 const成员 不得修改且只有一份内存；
static const int m_wheelsCount = 4;
//const成员 不得修改；
const int m_hasBoli;
//const成员在初始化列表中初始化；
Car() : m_hasBoli(1){
}
static void test(){
}
//const成员函数
void test1() const {
test();
}
//test1函数 构成函数重载
void test1() {
test();
}
};
int main(int argc, const char * argv[]) {
Car car1;
car1.m_price = 100;
Car car2;
car2.m_price = 500;
car2.test1(); //调用 test1
const Car car3;
car3.test1();//调用const test1
return 0;
}
引用类型成员
- 引用类型成员变量必须初始化(不考虑static情况)；
- 在声明的时候直接初始化；
- 通过初始化列表进行初始化；
#include <iostream>
using namespace::std;
class Car {
public:
int m_age;
int &m_price = m_age;
Car(int &price) : m_price(price){
}
};
int main(int argc, const char * argv[]) {
return 0;
}
网友评论