一、智能指針

為什么需要智能指針？

智能指針主要解決一下問題:

1. 內(nèi)存泄漏:內(nèi)存手動(dòng)釋放，使用智能指針可以自動(dòng)釋放
2. 共享所有權(quán)的指針的傳播和釋放，比如多線程使用同一個(gè)對(duì)象時(shí)析構(gòu)的問題。

C++里面的四個(gè)智能指針，auto_ptr,shared_ptr,unique_ptr,weak_ptr其中后3個(gè)是C++11支持，并且第一個(gè)已經(jīng)被C++棄用。

幾個(gè)指針的特點(diǎn)

• unique_ptr獨(dú)占對(duì)象的所有權(quán)，由于沒有引用技術(shù)，因此性能較好。
• shared_ptr共享對(duì)象的所有權(quán)，但性能略差。
• weak_ptr配合shared_ptr,解決循環(huán)引用的問題。

三者如何選擇呢?

1.1 Shared_ptr內(nèi)存模型

從圖中我們可以知道我們主要是保存一個(gè)原始的指針對(duì)象，還有個(gè)控制快，保存了shared_ptr的引用計(jì)數(shù)等。

1.2智能指針使用場景案例

1. 使用智能指針可以自己釋放占用的內(nèi)存
   例子:

class A
{
public:
	A();
	~A();

private:

};

A::A()
{
	std::cout << "A Created!" << std::endl;
}

A::~A()
{
	std::cout << "A Deleted!" << std::endl;
}

int main()
{
	auto Aptr = std::make_shared<A>();

	auto Aptr1 = new A{};


	return 0;
}

可以看到，智能指針會(huì)自動(dòng)釋放內(nèi)存

2. 使用智能指針可以自己釋放占用的內(nèi)存

1.3 shared_ptr共享的智能指針

std::shared_ptr使用引用計(jì)數(shù)每一個(gè)shared_ptr的拷貝都指向相同的內(nèi)存，最后一個(gè)shared_ptr析構(gòu)的時(shí)候，內(nèi)存才會(huì)被釋放。
shared_ptr共享被管理對(duì)象，同一時(shí)刻可以有多個(gè)shared_ptr擁有對(duì)象的所有權(quán)，當(dāng)最后一個(gè)shared_ptr對(duì)象銷毀時(shí)，被管理對(duì)象自動(dòng)銷毀。

簡單來說，shared_ptr實(shí)現(xiàn)包含了兩部分，

• 一個(gè)指向堆上創(chuàng)建的對(duì)象的裸指針，raw_ptr

• 一個(gè)指向內(nèi)部隱藏的、共享的管理對(duì)象.share_count_object

• user_count,當(dāng)前這個(gè)堆上對(duì)象被多少對(duì)象引用了，簡單來說就是引用計(jì)數(shù)。

1.3.1 shared_ptr的基本用法和常用函數(shù)

s.get(): 返回shared_ptr中保存的裸指針;
s.reset():重置shared_ptr;

• reset()不帶參數(shù)時(shí)，若智能指針s是唯一指向該對(duì)象的指針，則釋放。并置空。若智能指針P不是唯一指向該對(duì)象的指針，則引用技術(shù)減少一，同時(shí)將P置空。
• reset()帶參數(shù)時(shí)，若智能指針s是唯一指向?qū)ο蟮闹羔槪瑒t釋放并指向新的對(duì)象。若P不是唯一的指針，則只減少引用技術(shù)，并指向新的對(duì)象。如:

auto ptr = std::make_shared<int>(303);
ptr.reset(new int(10000));

s.use_count();返回shared_ptr的強(qiáng)引用計(jì)數(shù)。
s.unique();若use_count()為1.則返回true，否則返回false。

1. 初始化make_shared/reset

通過構(gòu)造函數(shù)，std::make_shared_ptr輔助函數(shù)和reset方法來初始化shared_ptr,代碼如下:

	std::shared_ptr<int>p1(new int(1));
	std::shared_ptr<int>p2 = p1;
	std::shared_ptr<int>p3;
	p3.reset(new int(1));

	if (p3)
	{
		std::cout << "p3 is not null!" << std::endl;
	}

我們應(yīng)該優(yōu)先使用make_shared來構(gòu)造智能指針，因?yàn)樗咝?/strong>

auto sp1=make_shared<int>(100);
//或
shared_ptr<int>sql=make_shared<int>(100);

//相當(dāng)于
shared_ptr<int> sp1(new int(100))

std::shared_ptr<int> p = new int(1);

	std::shared_ptr<int> p1;
	p1.reset(new int(1));
	std::shared_ptr<int>p2 = p1;

	//引用次數(shù)此時(shí)應(yīng)該是2
	std::cout << "p2.use_count() =" << p2.use_count() << std::endl;
	p1.reset();
	std::cout << "p1.reset()\n";
	//引用次數(shù)此時(shí)應(yīng)該是1
	std::cout << "p2.use_count() =" << p2.use_count() << std::endl;
	if (!p1)
	{
		std::cout << "p1 is empty!\n";
	}
	if(!p2)
	{
		std::cout << "p2 is empty!\n";
	}
	p2.reset();
	std::cout << "p2.reset()\n";
	std::cout << "p2.use_count() =" << p2.use_count() << std::endl;

	if (!p2)
	{
		std::cout << "p2 is empty!\n";
	}

std::shared_ptr<int> ptr (new int(1));
int *p=ptr.get();
//不可以 delete p;

void DeleteIntPtr(int *p)
{
	std::cout << "call DeleteIntPtr" << std::endl;
	delete p;
}
int main()
{

	std::shared_ptr<int> p(new int(1), DeleteIntPtr);

	return 0;
}

std::shared_ptr<int> p(new int(1), [](int *p) {
cout << "call lambda delete p" << endl;
delete p;});

std::shared_ptr<int> p(new int[20], [](int* p) {delete[] p; });

int * ptr=new int;
shared_ptr<int> p1(ptr);
shared_ptr<int> p2(ptr); //邏輯錯(cuò)誤

function(shared_ptr<int>(new int),g());

shared_ptr<int> p(new int);
function(p,g());

class A
{
public:
	std::shared_ptr<A> GetSelf()
	{
		return std::shared_ptr<A>(this); // 不要這么做
	}
	~A()
	{
		std::cout << "Destructor A" << std::endl;
	}
};
int main()
{
	std::shared_ptr<A> sp1(new A);
	std::shared_ptr<A> sp2 = sp1->GetSelf();
	return 0;
}

