C++ Primer记录

• AutoPoint.h

#pragma once

struct NULLPOINTER
{

};

template
class AutoPoint
{
public:

	~AutoPoint();

	AutoPoint():BindPoint(nullptr){}

	explicit AutoPoint(T* OutPoint);

	AutoPoint(AutoPoint& Other);
	AutoPoint(AutoPoint&& Other);

	T* operator->();

	AutoPoint& operator=(NULLPOINTER* Point);
	AutoPoint& operator=(AutoPoint& Other);//拷贝赋值运算符重载
	AutoPoint& operator=(AutoPoint&& Other);
	bool operator==(const AutoPoint& Other);
	bool operator!=(const AutoPoint& Other);



	//删除new关键字
	void* operator new(size_t) = delete;

	//转换规则，从当前类型到布尔的转换规则explicit禁止隐士转换
	explicit operator bool()
	{
		return BindPoint != nullptr;
	}

	void Free();
public:
	T* BindPoint;
};

template
AutoPoint::AutoPoint(AutoPoint&& Other)
{
	if (Other.BindPoint)
	{
		BindPoint = Other.BindPoint;
		Other.BindPoint = nullptr;
	}
}

template
AutoPoint& AutoPoint::operator=(AutoPoint&& Other)
{
	if (Other.BindPoint)
	{
		Free();
		BindPoint = Other.BindPoint;
		Other.BindPoint = nullptr;
	}
}

template
bool AutoPoint::operator!=(const AutoPoint& Other)
{
	return BindPoint != Other.BindPoint;
}

template
bool AutoPoint::operator==(const AutoPoint& Other)
{
	return BindPoint == Other.BindPoint;
}

template
AutoPoint& AutoPoint::operator=(AutoPoint& Other)
{
	if (!Other.BindPoint)
	{
		return *this;
	}
	//先要释放掉旧的内存引用计数
	Free();
	BindPoint = Other.BindPoint;
	PointReferenceManager::Get()->AddPointReference(BindPoint);
	return *this;
}

template
AutoPoint& AutoPoint::operator=(NULLPOINTER* Point)
{
	if (!Point)
	{
		Free();
	}
	return *this;
}

template
void AutoPoint::Free()
{
	if (BindPoint)
	{
		int Counter = PointReferenceManager::Get()->RemovePointReference(BindPoint);
		if (Counter<=0)
		{
			delete BindPoint;
		}
		BindPoint = nullptr;
	}
}

template
T* AutoPoint::operator->()
{
	return BindPoint;
}

template
AutoPoint::~AutoPoint()
{
	Free();
}

template
AutoPoint::AutoPoint(T* OutPoint)
{
	BindPoint = OutPoint;
	PointReferenceManager::Get()->AddPointReference(BindPoint);
}

template
AutoPoint::AutoPoint(AutoPoint& Other)
{
	if (!Other.BindPoint)
	{
		return;
	}
	BindPoint = Other.BindPoint;
	PointReferenceManager::Get()->AddPointReference(BindPoint);
}

• PointReferenceManager.h

#include 
#include 

• PointReferenceManager.cpp

#include "PointReferenceManager.h"

PointReferenceManager* PointReferenceManager::Get()
{
	static PointReferenceManager* Instance = new PointReferenceManager;
	return Instance;
}

void PointReferenceManager::AddPointReference(void* Point)
{
	//检查之前是否有人存过这个地址
	auto iter = CounterMap.find(Point);
	if (iter==CounterMap.end())
	{
		CounterMap.insert(pair(Point,1));
	}
	else
	{
		CounterMap[Point]++;
	}
}

int PointReferenceManager::RemovePointReference(void* Point)
{
	int Count = 0;
	//检查之前是否有人存过这个地址
	auto iter = CounterMap.find(Point);
	if (iter != CounterMap.end())
	{
		Count = CounterMap[Point];
		Count--;
		if (CounterMap[Point]<=0)
		{
			//删除给定地址的引用计数条目
			CounterMap.erase(iter);
			Count = 0;
		}
		else
		{
			CounterMap[Point] = Count;
		}
	}
	return Count;
}

int PointReferenceManager::GetPointReferenceCounter(void* Point)
{
	int Count = 0;
	auto iter = CounterMap.find(Point);
	if (iter!=CounterMap.end())
	{
		Count=CounterMap[Point];
	}
	return Count;
}

• 使用new动态分配和初始化对象。

int *pi = new int; // pi指向一个动态分配的、未初始化的无名对象

