Interview_C++

Interview_C++_day10

四种 (cast) 转换

四种 (cast) 转换为：(const\_cast、static\_cast、dynamic\_cast、reinterpret\_cast)。

(const\_cast：) 用于将 (const) 变量转换成非 (const)。
(static\_cast：) 用于各种隐式转换，比如非 (const) 转 (const)、(void*) 转指针等，能用于多态中向上转化，向下转化能成功但结果未知。
(dynamic\_cast：) 动态类型转换，只能用于含有虚函数的类，用于类层次间的向上和向下转化，只能转指针或引用。向下转换时，如果非法，对于指针返回 (NULL)，对于引用抛出异常。
(reinterpret\_cast：) 几乎什么都可以转，但可能会出问题。

四种智能指针

四种智能指针：(auto\_ptr、unique\_ptr、shared\_ptr、weak\_ptr)，第一种已经被 (C)++11 弃用。

(unique\_ptr)(替换 (auto\_ptr)) 实现独占式拥有概念。保证同一时间只有一个 (unique\_ptr) 指针指向某个内存，对于避免内存泄漏很有用。
(shared\_ptr) 实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在 "最后一个引用被销毁" 时释放。
- 两个对象互相使用一个 (shared\_ptr) 成员变量指向对方，会造成循环引用，使得两个对象都不会自动释放，造成内存泄漏。如下例子，可以看出析构函数没有被调用。为了解决这个问题，引入了 (weak\_ptr)。

#include<bits/stdc++.h>
using namespace std;

class A;
class B;
class A {
public:
	A() {
		cout << "A Created" << endl;
	}
	~A() {
		cout << "A Destroyed" << endl;
	}
	shared_ptr<B> ptr;
};
class B {
public:
	B() {
		cout << "B Created" << endl;
	}
	~B() {
		cout << "B Destroyed" << endl;
	}
	shared_ptr<A> ptr;
};

int main() {
	shared_ptr<A> pt1(new A());
	shared_ptr<B> pt2(new B());
	pt1->ptr = pt2;
    pt2->ptr = pt1;
    cout << "use of pt1: " << pt1.use_count() << endl;
    cout << "use of pt2: " << pt2.use_count() << endl;
    return 0;
}
/*
A Created
B Created
use of pt1: 2
use of pt2: 2
*/

(weak\_ptr) 是一种不控制对象生命周期的智能指针，它与一个 (shared\_ptr) 绑定，却不参与引用计数。一旦最后一个 (shared\_ptr) 销毁，对象就会释放。
- (weak\_ptr) 作用是在需要的时候变出一个 (shared\_ptr)，其他时候不干扰 (shared\_ptr) 的引用计数。
- (weak\_ptr) 没有 * 和 -> 符号，需要用 (lock()) 获得 (shared\_ptr)，进而使用对象。
- 利用 (weak\_ptr) 可以消除上面的循环引用，例子如下。

#include<bits/stdc++.h>
using namespace std;

class A;
class B;
class A {
public:
	A() {
		cout << "A Created" << endl;
	}
	~A() {
		cout << "A Destroyed" << endl;
	}
	weak_ptr<B> ptr;
};
class B {
public:
	B() {
		cout << "B Created" << endl;
	}
	~B() {
		cout << "B Destroyed" << endl;
	}
	weak_ptr<A> ptr;
};

int main() {
	shared_ptr<A> pt1(new A());
	shared_ptr<B> pt2(new B());
	pt1->ptr = pt2;
    pt2->ptr = pt1;
    cout << "use of pt1: " << pt1.use_count() << endl;
    cout << "use of pt2: " << pt2.use_count() << endl;
    return 0;
}
/*
A Created
B Created
use of pt1: 1
use of pt2: 1
B Destroyed
A Destroye
*/

因为存在这种情况：申请的空间在函数结束后忘记释放，造成内存泄漏。使用智能指针可以很大程度的避免这个问题，因为智能指针是一个类，超出类的作用范围后，类会调用析构函数释放资源，所以智能指针的作用原理就是在函数结束后自动释放内存空间。