class A : public std::enable_shared_from_this<A>
{
public:
	std::shared_ptr<A>GetSelf()
	{
		return shared_from_this(); //
	}
	~A()
	{
		std::cout << "Destructor A" << std::endl;
	}
};
int main()
{
	std::shared_ptr<A> sp1(new A);
	std::shared_ptr<A> sp2 = sp1->GetSelf(); // ok
	return 0;
}

class A;
class B;
class A {
public:
std::shared_ptr<B> bptr;
~A() {
cout << "A is deleted" << endl;
}
};
class B {
public:
std::shared_ptr<A> aptr;
~B() {
cout << "B is deleted" << endl;
}
};
int main()
{
{
std::shared_ptr<A> ap(new A);
std::shared_ptr<B> bp(new B);
ap->bptr = bp;
bp->aptr = ap;
}
cout<< "main leave" << endl; // 循環(huán)引用導(dǎo)致ap bp退出了作用域都沒有析構(gòu)
return 0;
}

   std::shared_ptr<int> ptr3(new int(1), [](int *p){delete  p;}); // 正確
   std::unique_ptr<int, void(*)(int*)> ptr5(new int(1), [](int *p){delete  p;}); // 正確

unique_ptr<T> my_ptr(new T);
unique_ptr<T> my_other_ptr = my_ptr; // 報(bào)錯(cuò)，不能復(fù)制

unique_ptr<T> my_ptr(new T); // 正確
unique_ptr<T> my_other_ptr = std::move(my_ptr); // 正確
unique_ptr<T> ptr = my_ptr; // 報(bào)錯(cuò)，不能復(fù)制

auto upw1(std::make_unique<Widget>()); // with make func
std::unique_ptr<Widget> upw2(new Widget); // without make func

std::unique_ptr<int []> ptr(new int[10]);
ptr[9] = 9;
std::shared_ptr<int []> ptr2(new int[10]); // 這個(gè)是不合法的

std::shared_ptr<int> ptr3(new int(1), [](int *p){delete p;}); // 正確
std::unique_ptr<int> ptr4(new int(1), [](int *p){delete p;}); // 錯(cuò)誤

std::unique_ptr<int, void(*)(int*)> ptr5(new int(1), [](int *p){delete p;}); //
正確

std::shared_ptr<int> sp(new int(10));
std::weak_ptr<int> wp(sp);
std::cout << wp.use_count() << std::endl; //結(jié)果講輸出1

std::shared_ptr<int> sp(new int(10));
	std::weak_ptr<int> wp(sp);
	if (wp.expired())
		std::cout << "weak_ptr無效,資源已釋放";
	else
		std::cout << "weak_ptr有效";

std::weak_ptr<int> gw;
void f2()
{
	std::cout << "lock\n";
    auto spt = gw.lock();  // 鎖好資源再去判斷是否有效
    std::this_thread::sleep_for(std::chrono::seconds(2));
    if (gw.expired()) {
	    std::cout << "gw Invalid, resource released\n";
    }
    else {
	    std::cout << "gw Valid, *spt = " << *spt << std::endl;
    }
}
int main()
{
    {
        auto sp = std::make_shared<int>(42);
        gw = sp;
        std::thread([&]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));

            std::cout << "sp reset\n";
            sp.reset();
            }).detach();

            f2();
    }
    f2();
    return 0;
}

#include <iostream>
#include <memory>
using namespace std;
class A: public std::enable_shared_from_this<A>
{
public:
shared_ptr<A>GetSelf()
{
return shared_from_this(); //
}
~A()
{
cout << "Destructor A" << endl;
}
};
int main()
{
shared_ptr<A> sp1(new A);
shared_ptr<A> sp2 = sp1->GetSelf(); // ok
return 0;
}

#include <iostream>
#include <memory>
using namespace std;
class A;
class B;
class A {
public:
std::weak_ptr<B> bptr; // 修改為weak_ptr
~A() {
cout << "A is deleted" << endl;
}
};
class B {
public:
std::shared_ptr<A> aptr;
~B() {
cout << "B is deleted" << endl;
}
};
int main()
{
{
std::shared_ptr<A> ap(new A);
std::shared_ptr<B> bp(new B);
ap->bptr = bp;
bp->aptr = ap;
}
cout<< "main  leave" << endl;
return 0;
}

weak_ptr<int> wp;
{
shared_ptr<int> sp(new int(1)); //sp.use_count()==1
wp = sp; //wp不會(huì)改變引用計(jì)數(shù)，所以sp.use_count()==1
shared_ptr<int> sp_ok = wp.lock(); //wp沒有重載->操作符。只能這樣取所指向的對(duì)象
}
shared_ptr<int> sp_null = wp.lock(); //sp_null .use_count()==0

weak_ptr<int> wp;
shared_ptr<int> sp_ok;
{
shared_ptr<int> sp(new int(1)); //sp.use_count()==1
wp = sp; //wp不會(huì)改變引用計(jì)數(shù)，所以sp.use_count()==1
sp_ok = wp.lock(); //wp沒有重載->操作符。只能這樣取所指向的對(duì)象
}
if(wp.expired()) {
cout << "shared_ptr is destroy" << endl;
} else {
cout << "shared_ptr no destroy" << endl;
}

std::thread td([&sp1]()){....});

void fn(shared_ptr<A>&sp) {
...
}
..
std::thread td(fn, sp1);

std::thread td([sp1]()){....});

void fn(shared_ptr<A>sp) {
...
}
..
std::thread td(fn, sp1);

void fn(shared_ptr<A>sp) {
...
if(..){
sp = other_sp;
} else {
sp = other_sp2;
}
}

const int &ref_a = 5; // 編譯通過

void push_back (const value_type& val);

int &&ref_a_right = 5; // ok
int a = 5;
int &&ref_a_left = a; // 編譯不過，右值引用不可以指向左值
ref_a_right = 6; // 右值引用的用途：可以修改右值

nt a = 5; // a是個(gè)左值
int &ref_a_left = a; // 左值引用指向左值
int &&ref_a_right = std::move(a); // 通過std::move將左值轉(zhuǎn)化為右值，可以被右值引用指向
cout << a; // 打印結(jié)果：5

