连续空间的多维数组实现（二）

最新推荐文章于 2022-09-21 00:47:07 发布
最新推荐文章于 2022-09-21 00:47:07 发布
阅读量357 收藏
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014613043/article/details/94492607
版权

在我的这篇文章中，我提出了一种实现连续空间的二维数组的方法。
https://blog.csdn.net/u014613043/article/details/51543534

今天重新组织了一下新的实现方式，觉得有点意思，记录一下

设计思想

一个连续的多维空间数组，希望可以使用模板自动帮我们识别，这是个N 维的数组。
然后二维的数组就是这个实现的泛化。

于是，给出如下的类声明：

template<class T, size_t N>
class array_n
{
private:
    size_t dimension[N];
    unique_ptr<T[]> data;
};

解决参数个数问题及赋值问题

提供类的构造函数，希望可以按照N 的个数， 检查参数的个数对不对，还希望检查参数的内容是不是整数类型。
所幸，我们可以使用static_assert 进行编译期检查，可以使用 std::is_integral 检查是不是整数。

首先，我们希望编写一个对可变参数解包的函数，为 dimension 数组赋值

void assign(size_t* d) {}

template<class T, class ... Args>
void assign(size_t* d, T value, Args&& ... args)
{
	static_assert(is_integral<T>::value, "array_n parameter type is not value");
	d[0] = static_cast<size_t>(value);
	assign(++d, args ...);
}

然后把以上内容串起来，可以编写一个类的构造函数：

	template< class ... Args >
	array_n(Args ... args)
	{
		using parameter_type = decltype(make_tuple(args ...));
		constexpr int p_size = tuple_size< decltype(make_tuple(args ...)) >::value;
		static_assert(p_size == N, "parametersize_not_equal_N");
		assign(dimension, args ...);
		init();
	}

其中 p_size 会检查参数的个数是不是满足N 的数量，否则，会报错。

其中decltype 的语句只是编译期行为，并不会真正地运行，所以这里并不会有任何的额外的检查开销。

补充init 函数如下：

	void init()
	{
		data.reset(new T[size()]);
	}

size 的解包如下：

template<size_t N>
size_t mul(const size_t d[])
{
	return d[N - 1] * mul<N - 1>(d);
}

template<>
size_t mul<0>(const size_t d[])
{
	return 1;
}


//-------------
	size_t size() const
	{
		return mul<N>(dimension);
	}

index 索引方法

如何提供一个优雅的index 是我们考虑的重点 。这次我希望可以使用原始的 operator[] 操作符来进行index 的操作。

我希望可以如下提供index 的方法：

1）当N == 1 时，直接访问到特性的元素
2） 当N == 2 时，第一次operator[] 返回一个 T*，第二次operator[] 时原生指针就可以支持访问了
3） 当N >= 3 时，operator[] 返回一个包装器，这个包装器对每级的operator[] 进行索引计算，直到拿到最终的元素。

于是，我们首先需要针对N ，定义返回的类型：

	template<size_t N>
	struct next_type_helper
	{
		using value = array_n_index<T, N>;
	};

	template<>
	struct next_type_helper<2>
	{
		using value = T * ;
	};

	template<>
	struct next_type_helper<1>
	{
		using value = T & ;
	};
	using next_type = typename next_type_helper<N>::value;

其中array_n_index<T,N> 就是我们的包装器。

先不关心N > 2 的情况，我们继续把剩下的内容补充完全

	next_type operator[](size_t index)
	{
		return index_operator<N>(index);
	}
	template<size_t N>
	inline next_type index_operator(size_t index)
	{
		return next_type(*this, index);
	}
	template<>
	inline next_type index_operator<2>(size_t index)
	{
		return data.get() + index * dimension[N - 1];
	}

	template<>
	inline next_type index_operator<1>(size_t index)
	{
		return data[index];
	}

针对N > 2 的情况，设计一个包装器。

