c++动态数组

发表于

一、new和数组
用new分配一个对象数组。

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

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

1
2
3
4
typedef int arrT[42];	//arrT表示42个int的数组类型
int *p = new arrT;	//分配一个42个int的数组；p指向第一个int
//编译器实际会执行：
int *p = new int[42];

分配一个数组会得到一个元素类型的指针

初始化动态分配对象的数组，在大小之后跟一对空括号。

1
2
3
4
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

新标准中，可用花括号列表初始化。

1
2
int *pia3 = new int[10]{0,1,2,3,4,5,6,7,8,9};
string *psa3 = new string[10]{"a","an","the",string(3,'x')};//其余为空

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

1
2
3
4
5
6
7
8
9
10
//遍历数组
size_t n = get_size();
int* p = new int[n];
for(int* q = p;q != p+n; ++q)
{
	//
}

char arr[0];	//错误：不能定义长度为0的数组
char *cp = new char[0];	//正确：但cp不能解引用，此指针像尾后迭代器

释放动态数组

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

typedef int arrT[42];
int *p = new arrT;
delete[] p;

unique_ptr和动态数组

为了用一个unique_ptr管理动态数组，必须在对象类型后面跟一对空括号,用来标识up指向一个int数组而不是一个int。销毁up指向的一个数组，会自动使用delete[]。

1
2
unique_ptr<int[]> up(new int[10]);
up.release();		//自动用delete[]销毁其指针

当一个unique_ptr指向一个数组时，我们不能使用点和箭头成员运算符。毕竟指向的是一个数组而不是单个对象。
可以使用下标运算符来访问数组中的元素。

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

指向数组的unique_ptr

指向数组的unique_ptr不支持成员访问运算符(点和箭头)。
其他unique_ptr操作不变。

语法 解释
unique_ptr< T[] > u u可以指向一个动态分配的数组，数组元素类型为T
unique_ptr< T[] > u(p) u指向内置指针p所指向的动态分配的数组。p必须能转换为类型T*
u[i] 返回u拥有的数组中位置i处的对象。u必须指向一个数组。

shared_ptr和动态数组

shared_ptr不支持管理动态数组。如果希望支持，必须提供自己定义的删除器。

1
2
shared_ptr<int> sp(new int[10], [](int *p){delete []p;});
sp.reset();	//使用自定义的lambda释放数组，使用delete[]

如果未提供删除器，这段代码将是未定义的。默认情况下shared_ptr使用delete摧毁它指向的对象。

shared_ptr未定义下标运算符，而且智能指针类型不支持指针算术运算。

1
2
for(size_t i = 0; i != 10; ++i)
	*(sp.get() + i) = i;	//使用get获取一个内置指针

二、allocator类

new讲内存分配和对象构造组合在了一起，delete讲对象析构和内存释放组合在了一起。

当分配一大块内存时，计划在这块内存上按需构造对象。在此情况下，希望将内存分配和对象构造分离。这意味着我们可以分配大块内存，但真正需要时才真正执行对象创建操作。

定义在memory中。

用法如下。

语法 解释
allocator< T[] > a 定义了一个名为a的allocator对象，它可以为类型为T的对象分配内存
a.allocate(n) 分配一段原始的、未构造的内存，保存n个类型为T的对象
a.deallocate(p,n) 释放从T*指针p中地址开始的内存，这块内存保存了n个类型为T的对象；p必须是一个先前由allocate返回的指针，且n必须是p创建时所要求的大小。在调用deallocate之前，用户必须对每个在这块内存中创建的对象调用destroy
a.construct(p, args) p必须是一个类型为T*的指针，指向一块原始内存：arg被传递给类型为T的构造函数，用来在p指向的内存中构造一个对象
a.destroy(p) p为T*类型的指针，此算法对p指向的对象执行析构函数

allocator分配的内存是未构造的。

1
2
allocator<string> alloc;		//可以分配string的allocator对象
auto const p = alloc.allocate(n);		//分配n个未初始化的string，p是const指针。

allocator分配未构造的内存

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

还未构造对象情况下，就使用原始内存是错误的。

1
2
cout<<*p<<endl;	//正确：使用string的输出运算符
cout<<*q<<endl;	//灾难：q指向未构造的内存！

注意：allocator分配内存后，必须用construct构造对象。

用完对象后，必须对每个构造的元素调用destroy来销毁。

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

释放内存。

1
alloc.deallocate(p, n);	//p指向内存初始位置，n与allocate大小一致。

拷贝和填充未初始化内存的算法

语法 解释
uninitialized_copy(b,e,b2) 从迭代器b和e指出的输入范围中拷贝元素到迭代器b2指定的未构造的原始内存中。b2指向的内存必须足够大，能够容纳输入序列中元素的拷贝
uninitialized_copy_n(b,n,b2) 从迭代器b指向的元素开始，拷贝n个元素到b2开始的内存中
uninitialized_fill(b,e,t) 从迭代器b和e指出的输入范围中拷贝元素到迭代器b2指定的未构造的原始内存中。b2指向的内存必须足够大，能够容纳输入序列中元素的拷贝
uninitialized_fill_n(b,n,t) 从迭代器b指向的内存地址开始创建n个对象。b必须指向足够大的未构造的原始内存，能够容纳给定数量的对象 
1
2
3
4
5
6
7
vector<int> vi{1,2,3,4,5,6,7,8,9};

auto p = alloc.allocate(vi.begin(), vi.end(), vi.size()*2);

auto q = uninitilized_copy(vi.begin(), vi.end(), p);//返回一个指针，指向最后一个构造的元素之后的位置。

unitialized_fill_n(q, vi.size(),42);	//返回void