动态数组
C++语言定义了第二种new表达式语法。能够分配并初始化一个对象数组。标准库中包括
一个名为allocator的类。同意我们将分配和初始化分离。
一个名为allocator的类。同意我们将分配和初始化分离。
12.2.1 new和数组
void fun1()
{
int *pia=new int[2]; //pia指向第一个int
//方括号里的大小必须是整型，但不必是常量
typedef int arrT[42]; //arrT表示42个int的数组类型
int *p=new arrT; //分配一个42个int的数组；p指向第一个int
//实际上，编译的时候还是这种
int *p1=new int[42];
}
分配一个数组会得到一个元素类型的指针
因为分配的内存并非一个数组类型。因此不能对动态数组调用begin或end
也不能使用范围for语句来处理动态数组中的元素
也不能使用范围for语句来处理动态数组中的元素
初始化动态分配对象的数组
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=10,n2=0;
int *p=new int[n]; //分配数组保存元素
for(int* q=p ; q != p ; ++q)
{
/* 处理数组 */
}
若n为0，new会分配0个对象。
for循环中的条件会失败(p等于q+n,由于n为0)。
因此,循环体不会被运行
释放动态数组
int *p=new int;
int *pa=new int[110];
//为了释放动态数组，我们使用一种特殊形式的delete——在指针前加上一方括号对
delete p; //p必须指向一个动态分配的对象或为空
delete [] pa; //pa必须指向一个动态分配的数组或为空 typedef int arrT[42]; //arrT是42个int的数组的类型别名
int *p1=new arrT; //分配一个42个int的数组;p指向第一个元素
delete [] p1; //方括号是必须的，由于我们当初分配的是一个动态数组
无论外面怎样，p指向的是一个对象数组的首元素，而不是一个类型为arrT的单一对象。
因此释放的时候必须加上方括号
智能指针和动态数组
//up指向一个包括10个未初始化的int的数组
unique_ptr<int[]> up(new int[10]);
up.release(); //自己主动用delete[]销毁其指针
//当一个unique_ptr指向一个动态数组的时候我们能够用下标訪问数组中的元素
for(size_t i=0 ; i != 10 ; ++i)
up[i]=i; //为每一个元素赋予一个新值
和unique_ptr不同，shared_ptr不直接支持管理动态数组。
假设希望shared_ptr管理一个动态
数组。那么就必须自己提供自定义的删除器
//为了适应shared_ptr,必须提供自定义的删除器
shared_ptr<int> sp(new int[10], [](int *p){delete [] p;});
sp.reset(); //使用我们提供的lambda释放数组，它使用delete[]
//shared_ptr没有定义下标运算，也不支持下标运算
for(size_t i=0 ; i != 10 ; ++i)
*(sp.get()+i)=i; //使用get获取一个内置指针
12.23
/**
12.23
编写一个程序，链接两个字符串字面常量，将结果保存在一个动态分配的char数组中
重写这个程序。连接两个标准库string对象
*/
void fun6()
{
string s1="cutter",s2="_point";
unique_ptr<char[]> upc(new char[20]); for(size_t i=0 ; i != s1.size()+s2.size() ; ++i)
{
if(i < s1.size())
upc[i]=s1[i];
else
upc[i]=s2[i-s1.size()];
} for(int j=0 ; j != 20 ; ++j)
cout<<upc[j]; upc.release(); //自己主动用delete[]销毁其指针 }
12.2.2allocator类
普通情况下。将内存分配和对象构造结合在一起可能会导致不必要的浪费
int n;
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[]来释放
可是。我们可能不须要n个string，少量string可能就足够了。
allocator类
int n;
allocator<string> alloc; //可分配string的allocator对象
auto const p=alloc.allocate(n); //分配n各未初始化的string
/*
allocator分配微构造的内存
*/
auto q=p; //这里q指向和p一样
alloc.construct(q++); //*q为空字符串
alloc.construct(q++, 10, 'c'); //*q为cccccccccc
alloc.construct(q++, "hi"); //*q为hi!
//q指向最后构造的元素之后的位置
cout<<*p<<endl; //正确；使用string输出运算符
// cout<<*q<<endl; //灾难：q指向微构造的内存 while(q != p)
alloc.destroy(--q); //释放我们真正构造的string
所有代码展示
/**
* 功能:动态数组
* 时间:2014年7月9日10:05:01
* 作者:cutter_point
*/ #include<iostream>
#include<memory>
#include<string>
#include<vector> using namespace std; /**
C++语言定义了第二种new表达式语法，能够分配并初始化一个对象数组。 标准库中包括
一个名为allocator的类，同意我们将分配和初始化分离。
*/ /**
12.2.1 new和数组
*/
void fun1()
{
int *pia=new int[2]; //pia指向第一个int
//方括号里的大小必须是整型。但不必是常量
typedef int arrT[42]; //arrT表示42个int的数组类型
int *p=new arrT; //分配一个42个int的数组。p指向第一个int
//实际上，编译的时候还是这种
int *p1=new int[42];
} /**
分配一个数组会得到一个元素类型的指针
*/ /*
由于分配的内存并非一个数组类型，因此不能对动态数组调用begin或end
也不能使用范围for语句来处理动态数组中的元素
*/ /**
初始化动态分配对象的数组
*/
void fun2()
{
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')};
} /**
动态分配一个空数组是合法的
*/
void fun3()
{
size_t n=10,n2=0;
int *p=new int[n]; //分配数组保存元素
for(int* q=p ; q != p ; ++q)
{
/* 处理数组 */
} /*
若n为0。new会分配0个对象。 for循环中的条件会失败(p等于q+n,由于n为0)。 因此,循环体不会被运行
*/
} /**
释放动态数组
*/
void fun4()
{
int *p=new int;
int *pa=new int[110];
//为了释放动态数组。我们使用一种特殊形式的delete——在指针前加上一方括号对
delete p; //p必须指向一个动态分配的对象或为空
delete [] pa; //pa必须指向一个动态分配的数组或为空 typedef int arrT[42]; //arrT是42个int的数组的类型别名
int *p1=new arrT; //分配一个42个int的数组;p指向第一个元素
delete [] p1; //方括号是必须的，由于我们当初分配的是一个动态数组 /*
无论外面怎样，p指向的是一个对象数组的首元素。而不是一个类型为arrT的单一对象。
因此释放的时候必须加上方括号
*/
} /**
智能指针和动态数组
*/
void fun5()
{
//up指向一个包括10个未初始化的int的数组
unique_ptr<int[]> up(new int[10]);
up.release(); //自己主动用delete[]销毁其指针
//当一个unique_ptr指向一个动态数组的时候我们能够用下标訪问数组中的元素
for(size_t i=0 ; i != 10 ; ++i)
up[i]=i; //为每一个元素赋予一个新值
/*
和unique_ptr不同，shared_ptr不直接支持管理动态数组。 假设希望shared_ptr管理一个动态
数组，那么就必须自己提供自定义的删除器
*/
//为了适应shared_ptr,必须提供自定义的删除器
shared_ptr<int> sp(new int[10], [](int *p){delete [] p;});
sp.reset(); //使用我们提供的lambda释放数组，它使用delete[]
//shared_ptr没有定义下标运算，也不支持下标运算
for(size_t i=0 ; i != 10 ; ++i)
*(sp.get()+i)=i; //使用get获取一个内置指针
} /**
12.23
编写一个程序，链接两个字符串字面常量，将结果保存在一个动态分配的char数组中
重写这个程序，连接两个标准库string对象
*/
void fun6()
{
string s1="cutter",s2="_point";
unique_ptr<char[]> upc(new char[20]); for(size_t i=0 ; i != s1.size()+s2.size() ; ++i)
{
if(i < s1.size())
upc[i]=s1[i];
else
upc[i]=s2[i-s1.size()];
} for(int j=0 ; j != 20 ; ++j)
cout<<upc[j]; upc.release(); //自己主动用delete[]销毁其指针 } /**
allocator类
*/
/*
普通情况下，将内存分配和对象构造结合在一起可能会导致不必要的浪费
*/
void fun7()
{
int n;
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[]来释放
/*
可是。我们可能不须要n个string。少量string可能就足够了。 */
} /*
allocator类
*/
void fun8()
{
int n;
allocator<string> alloc; //可分配string的allocator对象
auto const p=alloc.allocate(n); //分配n各未初始化的string
/*
allocator分配微构造的内存
*/
auto q=p; //这里q指向和p一样
alloc.construct(q++); //*q为空字符串
alloc.construct(q++, 10, 'c'); //*q为cccccccccc
alloc.construct(q++, "hi"); //*q为hi!
//q指向最后构造的元素之后的位置
cout<<*p<<endl; //正确；使用string输出运算符
// cout<<*q<<endl; //灾难：q指向微构造的内存 while(q != p)
alloc.destroy(--q); //释放我们真正构造的string
} int main()
{
fun6();
return 0;
}
PS：花了一早上，就搞了这么点东西，尽管中途歇息了一会。而且还玩了半个多小时的游戏
，可是哥还是把这玩意所有搞完了，哈哈搞完了就能够好好玩一玩啦！！