• 类类型对象将用默认构造函数进行初始化。

string *ps = new string; //初始化为空string
int *pi = new int;       // pi指向一个未初始化的int

• 可以使用直接初始化方式初始化一个动态分配的对象。

int *pi = new int(l024);          // pi指向的对象的值为1024
string *ps = new string(10, '9'); /)
{
    //获得一个连接；记住使用完后要关闭它
    connection c = connect(&d);
    //使用连接
    //如果我们在f退出前忘记调用disconnect, 就元法关闭c了
}

• 删除器函数能够完成对shared_ptr中保存的指针进行释放的操作。

struct destination;                //表示我们正在连接什么
struct connection;                 //使用连接所需的信息
connection connect(destination *); //打开连接
void disconnect(connection);       //关闭给定的连接
void end_connection(connection *p) { disconnect(*p); }

void f(destination &d )
{
    connection c = connect(&d);
    shared ptr p(&c, end_connection);
    //使用连接
    //当f退出时（即使是由于异常而退出），connec巨on会被正确关闭
}

• 一个unique_ptr拥有它所指向的对象，每个时刻只有一个unique_ptr指向一个给定对象。

unique_ptr p1;           //可以指向一个double的unique_ptr
unique_ptr p2(new int(42)); // p2指向一个值为42的int

• unique_ptr不支持普通的拷贝或赋值操作。

unique_ptr p1(new string("Stegosaurus"));
unique_ptr p2(p1); //错误：unique_ptr不支持拷贝
unique_ptr p3;
p3 = p2; //错误：unique_ptr不支持赋值

• 不能拷贝或赋值unique_ptr，但可以通过调用release或reset将指针的所有权从一个（非const）unique_ptr转移给另个unique。

//将所有权从p1(指向string Stegosaurus)转移给p2
unique_ptr p2(p1.release()); // release将p1置为空

unique_ptr p3(new string("Trex"));
//将所有权从p3转移给p2
p2.reset(p3.release()); // reset释放了p2原来指向的内存

• 调用release会切断unique_ptr和它原来管理的对象间的联系。

p2.release();          //错误：p2不会释放内存，而且我们丢失了指针
auto p = p2.release(); //正确，但我们必须记得delete(p)

• 可以拷贝或赋值一个将要被销毁的unique_ptr。
• 对于两段代码，编译器都知道要返回的对象将要被销毁，在此情况下，编译器执行一种特殊的拷贝。

unique_ptr clone(int p)
{
    //正确：从int*创建一个unique_ptr
    return unique_ptr(new int(p));
}

unique_ptr clone(int p)
{
    unique_ptr ret(new int(p));
    // ...
    return ret;
}

• 向unique_ptr传递删除器。

// p指向一个类型为objT的对象，并使用一个类型为delT的对象释放objT对象
//它会调用一个名为fcn的delT类型对象
unique_ptr p(new objT, fen);

• 重写连接程序，使用了decltype来指明函数指针类型。

void f(destination &d )
{
    connection c = connect(&d); //打开连接
    //当p被销毁时，连接将会关闭
    unique ptr p(&c, end connection);
    //使用连接
    //当f退出时（即使是由于异常而退出），connection会被正确关闭
}

• weak_ptr是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr管理的对象。

• 当创建一个weak_ptr时，要用一个shared_ptr来初始化它。

auto p = make_shared(42);
weak_ptr wp(p); // wp弱共享p，p的引用计数未改变

• 由于对象可能不存在，我们不能使用weak_ptr直接访问对象，而必须调用lock，此函数检查weak_ptr指向的对象是否仍存在。

if (shared_ptr np = wp.lock()) //如果np不为空则条件成立
{
    //在if中，np与p共享对象
}

• 标准库中包含一名为allocator的类，允许我们将分配和初始化分离，使用allocator通常会提供更好的性能和更灵活的内存管理能力。

• 在下例中，new分配要求数量的对象并返回指向第一个对象的指针。

//调用get_size确定分配多少个int
int *pia= new int[get_size()];//pia指向第一个int

• 可以用一个表示数组类型的类型别名来分配一个数组。

typedef int arrT[42]; // arrT表示42个int的数组类型
int *p = new arrT;    //分配一个42个int的数组，p指向笫一个int

• 动态数组并不是数组类型。
• 默认情况下，new分配的对象，不管是单个分配的还是数组中的，都是默认初始化的。

