1.定长数组:array 头文件
实际用法数组怎么用 我们就怎么用
正常的使用
#include<iostream>
#include<array>
#include<string>
using namespace std;
int main()
{
array<int, 4> test = { 9,9,9 }; //元素类型为int ,个数为4
array<string, 5> teststring = { "狐狸","狐狸2" }; //元素类型为string ,个数为5
cout << teststring.size() << endl;//数组的元素个数
for (int i = 0; i < teststring.size(); i++)
{
cout << teststring[i] << endl;//通过下标去访问就好了
}
return 0;
}
实际上这个就是一个类模板,我们也可以实现模拟出一个Myarray
#include<iostream>
#include<array>
#include<string>
using namespace std;
template <class _Ty, size_t size>
class Foxarray
{
public:
Foxarray()
{
memroy = new _Ty[size];//所谓数组就是动态内存申请
mysize = size;
}
_Ty& operator[](int index)//重载运算符 从而实现下标访问我们定义类的操作
{
return memroy[index];
}
size_t Foxsize()
{
return mysize;
}
~Foxarray()//做了动态内存申请了 要记得写析构函数
{
delete[] memroy;
}
protected:
_Ty* memroy;
size_t mysize;
};
int main()
{
Foxarray < string, 3 > fox;//因为我没写多的构造函数,所以得通过下标访问去做插入
for (int i = 0; i <fox.Foxsize(); i++)
{
cin >> fox[i];
}
for (int i = 0; i < fox.Foxsize(); i++)//输出结果看一下
{
cout << fox[i];
}
return 0;
}
在容器中 有一个叫做迭代器的东西,它的本质是类的对象模仿指针的操作
在C++中 逐渐模糊化 淡化C语言指针的概念影响。
int main()
{
array<int, 4>arr= {1, 2, 3, 4};
array<int, 4>::iterator iter;//迭代器类对象的创建
for (iter = arr.begin(); iter < arr.end(); iter++)//迭代器访问
{
cout << *iter << endl;
}
}
当然这种操作最关键的点呢,是运算符重载,我们也可以为我们写的array类进行迭代器操作
#include<iostream>
#include<array>
#include<string>
using namespace std;
template <class _Ty, size_t size>
class Foxarray
{
public:
Foxarray()
{
memroy = new _Ty[size];//所谓数组就是动态内存申请
mysize = size;
}
_Ty& operator[](int index)//重载运算符 从而实现下标访问我们定义类的操作
{
return memroy[index];
}
_Ty* begin()
{
return memroy + 0;
}
_Ty* end()
{
return memroy + size;
}
~Foxarray()//做了动态内存申请了 要记得写析构函数
{
delete[] memroy;
}
class MyIterator
{
public:
MyIterator(_Ty* pmove = nullptr) :pmove(pmove) {}//缺省写法 ,为无参构造函数做准备
void operator=(_Ty* pmove)
{
this->pmove = pmove;
}
bool operator!=(_Ty* pmove)
{
return this->pmove != pmove;
}
MyIterator operator++(int)
{
this->pmove++;
return *this;
}
_Ty operator*()
{
return *pmove;
}
protected:
_Ty* pmove;
};
protected:
_Ty* memroy;
size_t mysize;
};
int main()
{
Foxarray<char, 3> Foxchar;
Foxarray<char, 3>::MyIterator iser;
for (int i = 0; i < 3; i++)
{
Foxchar[i] = (char)i * 100;
}
for (iser= Foxchar.begin(); iser != Foxchar.end(); iser++)
{
cout << *iser;
}
}
定长数组也可以存放自定义类型数据
#include<iostream>
#include<array>
#include<string>
using namespace std;
class Fox;
template <class _Ty, size_t size>
class Foxarray
{
public:
Foxarray()
{
memroy = new _Ty[size];//所谓数组就是动态内存申请
mysize = size;
}
_Ty& operator[](int index)//重载运算符 从而实现下标访问我们定义类的操作
{
return memroy[index];
}
_Ty* begin()
{
return memroy + 0;
}
_Ty* end()
{
return memroy + size;
}
~Foxarray()//做了动态内存申请了 要记得写析构函数
{
delete[] memroy;
}
class MyIterator
{
public:
MyIterator(_Ty* pmove = nullptr) :pmove(pmove) {}//缺省写法 ,为无参构造函数做准备
void operator=(_Ty* pmove)
{
this->pmove = pmove;
}
bool operator!=(_Ty* pmove)
{
return this->pmove != pmove;
}
MyIterator operator++(int)
{
this->pmove++;
return *this;
}
_Ty operator*()
{
return *pmove;
}
protected:
_Ty* pmove;
};
protected:
_Ty* memroy;
size_t mysize;
};
class Fox
{
public:
Fox() {}
Fox(string name, int age) :name(name), age(age) {}
void print()
{
cout << name << "\t" << age << endl;
}
protected:
string name;
int age;
};
int main()
{
array<Fox, 3> foxarr = { Fox("狐狸1",18),Fox("狐狸2",3),Fox("狐狸3",4) };
for (Fox v : foxarr)//它会自动循环到最后一个元素
{
v.print();
}
动态数组:
动态数组 ,就是会因为元素个数而自动扩增的容器
头文件 vector
#include<iostream>
#include<vector>
#include<string>
using namespace std;
class Fox
{
public:
Fox(string name, int age) :name(name), age(age) {}
friend ostream& operator<<(ostream& out, const Fox& temp)
{
out << temp.name << "\t" << temp.age;
return out;
}
protected:
string name;
int age;
};
int main()
{
vector<int>vec;//带类型
vector<int>vec2(3);//带类型带长度
//带长度可以使用下标法访问插入,不带长度的必须使用成员函数啊
//插入的范围也只有确认大小的访问,不可以越界插入
for (int i = 0; i < 3; i++)
{
cin >> vec2[i];
}
vec.push_back(1);
vec.push_back(2);
vec.push_back(999);//不带长度成员函数插入
vec2.push_back(215);//确认长度也可以通过成员函数扩增插入
//可以通过迭代器去遍历数组
vector<int>::iterator ite;
for (ite = vec.begin(); ite != vec.end(); ite++)
{
cout << *ite << endl;
}
vector<Fox> vfox;
vfox.push_back(Fox("狐狸", 123));
for (int i = 0; i < 1; i++)
{
cout << vfox[i];
}
return 0;
}
动态数组基本成员函数
int main()
{
vector<int> Foxdata = { 9,8,7,6};
cout << Foxdata.size() << endl; //当前元素个数
cout << Foxdata.empty() << endl; //判断是否为空
cout << Foxdata.front() << endl; //访问第一个元素
cout << Foxdata.back() << endl; //访问最后一个元素
cout << Foxdata.at(2) << endl; //下标访问
cout << Foxdata[2] << endl; //和at(2)一样的效果
Foxdata.emplace(Foxdata.begin() +1, 100); //修改下标1的元素为100
Foxdata.emplace_back(999); //和push_back一样的功能
Foxdata.emplace(Foxdata.begin(), 9999); //修改第一个元素
//复制
int array[] = { 1,2,3 };
vector<int> vecData;
vecData.assign(array, array +6); //复制元素的个数
cout << vecData[4];
}
容器的嵌套
#include <iostream>
#include <array>
#include <vector>
#include <string>
#include <ctime>
#include <cstdlib>
using namespace std;
void testArrayVsArray()
{
array<array<int, 3>, 4> foxarr;//容器二维数组的概念 [4][3],有一个
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 3; j++) {
foxarr[i][j] = i * j;
cout << foxarr[i][j] << "\t";
}
cout << endl;
}
}
void testVectorVsVector()
{
srand((unsigned int)time(nullptr));
vector<vector<int>> foxData;
for (int i = 0; i < 4; i++)
{
vector<int> temp;
for (int j = 0; j < rand() % 4; j++)
{
temp.push_back(i * j);//先插入临时的int temp里面
}
foxData.push_back(temp);//插入到我们的容器里面来
}
//不等列数的二维数组
for (int i = 0; i < foxData.size(); i++)
{
for (int j = 0; j < foxData[i].size(); j++)//通过下标访问我们每个temp.size
{
cout << foxData[i][j] << "\t";
}
cout << endl;
}
}
void testArrayVsVector()
{
array<vector<int>, 3> vecArr;
vector<int> vec1[3] = { { 1,2,3 } , {1,2,3,4}, {1,2} };
for (int i = 0; i < vecArr.size(); i++) {
vecArr[i] = vec1[i];
}
//不等列数的二位数组
for (int i = 0; i < vecArr.size(); i++) {
for (int j = 0; j < vecArr[i].size(); j++) {
cout << vecArr[i][j] << "\t";
}
cout << endl;
}
vector<array<array<vector<int>, 3>, 3>> vec;
vector<int> a;
vector<int> b;
vector<int> c;
a.push_back(999);
b.push_back(888);
c.push_back(12);
array < vector<int>, 3 >arrvec = { a, b, c };//有三个不定长的数组
array<array<vector<int>, 3>, 3> arrc3 = { arrvec,arrvec ,arrvec };
vector<array<array<vector<int>, 3>, 3>> ve;
ve.push_back(arrc3);//插入这种类型的元素不定长
}