int &&ref_a = 5;
ref_a = 6;
等同于以下代碼：
int temp = 5;
int &&ref_a = std::move(temp);
ref_a = 6;
// 此時(shí)temp等于？

被聲明出來的左、右值引用都是左值.因?yàn)楸宦暶鞒龅淖笥抑狄檬?strong>有地址的，也位于等號(hào)左邊。仔細(xì)
看下邊代碼：

// 形參是個(gè)右值引用
void change(int&& right_value) {
right_value = 8;
}
int main() {
int a = 5; // a是個(gè)左值
int &ref_a_left = a; // ref_a_left是個(gè)左值引用
int &&ref_a_right = std::move(a); // ref_a_right是個(gè)右值引用
change(a); // 編譯不過，a是左值，change參數(shù)要求右值
change(ref_a_left); // 編譯不過，左值引用ref_a_left本身也是個(gè)左值
change(ref_a_right); // 編譯不過，右值引用ref_a_right本身也是個(gè)左值
change(std::move(a)); // 編譯通過
change(std::move(ref_a_right)); // 編譯通過
change(std::move(ref_a_left)); // 編譯通過
change(5); // 當(dāng)然可以直接接右值，編譯通過
cout << &a << ' ';
cout << &ref_a_left << ' ';
cout << &ref_a_right;
// 打印這三個(gè)左值的地址，都是一樣的
}

看完后你可能有個(gè)問題，std::move會(huì)返回一個(gè)右值引用int &&，它是左值還是右值呢？ 從表達(dá)式int &&ref = std::move(a)來看，右值引用ref指向的必須是右值，所以move返回的int &&是個(gè)右值。
所以右值引用既可能是左值，又可能是右值嗎？ 確實(shí)如此：右值引用既可以是左值也可以是右值，如果
有名稱則為左值，否則是右值。

或者說：作為函數(shù)返回值的&&是右值，直接聲明出來的&&是左值.這同樣也符合前面章節(jié)對(duì)左值，
右值的判定方式：其實(shí)引用和普通變量是一樣的， int &&ref = std::move(a) 和 int a = 5 沒有什
么區(qū)別，等號(hào)左邊就是左值，右邊就是右值。
最后，從上述分析中我們得到如下結(jié)論：

1. 從性能上講，左右值引用沒有區(qū)別，傳參使用左右值引用都可以避免拷貝。
2. 右值引用可以直接指向右值，也可以通過std::move指向左值；而左值引用只能指向左值(const左
   值引用也能指向右值)。
3. 作為函數(shù)形參時(shí)，右值引用更靈活。雖然const左值引用也可以做到左右值都接受，但它無法修
   改，有一定局限性。

void f(const int& n) {
n += 1; // 編譯失敗，const左值引用不能修改指向變量
}
void f2(int && n) {
n += 1; // ok
}
int main() {
f(5);
f2(5);
}

3 右值引用和std::move使用場景

std::move只是類型轉(zhuǎn)換工具，不會(huì)對(duì)性能有好處；
右值引用在作為函數(shù)形參時(shí)更具靈活性。他們有什么實(shí)際應(yīng)用場景嗎？

3.1 右值引用優(yōu)化性能，避免深拷貝

淺拷貝重復(fù)釋放

對(duì)于含有堆內(nèi)存的類，我們需要提供深拷貝的拷貝構(gòu)造函數(shù)，如果使用默認(rèn)構(gòu)造函數(shù)，會(huì)導(dǎo)致堆內(nèi)存的
重復(fù)刪除，比如下面的代碼：

#include <iostream>
using namespace std;
class A
{
public:
A() :m_ptr(new int(0)) {
cout << "constructor A" << endl;
}
~A(){
cout << "destructor A, m_ptr:" << m_ptr << endl;
delete m_ptr;
m_ptr = nullptr;
}
private:
int* m_ptr;
};
// 為了避免返回值優(yōu)化，此函數(shù)故意這樣寫
A Get(bool flag)
{
A a;
A b;
cout << "ready return" << endl;
if (flag)
return a;
else
return b;
}
int main()
{
{
A a = Get(false); // 運(yùn)行報(bào)錯(cuò)
}
cout << "main finish" << endl;
return 0;
}

打印
constructor A
constructor A
ready return
destructor A, m_ptr:000002628A9323D0
destructor A, m_ptr:000002628A92A0B0
destructor A, m_ptr:000002628A9323D0

深拷貝構(gòu)造函數(shù)

在上面的代碼中，默認(rèn)構(gòu)造函數(shù)是淺拷貝，main函數(shù)的 a 和Get函數(shù)的 b 會(huì)指向同一個(gè)指針 m_ptr，在
析構(gòu)的時(shí)候會(huì)導(dǎo)致重復(fù)刪除該指針。正確的做法是提供深拷貝的拷貝構(gòu)造函數(shù)，比如下面的代碼：

#include <iostream>
using namespace std;
class A
{
public:
A() :m_ptr(new int(0)) {
cout << "constructor A" << endl;
}
A(const A& a) :m_ptr(new int(*a.m_ptr)) {
cout << "copy constructor A" << endl;
}
~A(){
cout << "destructor A, m_ptr:" << m_ptr << endl;
delete m_ptr;
m_ptr = nullptr;
}
private:
int* m_ptr;
};
// 為了避免返回值優(yōu)化，此函數(shù)故意這樣寫
A Get(bool flag)
{
A a;
A b;
cout << "ready return" << endl;
if (flag)
return a;
else
return b;
}
int main()
{
{
A a = Get(false); // 正確運(yùn)行
}
cout << "main finish" << endl;
return 0;
}

constructor A
constructor A
ready return
copy constructor A
destructor A, m_ptr:000002455ECEA0B0
destructor A, m_ptr:000002455ECEA070
destructor A, m_ptr:000002455ECEA0F0
main finish

移動(dòng)構(gòu)造函數(shù)

這樣就可以保證拷貝構(gòu)造時(shí)的安全性，但有時(shí)這種拷貝構(gòu)造卻是不必要的，比如上面代碼中的拷貝構(gòu)造
就是不必要的。上面代碼中的 Get 函數(shù)會(huì)返回臨時(shí)變量，然后通過這個(gè)臨時(shí)變量拷貝構(gòu)造了一個(gè)新的對(duì)
象 b，臨時(shí)變量在拷貝構(gòu)造完成之后就銷毀了，如果堆內(nèi)存很大，那么，這個(gè)拷貝構(gòu)造的代價(jià)會(huì)很大，
帶來了額外的性能損耗。有沒有辦法避免臨時(shí)對(duì)象的拷貝構(gòu)造呢？答案是肯定的。看下面的代碼：

