类中的类类型静态成员变量
概述
- 对于类类型的静态成员变量，即使没有被使用，也会执行这个静态成员变量的构造和析构。
- 对于int，double基础类型，如果没有用到，编译器可能不为它分配内存。
使用
老用法
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class A { public: A() {} ~A(){} } class B { public: static A m_sa; // 声明 } A B::m_sa; // 定义 |
C++17
|
1 2 3 4 5 6 7 8 9 10 |
class A { public: A() {} ~A(){} } class B { public: inline static A m_sa; } |
函数中的类类型静态对象
概述
- 如果函数没有被调用过，该静态对象就不会被构造。
- 如果函数被调用了多次，该静态对象也只会被构造一次。
全局对象的构造顺序
- 如果一个项目中有多个源文件，每个源文件中都定义了一些不同的全局对象，这些全局对象的构造顺序（或初始化顺序）是不确定的。
拷贝构造函数和拷贝赋值运算符
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
class A { public: A() : a_(0),b_(0) {} A(const A& other) { a_ = other.a_; b_ = other.b_; } A& operator=(const A& other) { a_ = other.a_; b_ = other.b_; return (*this); } private: int a_; int b_; } |
对象自我赋值可能导致的问题
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
class A { public: A() : a_(0),b_(0),str_(new char[100]) {} ~A() { delete []str_; } A(const A& other) { str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; } A& operator=(const A& other) { delete str_; str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; return (*this); } private: int a_; int b_; char *str_; } |
如果对于上面的实现，发生了自己赋值自己，就会有问题
|
1 2 |
A a; a = a; |
方法一：在赋值的时候，判断是不是自己
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
class A { public: A() : a_(0),b_(0),str_(new char[100]) {} ~A() { delete []str_; } A(const A& other) { str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; } A& operator=(const A& other) { if (this == &other) { return (*this); } delete str_; str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; return (*this); } private: int a_; int b_; char *str_; } |
方法二：利用额外的空间进行处理
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
class A { public: A() : a_(0),b_(0),str_(new char[100]) {} ~A() { delete []str_; } A(const A& other) { str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; } A& operator=(const A& other) { char *tmp_str = new char[100]; memcpy(tmp_str, other.str_, 100); delete str_; str_ = tmp_str; a_ = other.a_; b_ = other.b_; return (*this); } private: int a_; int b_; char *str_; } |
继承关系下的拷贝构造函数和拷贝赋值运算符
这时类B和类A没有什么区别，所以不会有问题
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
class A { public: A() : a_(0),b_(0),str_(new char[100]) {} virtual ~A() { delete []str_; } A(const A& other) { str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; } A& operator=(const A& other) { if (this == &other) { return (*this); } delete str_; str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; return (*this); } private: int a_; int b_; char *str_; } class B : public A { } // other B b1; B b2 = b1; b2 = b1; |
当派生类定义了自己的拷贝构造和拷贝赋值运算符之后，就不会调用基类的拷贝构造函数和拷贝赋值预算符了：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
class A { public: A() : a_(0),b_(0),str_(new char[100]) {} virtual ~A() { delete []str_; } A(const A& other) { str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; } A& operator=(const A& other) { if (this == &other) { return (*this); } delete str_; str_ = new char[100]; memcpy(str_, other.str_, 100); a_ = other.a_; b_ = other.b_; return (*this); } private: int a_; int b_; char *str_; } class B : public A { public: B() {} B(const B& other) { } B& operator=(const B& other) { return (*this); } } // other B b1; B b2 = b1; b2 = b1; |
需要主动调用基类的拷贝构造函数和拷贝辅助运算符
|
1 2 3 4 5 6 7 8 9 10 11 |
class B : public A { public: B() {} B(const B& other) : A(other) { } B& operator=(const B& other) { A::operator=(other); return (*this); } } |
程序退出时检测内存泄漏并输出到“输出”窗口
|
1 2 3 4 |
int main() { _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); // ... } |
public继承
- 表现出的是一种“is-a”关系。
- 其中，基类表现的是一种更泛化的概念，而子类表现的是一种更特化的概念。
- 能够在基类对象上做的行为也能够在派生类对象上做，因为每个派生类对象都是一个基类对象。
- 设计模式的里氏替换原则，任何基类出现的地方都能够无差别的使用子类替换。
组合关系
- A对象里面有一个B对象成员，它们有一样的生命周期。
聚合关系
- A对象里面用到了B对象的指针，B对象的指针可以在需要的时候传过来，所以生命周期是可以不一致的。
不支持拷贝构造和拷贝赋值运算符的类
方法一
|
1 2 3 4 5 6 7 |
class A { public: A() {} A(const A& other) = delete; A& operator=(const A& other) = delete; // ... } |
方法二：将拷贝构造函数和拷贝赋值运算符设为私有，并不予以实现
|
1 2 3 4 5 6 7 8 |
class A { public: A() {} private: A(const A& other); A& operator=(const A& other); } |
方法三：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
class NonCopy { protected: NonCopy() {} ~NonCopy() {} private: NonCopy(const NonCopy&); NonCopy& operator(const NonCopy&); } class Test : private NonCopy { public: // ... } |
避免将基类的虚函数暴露给派生类
所谓非虚拟接口手法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
class A { public: void func() { virfunc(); } virtual ~A() {} private: virtual void virfunc() { std::cout << "A:virfunc" << std::endl; } } class B : public A { private: virtual void virfunc() { std::cout << "B:virfunc" << std::endl; } } // other. A* pa = new B(); pa->func(); delete pa; |
关于在构造和析构中调用虚函数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
class A { public: A() { f1(); } ~A() { f2(); } virtual void f1() { std::cout << "A:f1 called" << std::endl; } virtual void f2() { std::cout << "A:f2 called" << std::endl; } } class B : public A { public: B() { f1(); } ~B() { f2(); } virtual void f1() { std::cout << "B:f1 called" << std::endl; } virtual void f2() { std::cout << "B:f2 called" << std::endl; } } // test A* pa = new B(); pa->f1(); pa->f2(); delete pa; // res // A:f1 called // B:f1 called // B:f1 called // B:f2 called // B:f2 called // A:f2 called |
- 构造B的时候，会先走到A的构造里面去，这时，B还没有完成构造出来，此时在A的构造中调用了一个虚函数f1，那么调用的只能是A自己的f1了。
- 然后走到B的构造里面，这是B类对象已经完成构造了，在B的构造里面调用了一个f1，此时，根据虚函数机制，对象类型是B，所以调用的f1是B的。
- 然后调用了f1，f2，这时调用的都是B的。
- 最后析构对象的时候，先走B的析构函数，此时，虚函数机制还是起作用的，调用到的f2是B的
- 然后才走到A的析构函数，此时对象B的那部分已经被析构掉了，此时调用了一个虚函数f2，调用到的只能是A自己的f2了。
关于析构函数的访问权限
- 如果一个基类的析构函数不是虚函数，并且也不利用这个基类来创建对象，也不会用到这个基类类型的指针，则应该考虑将这个基类的析构函数设为受保护的。
- 比如设为protected之后：
- 无法创建基类对象
- 无法让基类指针执行基类或派生类的对象（因为无法成功delete）
模拟抽象类
- 抽象类至少要有一个纯虚函数。
- 抽象类不能用来生成对象。
|
1 2 3 4 5 6 |
class Interface { protected: Interface() {} Interface(const Interface& other) {} virtual ~Interface() = 0; } |
关于隐式转换（类型转换构造函数）
|
1 2 3 4 5 6 7 8 9 |
class A { public: A(int a) { std::cout << a << std::endl; } } // test A test = 10; |
|
1 2 3 4 5 6 7 |
class A { public: explict A(int a) {} } // test A test = 10;// error |
强制类对象不能在堆上分配内存
|
1 2 3 4 5 6 7 8 9 10 |
class A { public: A() {} ~A() {} private: static void* operator new(size_t size); static void operator delete(void* phead); static void* operator new[](size_t size); static void operator delete[](void* phead); } |
强制类对象只能在堆上分配内存
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// 不允许在栈上，也就是不能出现如下的局部变量 A a; // 要达到这种效果,需要把析构函数设为private class A { public: private: ~A() {} } // 但是析构函数被设为private之后，new出来的对象没法delete class A { public: void Destroy() { delete this; } private: ~A() {} } |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ STL_deque05/18
- ♥ C++11_第五篇12/08
- ♥ C++并发编程_概念了解05/07
- ♥ Soui四05/23
- ♥ Spdlog记述：四09/16
- ♥ breakpad记述：Windows下静态库的编译使用03/15