十
静态成员
静态成员也是存储在全局数据区，跟全局变量的区别是 作用域。
静态成员必须在类的外面初始化，且不能带static关键字：
class Person {
protected:
static int age;
};
int Person::age = 10;
可以通过类名访问：Person::age = 30;
如果类的声明和实现分离，那么在实现中初始化静态成员变量。
静态成员函数
内部不能使用this指针，只能访问静态成员函数和静态成员变量。
class Person {
public:
static int age;
static void setAge(int newAge) {
age = newAge;
}
};
int Person::age = 10;
单例模式：
1.构造函数私有化
2.定义一个私有的静态成员变量指针，用于指向单例对象
3.提供一个公共的静态成员函数，用于返回单例对象
class Person {
public:
static Person *shared() {
// 这个地方还需要加锁
if (person == nullptr) {
person = new Person();
}
return person;
}
private:
static Person *person;
Person(){
}
};
十一
const成员变量
必须在类内部初始化。可以声明的时候直接赋初值。
非static的const成员变量还可以在初始化列表中，进行初始化。
class Person {
const int height = 180;
void run() const {
}
};
const成员函数
const关键字写在参数列表后面，函数的声明和实现都必须加const
函数内部不能修改 非static 的成员变量
内部只能调用const成员函数、static成员函数
非const成员函数可以调用const成员函数
const成员函数 对 非const成员函数构成重载
非const对象（指针）优先调用非const成员函数
const对象（指针）只能调用const成员函数
拷贝构造函数
class Person {
int age;
int height;
Person(int a, int h): age(a),height(h) { }
// 拷贝构造函数 固定格式
Person(const Person &person): age(person.age), height(person.height) {}
};
带字符串的构造函数 深拷贝：
class Person {
int age;
char *name;
public:
// const是为了兼容外部传入const字符串
Person(int age = 0, const char *name = nullptr): age(age) {
}
// 拷贝构造函数
Person(const Person &p): age(p.age) {
if (p.name == nullptr) { return; }
// 申请堆空间来存储字符串内容， 否则存储的内容是指向栈空间的 {}是重置数据
this->name = new char [strlen(name) + 1]{};
// 拷贝字符串到堆空间
strcpy(this->name, name);
}
~Person() {
if (this->name == nullptr) { return; }
delete [] this->name; // 对应创建时候的[]
this->name = nullptr;
}
};
int main(int argc, const char * argv[]) {
Person *p1 = new Person(10, "123123");
char name[] = {'z', 'm', 'j'};
Person *p2 = new Person(10, name);
Person *p3 = p2;
return 0;
}
对象类型的参数 和 返回值
struct Person {
};
void test(Person p) {
// 是一个浅拷贝的过程 会产生临时对象A
}
void test1(Person &p) {
// 不会产生临时对象 传递的就是传入那个对象
}
void test2(const Person &p) {
// 不产生临时对象 同时限制内部不能更改外部的对象 只能访问
}
十二
匿名对象
struct Person { };
int main(int argc, const char * argv[]) {
Person();
return 0;
}
隐式构造
struct Person {
int age;
Person(int age): age(age) { }
};
int main(int argc, const char * argv[]) {
Person p(10);
p = 20; // 隐式构造 相当于 p = Person(20);
return 0;
}
编译器自动生成构造函数
编译器在以下四种情况下，会自动给类生成无参的构造函数：
- 成员变量在声明的同时进行了初始化
- 有定义虚函数
- 虚继承自其他类
- 包含了对象类型的成员，且这个成员有构造函数（编译器生成或者用户自定义）
友元
1.友元包括友元函数和友元类
2.如果将函数A（非成员函数）声明为类C的友元函数，那么函数A就能直接访问类C对象的所有成员
3.如果将类A声明为类C的友元类，那么类A的所有成员函数都能直接访问类C对象的所有成员
4.友元破坏了面向对象的封装性，但是在某些频繁访问成员变量的地方，可以提高性能
class Point {
int x;
int y;
friend Point addPoint(const Point &p1, const Point &p2) {
return Point(p1.x + p2.x, p1.y + p2.y);
}
public:
Point(int x, int y): x(x),y(y) {}
};
内部类
类的内部定义类
局部类
函数内部定义类
运算符重载
class Point {
int x;
int y;
friend Point operator+(const Point &, const Point &);
public:
Point(int x, int y): x(x),y(y) {}
// 使用引用作为返回值类型 来返回自身 避免产生临时变量
Point &operator+=(const Point &point) {
this->x += point.x;
this->y += point.y;
return *this;
}
};
Point operator+(const Point &p1, const Point &p2) {
return Point(p1.x + p2.x, p1.y + p2.y);
}
int main(int argc, const char * argv[]) {
Point p1(1, 2);
Point p2(2, 3);
Point p3 = p1 + p2;
(p1 += p2) = Point(10, 12);
return 0;
}