template<class T, size_t N>
struct array_n_index
{
	array_n_index(array_n<T, N>& in_array, size_t index)
	{  ... }
private:
	T* data; //pointer of data
	size_t dimension[N-1]; //dimension 
	int now_dimension; // now index level 
};

回顾一下访问index 的内容，假如存在 int value[row][col], 当需要访问index （i，j） 的内容时，表达式如下：

value + i * col + j

如果多了一维数组，那么访问如下: int value[row][col][third], index(i,j,k)

value + i*col*third + j * third + k

于是dimension 的设计如下：


dimension[0] = col * third
dimension[1] = third
dimension[2] = 1

考虑到从 array_n 的 operator[] 中已经调用了第一级，所以 dimension[0] 可以去掉了，变成：

dimension[0] = third
dimension[1] = 1

当维数变得更高的时候，这个规律依然适用。

补充一下剩下的实现，完整的包装器如下：



template<class T, size_t N>
struct array_n_index
{
	array_n_index(array_n<T, N>& in_array, size_t index)
	{
		data = in_array.get_data();
		dimension[N-2] = 1;//N-2
		dimension[N - 3] = in_array.dimension[N - 1];
		for (int i = N - 4; i >= 0; --i)
		{
			dimension[i] = in_array.dimension[i + 2] * dimension[i + 2];
		}
		now_dimension = 0;
		//compute now 
		data += dimension[N-2] * in_array.dimension[1] * index;
	}

	array_n_index& operator[](size_t index)
	{
		data += index * dimension[now_dimension++];
		return *this;
	}

	operator T&()
	{
		return *data;
	}

	array_n_index& operator= (const T& value)
	{
		*data = value;
		return *this;
	}


private:
	T* data;
	size_t dimension[N-1];
	int now_dimension;
};

至此，核心的功能已经完成了。

使用

对类型进行别名：

template<class T>
using array2 = array_n<T, 2>;

template<class T>
using array3 = array_n<T, 3>;

template<class T>
using array4 = array_n<T, 4>;

就可以特化成特定维数的数组。

性能

对二维和三维的数组进行测试， 测试环境 Visual Studio 2017 , Windows10



template<class T>
void test2(T& value, int first, int second)
{
	for (int i = 0; i < first; ++i)
	{
		for (int j = 0; j < second; ++j)
		{
			value[i][j] = 233;
		}
	}
}

template<class T>
void test3(T& value, int first, int second, int third)
{
	for (int i = 0; i < first; ++i)
	{
		for (int j = 0; j < second; ++j)
		{
			for (int k = 0; k < third; ++k)
			{
				value[i][j][k] = 233;
			}
		}
	}
}




int main()
{
	const int first = 133;
	const int second = 255;
	const int third = 123;
	{

		int value[first][second];
		auto start = steady_clock::now();
		test2(value, first, second);
		auto end = steady_clock::now();

		auto dur = duration<double, std::milli>(end - start);
		cout <<"native 2-array  "<< dur.count() << endl;
	}

	{
		array2<int> value(first, second);
		auto start = steady_clock::now();
		test2(value, first, second);
		auto end = steady_clock::now();

		auto dur = duration<double, std::milli>(end - start);
		cout <<"array2 "<< dur.count() << endl;
	}

	{
		vector< vector<int> > value(first, vector<int>( second) );
		auto start = steady_clock::now();
		test2(value, first, second);
		auto end = steady_clock::now();

		auto dur = duration<double, std::milli>(end - start);
		cout <<"vector "<< dur.count() << endl;
	}

	{
		array3<int> value(first,second,third);
		auto start = steady_clock::now();
		test3(value, first, second, third);
		auto end = steady_clock::now();

		auto dur = duration<double, std::milli>(end - start);
		cout << "array3 " << dur.count() << endl;
	}

	{
		vector< vector< vector<int> > > value(first, vector< vector<int> >(second, vector<int>(third)));
		auto start = steady_clock::now();
		test3(value, first, second, third);
		auto end = steady_clock::now();

		auto dur = duration<double, std::milli>(end - start);
		cout << "native3 " << dur.count() << endl;
	}

	system("pause");
}