#include <iostream>
using namespace std;
class A
{
public:
A() :m_ptr(new int(0)) {
cout << "constructor A" << endl;
}
A(const A& a) :m_ptr(new int(*a.m_ptr)) {
cout << "copy constructor A" << endl;
}
// 移動(dòng)構(gòu)造函數(shù)，可以淺拷貝
A(A&& a) :m_ptr(a.m_ptr) {
a.m_ptr = nullptr; // 為防止a析構(gòu)時(shí)delete data，提前置空其m_ptr
cout << "move constructor A" << endl;
}
~A(){
cout << "destructor A, m_ptr:" << m_ptr << endl;
if(m_ptr)
delete m_ptr;
}
private:
int* m_ptr;
};
// 為了避免返回值優(yōu)化，此函數(shù)故意這樣寫
A Get(bool flag)
{
A a;
A b;
cout << "ready return" << endl;
if (flag)
return a;
else
return b;
}
int main()
{
{
A a = Get(false); // 正確運(yùn)行
}
cout << "main finish" << endl;
return 0;
}

constructor A
constructor A
ready return
move constructor A
destructor A, m_ptr:0000000000000000
destructor A, m_ptr:000002640DF0A030
destructor A, m_ptr:000002640DF0A070
main finish

上面的代碼中沒有了拷貝構(gòu)造，取而代之的是移動(dòng)構(gòu)造（ Move Construct）。從移動(dòng)構(gòu)造函數(shù)的實(shí)現(xiàn)
中可以看到，它的參數(shù)是一個(gè)右值引用類型的參數(shù) A&&，這里沒有深拷貝，只有淺拷貝，這樣就避免了
對(duì)臨時(shí)對(duì)象的深拷貝，提高了性能。這里的 A&& 用來根據(jù)參數(shù)是左值還是右值來建立分支，如果是臨時(shí)
值，則會(huì)選擇移動(dòng)構(gòu)造函數(shù)。移動(dòng)構(gòu)造函數(shù)只是將臨時(shí)對(duì)象的資源做了淺拷貝，不需要對(duì)其進(jìn)行深拷
貝，從而避免了額外的拷貝，提高性能。這也就是所謂的移動(dòng)語義（ move 語義），右值引用的一個(gè)重
要目的是用來支持移動(dòng)語義的。

移動(dòng)語義可以將資源（堆、系統(tǒng)對(duì)象等）通過淺拷貝方式從一個(gè)對(duì)象轉(zhuǎn)移到另一個(gè)對(duì)象，這樣能夠減少
不必要的臨時(shí)對(duì)象的創(chuàng)建、拷貝以及銷毀，可以大幅度提高 C++ 應(yīng)用程序的性能，消除臨時(shí)對(duì)象的維護(hù)
（創(chuàng)建和銷毀）對(duì)性能的影響。

3.2 移動(dòng)(move )語義

move是將對(duì)象的狀態(tài)或者所有權(quán)從一個(gè)對(duì)象轉(zhuǎn)移到另一個(gè)對(duì)象，只是轉(zhuǎn)義，沒有內(nèi)存拷貝。要move語
義起作用，核心在于需要對(duì)應(yīng)類型的構(gòu)造函數(shù)支持。

//2-3-2-move
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <string.h>
using namespace std;

class MyString {
private:
    char* m_data;
    size_t   m_len;
    void copy_data(const char *s) {
        m_data = new char[m_len+1];
        memcpy(m_data, s, m_len);
        m_data[m_len] = '\0';
    }
public:
    MyString() {
        m_data = NULL;
        m_len = 0;
    }

    MyString(const char* p) {
        m_len = strlen (p);
        copy_data(p);
    }

    MyString(const MyString& str) {
        m_len = str.m_len;
        copy_data(str.m_data);
        std::cout << "Copy Constructor is called! source: " << str.m_data << std::endl;
    }
    MyString& operator=(const MyString& str) {
        if (this != &str) {
            m_len = str.m_len;
            copy_data(str.m_data);
        }
        std::cout << "Copy Assignment is called! source: " << str.m_data << std::endl;
        return *this;
    }

    // 用c++11的右值引用來定義這兩個(gè)函數(shù)
    MyString(MyString&& str) {
        std::cout << "Move Constructor is called! source: " << str.m_data << std::endl;
        m_len = str.m_len;
        m_data = str.m_data; //避免了不必要的拷貝
        str.m_len = 0;
        str.m_data = NULL;
    }

    MyString& operator=(MyString&& str) {
        std::cout << "Move Assignment is called! source: " << str.m_data << std::endl;
        if (this != &str) {
            m_len = str.m_len;
            m_data = str.m_data; //避免了不必要的拷貝
            str.m_len = 0;
            str.m_data = NULL;
        }
        return *this;
    }

    virtual ~MyString() {
        if (m_data) free(m_data);
    }
};


int main()
{
    MyString a;
    a = MyString("Hello");      // Move Assignment
    MyString b = a;             // Copy Constructor
    MyString c = std::move(a);  // Move Constructor is called! 將左值轉(zhuǎn)為右值

    std::vector<MyString> vec;
    vec.push_back(MyString("World")); // Move Constructor is called!
    return 0;
}

有了右值引用和轉(zhuǎn)移語義，我們?cè)谠O(shè)計(jì)和實(shí)現(xiàn)類時(shí)，對(duì)于需要?jiǎng)討B(tài)申請(qǐng)大量資源的類，應(yīng)該設(shè)計(jì)右值引
用的拷貝構(gòu)造函數(shù)和賦值函數(shù)，以提高應(yīng)用程序的效率

3.3 forward 完美轉(zhuǎn)發(fā)

forward 完美轉(zhuǎn)發(fā)實(shí)現(xiàn)了參數(shù)在傳遞過程中保持其值屬性的功能，即若是左值，則傳遞之后仍然是左
值，若是右值，則傳遞之后仍然是右值。
現(xiàn)存在一個(gè)函數(shù)

Template<class T>
void func(T &&val);