int *pia = new int[10];          // 10个未初始化的int
int *pia2 = new int[10]();       // 10个值初始化为0的int
string *psa = new string[10];    // 10个空string
string *psa2 = new string[10](); // 10个空string

• 在新标准中，我们还可以提供一个元素初始化器的花括号列表。

// 10个int分别用列表中对应的初始化器初始化
int *pia3 = new int[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
// 10个string,前4个用给定的初始化器初始化，剩余的进行值初始化
string *psa3 = new string[10]{"a", "an", "the", string(3, 'x')};

• 动态分配一个空数组是合法的。

size_t n = get_size(); // get_size返回需要的元素的数目
int *p = new int[n];   //分配数组保存元素
for (int *q = p; q != p + n; ++q)

• 当n等于0时，调用new[n]是合法的。

char arr[0];            //错误：不能定义长度为0的数组
char *cp = new char[0]; //正确：但cp不能解引用

• 释放动态数组。
• 销毁pa指向的数组中的元素，并释放对应的内存。
• 按逆序销毁。

delete p;    // p必须指向一个动态分配的对象或为空
delete[] pa; // pa必须指向一个动态分配的数组或为空

• 使用类型别名定义时释放也一样。

typedef int arrT[42]; // arrT表示42个int的数组类型
int *p = new arrT;    //分配一个42个int的数组，p指向笫一个int
delete[] p;           //方括号是必需的，因为我们当初分配的是一个数组

• 智能指针和动态数组。

// up指向一个包含10个未初始化int的数组
unique_ptr up(new int[10]);
up.release(); //自动用delete[]销毁其指针

• 可以使用下标运算符来访问数组中的元素。

for (size_t i = 0; i != 10; ++i)
{
    up[i] = i; //为每个元素赋子一个新值
}

• 与unique_ptr不同，shared_ptr不直接支持管理动态数组。
• 如果希望使用shared_ptr管理一个动态数组，必须提供自己定义的删除器。

//为了使用shared_ptr, 必须提供一个删除器
shared_ptr sp(new int[10], [](int *p)
                   { delete[] p; });
sp.reset(); //使用我们提供的lambda释放数组，它使用delete[]

• shared_ptr不直接支持动态数组管理这一特性会影响我们如何访问数组中的元素。
• 为了访问数组中的元素，必须用get获取一个内置指针，然后用它来访问数组元素

// shared_ptr未定义下标运算符，并且不支持指针的算术运算
for (size_t i = 0; i != 10; ++i)
{
    *(sp.get() + i) = i; //使用get获取一个内置指针
}

• 将内存分配和对象构造组合在一起会导致不必要的浪费。
• 没有默认构造函数的类就不能动态分配数组。

string *const p = new string[n];
//构造n个空string
string s;
string *q = p; // q指向笫一个string
while (cin >> s && q != p + n)
{
    *q++ = s; //赋予*q一个新值
}
const size_t size = q - p; //记住我们读取了多少个string
//使用数组
delete[] p; // p指向一个数组；记得用delete[]来释放

• 标准库allocator类定义在头文件memory中，帮助我们将内存分配和对象构造分离开来。
• allocator是一个模板。

allocator alloc;          //可以分配string的allocator对象
auto const p = alloc.allocate(n); //分配n个未初始化的string

• allocator分配未构造的内存。

auto q = p;                       // q指向最后构造的元素之后的位置
alloc.construct(q++);             // *q为空宇符串
alloc.construct(q++, 10, 'c');    // *q为cccccccccc
alloc.construct(q++, "hi");       // *q为hi!

• 还未构造对象的清况下就使用原始内存是错误的。
• 用完对象后，必须对每个构造的元素调用destroy来销毁它们。

while (q != p)
{
    alloc.destroy(--q); //释放我们真正构造的string
}

• 最后释放内存。

alloc.deallocate(p, n) 

• 标准库还为allocator类定义了两个伴随算法，可以在未初始化内存中创建对象。

• 分配一块比vector中元素所占用空间大一倍的动态内存，然后将原vector中的元素拷贝到前一半空间，对后一半空间用一个给定值进行填充。

//分配比vi中元素所占用空间大一倍的动态内存
auto p = alloc.allocate(vi.size() * 2);
//通过拷贝vi中的元素来构造从p开始的元素
auto q = uninitialized_copy(vi.begin(), vi.end(), p);
//将剩余元素初始化为42
uninitialized_fill_n(q, vi.size(), 42);

• 略

• 略

• 略