开了release 的输出如下：

native 2-array  0.0006
array2 0.0652
vector 0.0155
array3 2.4337
native3 3.0414
请按任意键继续. . .

可以看到，在二维方面 ，array2 的表现只能是差强人意
但是在三维方面的表现，比vector 嵌套三次的效果要好。

在非debug 下：

native 2-array  0.0945
array2 5.0919
vector 12.8314
array3 691.447
native3 2194.27

emmm, 这个结果就耐人寻味了，不知道vector<vector <int> > 的数据结果在release 下做了什么样的优化，可以让它如此地接近原生数组地性能。

完整code

#include<tuple>
#include <memory>
#include <type_traits>
using namespace std;
template<size_t N>
size_t mul(const size_t d[])
{
	return d[N - 1] * mul<N - 1>(d);
}

template<>
size_t mul<0>(const size_t d[])
{
	return 1;
}


void assign(size_t* d) {}

template<class T, class ... Args>
void assign(size_t* d, T value, Args&& ... args)
{
	static_assert(is_integral<T>::value, "array_n parameter type is not value");
	d[0] = static_cast<size_t>(value);
	assign(++d, args ...);
}
template<class T, size_t N>
struct array_n_index;






template<class T, size_t N>
class array_n
{
	template<size_t N>
	struct next_type_helper
	{
		using value = array_n_index<T, N>;
	};

	template<>
	struct next_type_helper<2>
	{
		using value = T * ;
	};

	template<>
	struct next_type_helper<1>
	{
		using value = T & ;
	};
	using next_type = typename next_type_helper<N>::value;


	friend struct array_n_index<T, N>;
public:
	template< class ... Args >
	array_n(Args ... args)
	{
		using parameter_type = decltype(make_tuple(args ...));
		constexpr int p_size = tuple_size< decltype(make_tuple(args ...)) >::value;
		static_assert(p_size == N, "parametersize_not_equal_N");
		assign(dimension, args ...);
		init();
	}
	size_t size() const
	{
		return mul<N>(dimension);
	}

	size_t get_dimension(int d) const
	{
		return dimension[d];
	}

	T* get_data()
	{
		return data.get();
	}


	next_type operator[](size_t index)
	{
		return index_operator<N>(index);
	}



private:
	template<size_t N>
	inline next_type index_operator(size_t index)
	{
		return next_type(*this, index);
	}
	template<>
	inline next_type index_operator<2>(size_t index)
	{
		return data.get() + index * dimension[N - 1];
	}

	template<>
	inline next_type index_operator<1>(size_t index)
	{
		return data[index];
	}

	void init()
	{
		data.reset(new T[size()]);
	}


	size_t dimension[N];
	unique_ptr<T[]> data;
};



template<class T, size_t N>
struct array_n_index
{
	array_n_index(array_n<T, N>& in_array, size_t index)
	{
		data = in_array.get_data();
		dimension[N-2] = 1;//N-2
		dimension[N - 3] = in_array.dimension[N - 1];
		for (int i = N - 4; i >= 0; --i)
		{
			dimension[i] = in_array.dimension[i + 2] * dimension[i + 2];
		}
		now_dimension = 0;
		//compute now 
		data += dimension[N-2] * in_array.dimension[1] * index;
	}

	array_n_index& operator[](size_t index)
	{
		data += index * dimension[now_dimension++];
		return *this;
	}

	operator T&()
	{
		return *data;
	}

	array_n_index& operator= (const T& value)
	{
		*data = value;
		return *this;
	}


private:
	T* data;
	size_t dimension[N-1];
	int now_dimension;
};


template<class T>
using array2 = array_n<T, 2>;

template<class T>
using array3 = array_n<T, 3>;