根據(jù)前面所描述的，這種引用類型既可以對(duì)左值引用，亦可以對(duì)右值引用。
但要注意，引用以后，這個(gè)val值它本質(zhì)上是一個(gè)左值！
看下面例子

int &&a = 10;
int &&b = a; //錯(cuò)誤

注意這里，a是一個(gè)右值引用，但其本身a也有內(nèi)存名字，所以a本身是一個(gè)左值，再用右值引用引用a這
是不對(duì)的。
因此我們有了std::forward()完美轉(zhuǎn)發(fā)，這種T &&val中的val是左值，但如果我們用std::forward (val)，
就會(huì)按照參數(shù)原來的類型轉(zhuǎn)發(fā)；

int &&a = 10;
int &&b = std::forward<int>(a);

這樣是正確的！
通過范例鞏固下知識(shí)：

//2-3-3-forward1
#include <iostream>
using namespace std;
template <class T>
void Print(T &t)
{
cout << "L" << t << endl;
}
template <class T>
void Print(T &&t)
{
cout << "R" << t << endl;
}
template <class T>
void func(T &&t)
{
Print(t);
Print(std::move(t));
Print(std::forward<T>(t));
}
int main()
{
cout << "-- func(1)" << endl;
func(1);
int x = 10;
int y = 20;
cout << "-- func(x)" << endl;
func(x); // x本身是左值
cout << "-- func(std::forward<int>(y))" << endl;
func(std::forward<int>(y)); //
return 0;
}

-- func(1)
L1
R1
R1
-- func(x)
L10
R10
L10
-- func(std::forward(y))
L20
R20
R20

解釋：
func(1) ：由于1是右值，所以未定的引用類型T&&v被一個(gè)右值初始化后變成了一個(gè)右值引用，但是在
func()函數(shù)體內(nèi)部，調(diào)用PrintT(v) 時(shí)，v又變成了一個(gè)左值（因?yàn)樵趕td::forward里它已經(jīng)變成了一個(gè)具
名的變量，所以它是一個(gè)左值），因此，示例測試結(jié)果第一個(gè)PrintT被調(diào)用，打印出“L1"
調(diào)用PrintT（std::forward(v)）時(shí)，由于std::forward會(huì)按參數(shù)原來的類型轉(zhuǎn)發(fā)，因此，它還是一個(gè)右值
（這里已經(jīng)發(fā)生了類型推導(dǎo)，所以這里的T&&不是一個(gè)未定的引用類型，會(huì)調(diào)用void PrintT（T&&t）函
數(shù)打印 “R1”.調(diào)用PrintT(std::move(v))是將v變成一個(gè)右值（v本身也是右值），因此，它將輸出”R1"
func(x)未定的引用類型T&&v被一個(gè)左值初始化后變成了一個(gè)左值引用，因此，在調(diào)用
PrintT(std::forward(v))時(shí)它會(huì)被轉(zhuǎn)發(fā)到void PrintT（T&t）.
forward將左值轉(zhuǎn)換為右值：

MyString str1 = "hello";
MyString str2(str1);
MyString str3 = Fun();
MyString str4 = move(str2);
MyString str5(forward<MyString>(str3));

綜合示例

//2-3-3-forward2
#include "stdio.h"
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
class A
{
public:
    A() : m_ptr(NULL), m_nSize(0) {}
    A(int *ptr, int nSize)
    {
        m_nSize = nSize;
        m_ptr = new int[nSize];
        printf("A(int *ptr, int nSize) m_ptr:%p\n", m_ptr);
        if (m_ptr)
        {
            memcpy(m_ptr, ptr, sizeof(sizeof(int) * nSize));
        }
    }
    A(const A &other) // 拷貝構(gòu)造函數(shù)實(shí)現(xiàn)深拷貝
    {
        m_nSize = other.m_nSize;
        if (other.m_ptr)
        {
            printf("A(const A &other) m_ptr:%p\n", m_ptr);
            if(m_ptr)
                delete[] m_ptr;
            printf("delete[] m_ptr\n");
            m_ptr = new int[m_nSize];
            memcpy(m_ptr, other.m_ptr, sizeof(sizeof(int) * m_nSize));
        }
        else
        {
            if(m_ptr)
                delete[] m_ptr;
            m_ptr = NULL;
        }
        cout << "A(const int &i)" << endl;
    }
    // 右值引用移動(dòng)構(gòu)造函數(shù)
    A(A &&other)
    {
        m_ptr = NULL;
        m_nSize = other.m_nSize;
        if (other.m_ptr)
        {
            m_ptr = move(other.m_ptr); // 移動(dòng)語義
            other.m_ptr = NULL;
        }
    }
    ~A()
    {
        if (m_ptr)
        {
            delete[] m_ptr;
            m_ptr = NULL;
        }
    }
    void deleteptr()
    {
        if (m_ptr)
        {
            delete[] m_ptr;
            m_ptr = NULL;
        }
    }
    int *m_ptr = NULL;  // 增加初始化
    int m_nSize = 0;
};
int main()
{
    int arr[] = {1, 2, 3};
    A a(arr, sizeof(arr) / sizeof(arr[0]));
    cout << "m_ptr in a Addr: 0x" << a.m_ptr << endl;
    A b(a);
    cout << "m_ptr in b Addr: 0x" << b.m_ptr << endl;

    b.deleteptr();
    A c(std::forward<A>(a)); // 完美轉(zhuǎn)換
    cout << "m_ptr in c Addr: 0x" << c.m_ptr << endl;
    c.deleteptr();
    vector<int> vect{1, 2, 3, 4, 5};
    cout << "before move vect size: " << vect.size() << endl;
    vector<int> vect1 = move(vect);
    cout << "after move vect size: " << vect.size() << endl;
    cout << "new vect1 size: " << vect1.size() << endl;
    return 0;
}

3.4 emplace_back 減少內(nèi)存拷貝和移動(dòng)

對(duì)于STL容器，C++11后引入了emplace_back接口。
emplace_back是就地構(gòu)造，不用構(gòu)造后再次復(fù)制到容器中。因此效率更高。
考慮這樣的語句：

vector<string> testVec;
testVec.push_back(string(16, 'a'));

上述語句足夠簡單易懂，將一個(gè)string對(duì)象添加到testVec中。底層實(shí)現(xiàn)：

