C++-面向对象(七)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42528266/article/details/102753434
静态成员（static）
- 静态成员：被static修饰的成员变量\函数
- 可以通过对象（对象.静态成员）、对象指针（对象指针->静态成员）、类访问（类名::静态成员）
- 静态成员变量
- 存储在数据段（全局区，类似于全局变量），整个程序运行过程中只有一份内存
- 对比全局变量，它可以设定访问权限（public、protected、private），达到局部共享的目的
- 必须初始化，必须在类外面初始化，初始化时不能带static，如果类的声明和实现分离（在实现.cpp中初始化）
- 静态成员函数
- 内部不能使用this指针（this指针只能用在非静态成员函数内部）
- 不能是虚函数（虚函数只能是非静态成员函数）
- 内部不能访问非静态成员变量\函数，只能访问静态成员变量\函数
- 非静态成员函数内部可以访问静态成员变量\函数
- 构造函数、析构函数不能是静态
- 当声明和实现分离时，实现部分不能带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::ms_count = 20;
Student::ms_count = 10;
cout << Person::ms_count << endl;
getchar();
return 0;
}
//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;
//
// cout << car1.getCount() << endl;*/
//
// cout << Car::getCount() << endl;
//
// /*Car car1;
// car1.m_count = 10;
// car1.getCount();
//
// p->m_count = 10;
// p->getCount();
//
// Car::m_count = 20;
// Car::getCount();*/
//
// getchar();
// return 0;
//}
//class Car {
//public:
// static int m_price;
// void run() {
// cout << "run()" << endl;
//
// }
//};
//
//// 初始化静态成员变量
//int Car::m_price = 0;
//
//int main() {
// Car car;
// car.m_price = 10;
//
// Car car2;
// car2.m_price = 20;
//
// Car::m_price = 30;
//
// Car *p = new Car();
// p->m_price = 40;
//
// Car car3;
// cout << car3.m_price << endl;
//
//
// getchar();
// return 0;
//}静态成员经典应用 – 单例模式
#include <iostream>
using namespace std;
/*
单例模式：
在程序运行过程中，可能会希望某些类的实例对象永远只有一个
1.把构造函数私有化
2.定义一个私有的静态成员变量指针，用于指向单例对象
3.提供一个公共的返回单例对象的静态成员函数
*/
//class Person {
//public:
// static int ms_count;
// virtual void run() {
//
// }
//};
//
//int Person::ms_count = 0;
//
//class Student : public Person {
//public:
// static int ms_count;
// void run() {
// ms_count = 10;
// }
//};
//
//int Student::ms_count = 0;
//
//
//int main() {
//
// Person::ms_count = 10;
// Student::ms_count = 20;
//
// cout << Person::ms_count << endl;
// cout << Student::ms_count << endl;
//
//
// getchar();
// return 0;
//}
class Rocket {
public:
// C++：静态成员函数
// Java、OC：类方法
static Rocket * sharedRocket() {
// API p_thread
if (ms_rocket == NULL) {
ms_rocket = new Rocket();
}
return ms_rocket;
}
static void deleteRocket() {
static Rocket *ms_rocket;
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() {
int *p = new int();
*p = 5;
delete p;
p = NULL;
cout << *p << endl;
// mac
// xcode
Rocket *p1 = Rocket::sharedRocket();
// ......
Rocket::deleteRocket();
Rocket *p2 = Rocket::sharedRocket();
Rocket::deleteRocket();
/*Rocket *p1 = Rocket::sharedRocket();
Rocket *p2 = Rocket::sharedRocket();
Rocket *p3 = Rocket::sharedRocket();
Rocket *p4 = p3->sharedRocket();
cout << p1 << endl;
cout << p2 << endl;
cout << p3 << endl;
cout << p4 << endl;*/
getchar();
return 0;
}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 int msc_wheelsCount = 4;
Car() :m_price(0) {
}
static void test3() {
}
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 *p = new Car();
p->test();
const Car car2;
car2.test();
const Car *p2 = new Car();
p2->test();
/*Car car1;
car1.m_price = 100;
Car car2;
car2.m_price = 500;
cout << sizeof(Car) << endl;*/
getchar();
return 0;
}本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2019-10-26 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录