template<class T>
using array4 = array_n<T, 4>;
小键233
关注
专栏目录
pythonnumpy初始化三维数组_Python numpy多维数组实现原理详解
weixin_39617484的博客
12-03 987
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。今天就针对多维数组展开来写博客numpy其一部分功能如下：1.ndarray，是具有矢量算术运算且节省空间的多维数组。2.可以用于对整组的数据快速进行运算的辨准数学函数。3.能够用于读写磁盘数据的工具以及用于操作系统内存映射的工具。NumPy...
【Fortran】二维、多维数组及相应高级特性
热门推荐
小毛95的博客
05-11 1万+
总结了Fortran中二维及多维数组的应用方式。
多维数组的实现
三月软件工作室--任忌
03-29 1547
数组一旦被定义了，它的维数和维界就不会变。因此，除了结构的初始化和销毁之外，数组只有存取元素和修改元素。数组一般分为行序和列许。一般系统都是用的行许。 以2维数组a[m][n]为例 列序： a[0][0]  a[1][0] ...... a[m-1][0] ............. a[m-1][0] a[m-1][1] ...... a[m-1][n-1] 行序列：
多维数组的实现 (java 表示)
gacmy的专栏
12-12 1100
public class MultiDimArray { private static int MAX_ARRAY_DIM = 8;//数组最大维数 int[] base;//数组元素基地址 int dim;//数组维数 int[] bounds; //数组维界基地址 int[] constants;//数组映像函数 常量基址 //初始化n维数组
数组的顺序表示和实现【严蔚敏】
MooMLu的博客
04-25 1188
代码为数据结构【严蔚敏】书籍配套纯c代码 //数组的顺序存储表示 #include // 标准头文件，提供宏va_start，va_arg和va_end， // 用于存取变长参数表 struct Array { ElemType *base; // 数组元素基址，由InitArray分配 int dim; // 数组维数 i
数据结构-多维数组的实现
suliangkuanjiayou的博客
11-09 4957
写给自己的话：在之前写代码的过程中，我还没有遇到过要自己设计一个可变参数的函数。但是，数据结构中多维数组中，我就不得不去面对这个难题了。说实话，我一开始没有打算写这篇博客的。但是，我看到我的同学（我之前和他讲了这个代码）还在深入研究这个可变参数，我觉得自己也得把它弄得清楚一些，可不能半吊子了！ 回归正题，相信大家书本上一定会给大家介绍四个类型va_list,va_start,va_arg,va_e...
【数据结构学习记录12】——多维数组的顺序实现
康娜喵的原创博客
11-10 555
多维数组的顺序实现一.前言二.数组的结构再探1.降维2.下标计算3.名词解释三.实现原理1.数组的结构2.数组的初始化3.数组的取地址4.数组的取值与修改四.代码实现1.stdarg.h1.1 va_list1.2 va_start()1.3 va_arg()1.4 va_end()1.6 样例代码2.主代码 一.前言 对于数组，我们大家肯定不陌生。单维数组肯定很熟悉，那多维数组呢？实际上就是多个单维数组所构成的特殊的数组的数组。这一内容，在C++的文章里也提到过。那么，我们如何通过用线性结构来模拟一个多维
Python 实现取多维数组第n维的前几位
09-18
一个Numpy数组的维度称为“轴”（axis），多维数组的轴可以类比为数学中的多维空间的坐标轴。 以本文为例，我们有一个具体的numpy数组，它的shape为(7352,9,128,1)。这个数组有四个维度，分别对应于(样本数, 特征数...
Lua一维数组与多维数组的使用示例
09-19
多维数组是指数组的元素本身也是数组的数据结构，最常见的形式是二维数组，相当于数学上的矩阵。 ##### 3.1 创建多维数组 创建多维数组的方法与一维数组类似，但需要嵌套使用花括号： ```lua -- 初始化一个2x2的...
如何动态分配多维数组
08-03
动态分配多维数组的技术和实现 多维数组是编程语言中的一种数据结构，它由多个维度组成，每个元素由值及多个能确定元素位置的下标组成。动态分配多维数组是指在程序执行过程中动态分配内存空间来存储多维数组的元素...
C语言实现多维数组数据结构
m0_53295613的博客
12-10 1843
C语言实现多维数组数据结构之多维数组各基本操作函数原型说明各基本操作的具体实现测试分析思考与小结1、 对数组的再认识2、调试过程中遇到的问题及解决方案3、算法的时间复杂度分析 数据结构之多维数组 定义结构体 typedef struct { ElemType* base;//数组元素基址（数组基址） int dim;//数组维数 int* bounds;//数组维界基址（存放各位长度信息） int* constants;//数组映象函数常量基址 }Array; 各基本操作函数原型说明 （1）
自定义N维空间数组
weixin_30321709的博客
11-20 116
class Space : IEnumerable<Space> { public object Filler { get { return filler ?? (filler = Top.create()); } } public Space Upper { get; protected ...
C++自动化(模板元)编程基础与应用(2)
Augusdi的专栏
02-01 618
#if 0 在上一篇文章的最后提到了一个相对来说通用一点的LOOP循环，下面还是将上一篇文 章中的LOOP循环代码复制如下： #endif #ifdef CODE1 #include <iostream> template<size_t n> void print() {//这里的n是编译期的结果，可以用来定义数组的 int a[n+1];//这么做是为了证明n是编译期常量 std::cout << sizeof(a)/size...
【C++/STL】位图和布隆过滤器
最新发布
qq_53893431的博客
09-21 438
位图和布隆过滤器的应用
C++ bitset头文件中的内容
sinat_27305889的博客
09-06 2489
CLass templatestd::bitset类模板格式template<size_t N> class bitset bitset是用来存储比特的集合。 可以像数组取得数组值地方法获取其中的比特位。 可以从string类型或者整型值构造或者向它们转换。 bitset的大小在编译时就已经确定，取决于模板参数。 也可以用vector特化类型实现bitset类似功能 1.成员类型只有一种类型std:
C++模板进阶
weixin_52199109的博客
09-14 1648
非类型模板参数 模板参数 类型模板参数：用typename/class定义的参数类型名称 非类型模板参数：用一个整形作为模板的一个参数，在模板中可以当常量使用 例如： template<class T,size_t N>//T就是类型模板参数，N就是非类型模板参数 这个N可以直接当常量用，就是说可以直接去初始化数组的元素个数 举个实际点的例子 #include <iostream> template <class T ,size_t N> class arr { p
C++基础之bitset
itlilyer的博客
07-21 4063
类模板std::bitset template <size_t N> class bitset; 头文件 #include <bitset> 说明 一个bitset中保存了一些bit(字节， 只能取两个值的元素：0或1，真或假 …) bitset模拟了一个bool类型的数组，但是优化了内存空间：总的来说，每个元素值占用一个bit（比大多数系统中最小的元素char小了8倍） 每个位置的都可以独立的访问：例如，给定一个bitset命名为foo，foo[3]访问的就是第四个元素，就像通常数
如何在C中为一个数组分配空间？
魏波
09-23 1万+
                            如何在C中为一个数组分配空间 最简单的方法是： char array[5]//分配给数组array一个5个字节的空间。 但是我们要知道在C中数组其实就是一个名字，其实质含义就是指针，比如char array[]：是到底分配的多少空间，所以我们要将其分成为两种不同的形式给出答案： 第一种是栈的形式： char array[5] ...
C语言动态开辟多维数组空间
zzw3354353337的博客
09-06 2425
在一些特定的程序中，我们常常无法预测数组的大小。如果我们自己将值分配给数组，那么它在执行期间无法更改。这会产生问题，要么数组的内存变低，要么数组占用更少的空间浪费内存，因此为避免这种情况，建议动态分配数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值