• 首先，string(16, ‘a(chǎn)’)會(huì)創(chuàng)建一個(gè)string類型的臨時(shí)對(duì)象，這涉及到一次string構(gòu)造過程。
• 其次，vector內(nèi)會(huì)創(chuàng)建一個(gè)新的string對(duì)象，這是第二次構(gòu)造。
• 最后在push_back結(jié)束時(shí)，最開始的臨時(shí)對(duì)象會(huì)被析構(gòu)。加在一起，這兩行代碼會(huì)涉及到兩次
  string構(gòu)造和一次析構(gòu)。
  c++11可以用emplace_back代替push_back，emplace_back可以直接在vector中構(gòu)建一個(gè)對(duì)象，而非
  創(chuàng)建一個(gè)臨時(shí)對(duì)象，再放進(jìn)vector，再銷毀。emplace_back可以省略一次構(gòu)建和一次析構(gòu)，從而達(dá)到優(yōu)
  化的目的。

//2-5-emplace_back
#include <vector>
#include <string>
#include "time_interval.h"

int main() {


    std::vector<std::string> v;
    int count = 10000000;
    v.reserve(count);       //預(yù)分配十萬大小，排除掉分配內(nèi)存的時(shí)間
    {
        TIME_INTERVAL_SCOPE("push_back string:");
        for (int i = 0; i < count; i++)
        {
            std::string temp("ceshi");
            v.push_back(temp);// push_back(const string&)，參數(shù)是左值引用
        }
    }

    v.clear();
    {
        TIME_INTERVAL_SCOPE("push_back move(string):");
        for (int i = 0; i < count; i++)
        {
            std::string temp("ceshi");
            v.push_back(std::move(temp));// push_back(string &&), 參數(shù)是右值引用
        }
    }

    v.clear();
    {
        TIME_INTERVAL_SCOPE("push_back(string):");
        for (int i = 0; i < count; i++)
        {
            v.push_back(std::string("ceshi"));// push_back(string &&), 參數(shù)是右值引用
        }
    }

    v.clear();
    {
        TIME_INTERVAL_SCOPE("push_back(c string):");
        for (int i = 0; i < count; i++)
        {
            v.push_back("ceshi");// push_back(string &&), 參數(shù)是右值引用
        }
    }

    v.clear();
    {
        TIME_INTERVAL_SCOPE("emplace_back(c string):");
        for (int i = 0; i < count; i++)
        {
            v.emplace_back("ceshi");// 只有一次構(gòu)造函數(shù)，不調(diào)用拷貝構(gòu)造函數(shù)，速度最快
        }
    }
}

結(jié)果

push_back string:9439 ms
push_back move(string):8566 ms
push_back(string):7990 ms
push_back(c string):8427 ms
emplace_back(c string):3581 ms

3.5 小結(jié)

C++11 在性能上做了很大的改進(jìn)，最大程度減少了內(nèi)存移動(dòng)和復(fù)制，通過右值引用、 forward、
emplace 和一些無序容器我們可以大幅度改進(jìn)程序性能。

• 右值引用僅僅是通過改變資源的所有者來避免內(nèi)存的拷貝，能大幅度提高性能。
• forward 能根據(jù)參數(shù)的實(shí)際類型轉(zhuǎn)發(fā)給正確的函數(shù)。
• emplace 系列函數(shù)通過直接構(gòu)造對(duì)象的方式避免了內(nèi)存的拷貝和移動(dòng)。

四 匿名函數(shù)lambda

重點(diǎn)：

• 怎么傳遞參數(shù)
• 傳引用還是傳值

4.1匿名函數(shù)的基本語法

[捕獲列表](參數(shù)列表) mutable(可選) 異常屬性 -> 返回類型 {
// 函數(shù)體
}

語法規(guī)則：lambda表達(dá)式可以看成是一般函數(shù)的函數(shù)名被略去，返回值使用了一個(gè) -> 的形式表示。唯
一與普通函數(shù)不同的是增加了“捕獲列表”。

//[捕獲列表](參數(shù)列表)->返回類型{函數(shù)體}
int main()
{
auto Add = [](int a, int b)->int {
return a + b;
};
std::cout << Add(1, 2) << std::endl; //輸出3
return 0;
}

一般情況下，編譯器可以自動(dòng)推斷出lambda表達(dá)式的返回類型，所以我們可以不指定返回類型，即：

//[捕獲列表](參數(shù)列表){函數(shù)體}
int main()
{
auto Add = [](int a, int b) {
return a + b;
};
std::cout << Add(1, 2) << std::endl; //輸出3
return 0;
}

但是如果函數(shù)體內(nèi)有多個(gè)return語句時(shí)，編譯器無法自動(dòng)推斷出返回類型，此時(shí)必須指定返回類型。

//[捕獲列表](參數(shù)列表){函數(shù)體}
int main()
{
auto Add = [](int a, int b) {
return a + b;
};
std::cout << Add(1, 2) << std::endl; //輸出3
return 0;
}

但是如果函數(shù)體內(nèi)有多個(gè)return語句時(shí)，編譯器無法自動(dòng)推斷出返回類型，此時(shí)必須指定返回類型。

4.2 捕獲列表

有時(shí)候，需要在匿名函數(shù)內(nèi)使用外部變量，所以用捕獲列表來傳遞參數(shù)。根據(jù)傳遞參數(shù)的行為，捕獲列
表可分為以下幾種：

1 值捕獲

與參數(shù)傳值類似，值捕獲的前提是變量可以拷貝，不同之處則在于，被捕獲的變量在 lambda表達(dá)式被
創(chuàng)建時(shí)拷貝，而非調(diào)用時(shí)才拷貝：

void test3()
{
cout << "test3" << endl;
int c = 12;
int d = 30;
auto Add = [c, d](int a, int b)->int {
cout << "d = " << d << endl;
return c;
};
d = 20;
std::cout << Add(1, 2) << std::endl;
}

2 引用捕獲

與引用傳參類似，引用捕獲保存的是引用，值會(huì)發(fā)生變化。
如果Add中加入一句：c = a;

void test5()
{
cout << "test5" << endl;
int c = 12;
int d = 30;
auto Add = [&c, &d](int a, int b)->int {
c = a; // 編譯對(duì)的
cout << "d = " << d << endl;
return c;
};
d = 20;
std::cout << Add(1, 2) << std::endl;
}

3 隱式捕獲

手動(dòng)書寫捕獲列表有時(shí)候是非常復(fù)雜的，這種機(jī)械性的工作可以交給編譯器來處理，這時(shí)候可以在捕獲
列表中寫一個(gè) & 或 = 向編譯器聲明采用引用捕獲或者值捕獲。

void test7()
{
cout << "test7" << endl;
int c = 12;
int d = 30;
// 把捕獲列表的&改成=再測試
auto Add = [&](int a, int b)->int {
c = a; // 編譯對(duì)的
cout << "d = " << d << endl;
return c;
};
d = 20;
std::cout << Add(1, 2) << std::endl;
std::cout << "c:" << c<< std::endl;
}

4 空捕獲列表

捕獲列表'[]'中為空，表示Lambda不能使用所在函數(shù)中的變量。

void test8()
{
cout << "test7" << endl;
int c = 12;
int d = 30;
// 把捕獲列表的&改成=再測試
auto Add = [](int a, int b)->int {
cout << "d = " << d << endl; // 編譯報(bào)錯(cuò)
return c;// 編譯報(bào)錯(cuò)
};
d = 20;
std::cout << Add(1, 2) << std::endl;
std::cout << "c:" << c<< std::endl;
}

5 表達(dá)式捕獲

上面提到的值捕獲、引用捕獲都是已經(jīng)在外層作用域聲明的變量，因此這些捕獲方式捕獲的均為左值，
而不能捕獲右值。
C++14之后支持捕獲右值，允許捕獲的成員用任意的表達(dá)式進(jìn)行初始化，被聲明的捕獲變量類型會(huì)根據(jù)
表達(dá)式進(jìn)行判斷，判斷方式與使用 auto 本質(zhì)上是相同的：

void test9()
{
cout << "test9" << endl;
auto important = std::make_unique<int>(1);
auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
return x + y + v1 + (*v2);
};
std::cout << add(3,4) << std::endl;
}

6 泛型 Lambda

在C++14之前，lambda表示的形參只能指定具體的類型，沒法泛型化。從 C++14 開始， Lambda 函數(shù)
的形式參數(shù)可以使用 auto關(guān)鍵字來產(chǎn)生意義上的泛型：

//泛型 Lambda C++14
void test10()
{
cout << "test10" << endl;
auto add = [](auto x, auto y) {
return x+y;
};
std::cout << add(1, 2) << std::endl;
std::cout << add(1.1, 1.2) << std::endl;
}

7 可變lambda

• 采用值捕獲的方式，lambda不能修改其值，如果想要修改，使用mutable修飾
• 采用引用捕獲的方式，lambda可以直接修改其值

void test12() {
cout << "test12" << endl;
int v = 5;
// 值捕獲方式，使用mutable修飾，可以改變捕獲的變量值
auto ff = [v]() mutable {return ++v;};
v = 0;
auto j = ff(); // j為6
}
void test13() {
cout << "test13" << endl;
int v = 5;
// 采用引用捕獲方式，可以直接修改變量值
auto ff = [&v] {return ++v;};
v = 0;
auto j = ff(); // v引用已修改，j為1
}

總結(jié)

1. 如果捕獲列表為[&]，則表示所有的外部變量都按引用傳遞給lambda使用；
2. 如果捕獲列表為[=]，則表示所有的外部變量都按值傳遞給lambda使用；
3. 匿名函數(shù)構(gòu)建的時(shí)候?qū)τ诎粗祩鬟f的捕獲列表，會(huì)立即將當(dāng)前可以取到的值拷貝一份作為常數(shù)，然
   后將該常數(shù)作為參數(shù)傳遞。
   Lambda捕獲列表總結(jié)

五 C++11標(biāo)準(zhǔn)庫(STL)

STL定義了強(qiáng)大的、基于模板的、可復(fù)用的組件，實(shí)現(xiàn)了許多通用的數(shù)據(jù)結(jié)構(gòu)及處理這些數(shù)據(jù)結(jié)構(gòu)的算
法。其中包含三個(gè)關(guān)鍵組件——容器（container，流行的模板數(shù)據(jù)結(jié)構(gòu)）、迭代器（iterator）和算法
（algorithm）。

5.1 容器簡介

STL容器，可將其分為四類：序列容器、有序關(guān)聯(lián)容器、無序關(guān)聯(lián)容器、容器適配器、序列容器：

有序關(guān)聯(lián)容器（鍵按順序保存）：

無序關(guān)聯(lián)容器：

容器適配器：

序列容器描述了線性的數(shù)據(jù)結(jié)構(gòu)（也就是說，其中的元素在概念上” 排成一行"), 例如數(shù)組、向量和 鏈
表。
關(guān)聯(lián)容器描述非線性的容器，它們通常可以快速鎖定其中的元素。這種容器可以存儲(chǔ)值的集合或者鍵－
值對(duì)

棧和隊(duì)列都是在序列容器的基礎(chǔ)上加以約束條件得到的，因此STL把stack和queue作為容器適配器來實(shí)
現(xiàn)，這樣就可以使程序以一種約束方式來處理線性容器。類型string支持的功能跟線性容器一樣， 但是
它只能存儲(chǔ)字符數(shù)據(jù).

5.2 迭代器簡介

迭代器在很多方面與指針類似，也是用于指向首類容器中的元素（還有一些其他用途，后面將會(huì)提
到）。 迭代器存有它們所指的特定容器的狀態(tài)信息，即迭代器對(duì)每種類型的容器都有一個(gè)實(shí)現(xiàn)。 有些迭
代器的操作在不同容器間是統(tǒng)一的。 例如，＊運(yùn)算符間接引用一個(gè)迭代器，這樣就可以使用它所指向的
元素。++運(yùn)算符使得迭代器指向容器中的下一個(gè)元素（和數(shù)組中指針遞增后指向數(shù)組的下一個(gè)元素類
似）。
STL 首類容器提供了成員函數(shù) begin 和 end。函數(shù) begin 返回一個(gè)指向容器中第一個(gè)元素的迭代器，函
數(shù) end 返回一個(gè)指向容器中最后一個(gè)元素的下一個(gè)元素（這個(gè)元素并不存在，常用于判斷是否到達(dá)了容
器的結(jié)束位僅）的迭代器。 如果迭代器 i 指向一個(gè)特定的元素，那么 ++i 指向這個(gè)元素的下一個(gè)元素。*
i 指代的是i指向的元素。 從函數(shù) end 中返回的迭代器只在相等或不等的比較中使用，來判斷這個(gè)“移動(dòng)
的迭代器” （在這里指i)是否到達(dá)了容器的末端。
使用一個(gè) iterator 對(duì)象來指向一個(gè)可以修改的容器元素，使用一個(gè) const_iterator 對(duì)象來指向一個(gè)不能
修改的容器元素。

每種容器所支持的迭代器類型決定了這種容器是否可以在指定的 STL 算 法中使用。 支持隨機(jī)訪問迭代
器的容器可用于所有的 STL 算法（除了那些需要改變?nèi)萜鞔笮〉乃惴ǎ@樣的算法不能在數(shù)組和 array
對(duì)象中使用）。 指向 數(shù)組的指針可以代替迭代器用于幾乎所有的 STL 算法中，包括那些要求隨機(jī)訪問
迭代器的算法。 下表顯示了每種 STL 容器所支持的迭代器類型。 注意， vector 、 deque 、 list 、 set、 multiset 、 map 、 multimap以及 string 和數(shù)組都可以使用迭代器遍歷.

下表顯示了在 STL容器的類定義中出現(xiàn)的幾種預(yù)定義的迭代器 typedef。不是每種 typedef 都出現(xiàn)在每
個(gè)容器中。 我們使用常量版本的迭代器來訪問只讀容器或不應(yīng)該被更改的非只讀容器，使用反向迭代器
來以相反的方向訪問容器。

下表顯示了可作用在每種迭代器上的操作。 除了給出的對(duì)于所有迭代器都有的運(yùn)算符，迭代器還必須提
供默認(rèn)構(gòu)造函數(shù)、拷貝構(gòu)造函數(shù)和拷貝賦值操作符。 前向迭代器支持＋＋ 和所有的輸入和輸出迭代器的
功能。 雙向迭代器支持–操作和前向迭代器的功能。 隨機(jī)訪問迭代器支持所有在表中給出的操作。 另
外， 對(duì)于輸入迭代器和輸出迭代器，不能在保存迭代器之后再使用保存的值

5.3 map與unordered_map（紅黑樹VS哈希表）

C++11 增加了無序容器 unordered_map/unordered_multimap 和
unordered_set/unordered_multiset，由于這些容器中的元素是不排序的，因此，比有序容器
map/multimap 和 set/multiset 效率更高。 map 和 set 內(nèi)部是紅黑樹，在插入元素時(shí)會(huì)自動(dòng)排序，而
無序容器內(nèi)部是散列表（ Hash Table），通過哈希（ Hash），而不是排序來快速操作元素，使得效率
更高。由于無序容器內(nèi)部是散列表，因此無序容器的 key 需要提供 hash_value 函數(shù)，其他用法和
map/set 的用法是一樣的。不過對(duì)于自定義的 key，需要提供 Hash 函數(shù)和比較函數(shù)。

5.3.1 map和unordered_map的差別

需要引入的頭文件不同

map: #include < map >
unordered_map: #include < unordered_map >

內(nèi)部實(shí)現(xiàn)機(jī)理不同

• map： map內(nèi)部實(shí)現(xiàn)了一個(gè)紅黑樹（紅黑樹是非嚴(yán)格平衡二叉搜索樹，而AVL是嚴(yán)格平衡二叉搜
  索樹），紅黑樹具有自動(dòng)排序的功能，因此map內(nèi)部的所有元素都是有序的，紅黑樹的每一個(gè)節(jié)點(diǎn)
  都代表著map的一個(gè)元素。
• unordered_map: unordered_map內(nèi)部實(shí)現(xiàn)了一個(gè)哈希表（也叫散列表，通過把關(guān)鍵碼值映射到
  Hash表中一個(gè)位置來訪問記錄，查找的時(shí)間復(fù)雜度可達(dá)到O(1)，其在海量數(shù)據(jù)處理中有著廣泛應(yīng)
  用）。因此，其元素的排列順序是無序的。

5.3.2 優(yōu)缺點(diǎn)以及適用處

map：

1. 優(yōu)點(diǎn)：

• 有序性，這是map結(jié)構(gòu)最大的優(yōu)點(diǎn)，其元素的有序性在很多應(yīng)用中都會(huì)簡化很多的操作
• 紅黑樹，內(nèi)部實(shí)現(xiàn)一個(gè)紅黑書使得map的很多操作在lgn的時(shí)間復(fù)雜度下就可以實(shí)現(xiàn)，因此效率非
  常的高

2. 缺點(diǎn)：

• 空間占用率高，因?yàn)閙ap內(nèi)部實(shí)現(xiàn)了紅黑樹，雖然提高了運(yùn)行效率，但是因?yàn)槊恳粋€(gè)節(jié)點(diǎn)都需要額
  外保存父節(jié)點(diǎn)、孩子節(jié)點(diǎn)和紅/黑性質(zhì)，使得每一個(gè)節(jié)點(diǎn)都占用大量的空間

3. 適用處：
   對(duì)于那些有順序要求的問題，用map會(huì)更高效一些

unordered_map：

1. 優(yōu)點(diǎn)： 因?yàn)閮?nèi)部實(shí)現(xiàn)了哈希表，因此其查找速度非常的快
2. 缺點(diǎn)： 哈希表的建立比較耗費(fèi)時(shí)間
3. 適用處：對(duì)于查找問題，unordered_map會(huì)更加高效一些，因此遇到查找問題，常會(huì)考慮一下用unordered_map

5.3.3 總結(jié)

1. 內(nèi)存占有率的問題就轉(zhuǎn)化成紅黑樹 VS hash表 , 還是unorder_map占用的內(nèi)存要高。
2. 但是unordered_map執(zhí)行效率要比map高很多
3. 對(duì)于unordered_map或unordered_set容器，其遍歷順序與創(chuàng)建該容器時(shí)輸入的順序不一定相
   同，因?yàn)楸闅v是按照哈希表從前往后依次遍歷的

推薦一個(gè)零聲學(xué)院免費(fèi)教程，個(gè)人覺得老師講得不錯(cuò)，
分享給大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，
fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，
TCP/IP，協(xié)程，DPDK等技術(shù)內(nèi)容，點(diǎn)擊立即學(xué)習(xí):
服務(wù)器
音視頻
dpdk
Linux內(nèi)核