一个简单的C++多维数组类

最新推荐文章于 2020-11-20 16:40:53 发布
最新推荐文章于 2020-11-20 16:40:53 发布
阅读量642 收藏
点赞数
文章标签： c++ null delete object java interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mars_man/article/details/5936419
版权

 

该数组类，是为了满足和JAVA类似的语法而写的，不过初始化方面，还是不够灵活

 

#ifndef _MULTIARRAY_

#define _MULTIARRAY_

 

template <typename IT, typename IT2>

void elemcopy(IT srcbegin, IT srcend, IT2 destbegin)

{

while (srcbegin != srcend)

{

*destbegin = *srcbegin;

++destbegin;

++srcbegin;

}

}

 

template <int DIMEN>

struct DIM_INFO

{

int dimsize[DIMEN];

DIM_INFO(const DIM_INFO<DIMEN - 1>& e, int size)

{

dimsize[0] = size;

elemcopy(&e.dimsize[0], &e.dimsize[DIMEN - 1], &dimsize[1]);

}

DIM_INFO<DIMEN + 1> operator[] (int size) const

{

return DIM_INFO<DIMEN + 1>(*this, int(size));

}

};

 

template <>

struct DIM_INFO<0>

{

int dimsize[1];

DIM_INFO<1> operator[] (int size) const

{

return DIM_INFO<1>(*this, int(size));

}

};

typedef DIM_INFO<0> 0DIM;

 

#ifdef DIM

#undef DIM

#endif

#define DIM (0DIM())

 

#ifndef NULL

#define NULL (0)

#endif

 

//

 

#ifdef INITCOUNTER

#undef INITCOUNTER

#endif

#define INITCOUNTER (1)

 

//

//

 

template <typename T>

class _share_array_data_

{

public:

_share_array_data_<T> * Duplicate()

{

if (this != NULL)

{

++_nRef;

}

return this;

}

 

void Release()

{

if (this != NULL)

{

// assert(_nRef  >= INITCOUNTER);

--_nRef;

if (_nRef < INITCOUNTER)

{

delete this;

}

}

}

 

static _share_array_data_<T>* NewData(int size)

{

return ((0 == size)?NULL:(new _share_array_data_<T>(size)));

}

 

 

inline int Size() const {return (NULL == this)?0:_nSize;}

 

inline const T* begin() const {return (NULL == this)?NULL:_pValue;}

inline const T* end() const {return (NULL == this)?NULL:(_pValue + _nSize);}

 

inline T* begin() {return (NULL == this)?NULL:_pValue;}

inline T* end() {return (NULL == this)?NULL:(_pValue + _nSize);}

 

private:

_share_array_data_<T>& operator=(const _share_array_data_<T>&);

_share_array_data_(const _share_array_data_<T>&);

 

_share_array_data_(int size)

{

_nSize = size; // assert(_nSize != 0);

_pValue = new T[size]; // assert(_pValue != NULL);

_nRef = INITCOUNTER;

}

~_share_array_data_()

{

// assert(_nRef  < INITCOUNTER);

// assert(_pValue != NULL);

delete[] _pValue;

}

 

int _nRef;

int _nSize;

T *_pValue;

};

 

//

 

template <typename T>

inline void InitFunc(T*, T*)

{}

 

template <typename T>

inline void InitFunc(T **pbegin, T **pend)

{

MEMSET(pbegin, 0, (pend - pbegin)*sizeof(T*));

}

 

inline void InitFunc(int *pbegin, int *pend)

{

MEMSET(pbegin, 0, (pend - pbegin)*sizeof(int));

}

 

inline void InitFunc(short *pbegin, short *pend)

{

MEMSET(pbegin, 0, (pend - pbegin)*sizeof(short));

}

 

inline void InitFunc(char *pbegin, char *pend)

{

MEMSET(pbegin, 0, (pend - pbegin)*sizeof(char));

}

 

inline void InitFunc(signed char *pbegin, signed char *pend)

{

MEMSET(pbegin, 0, (pend - pbegin)*sizeof(signed char));

}

 

//

// Interface: multi_array

 

template <typename T, int DIMEN>

class multi_array;

 

//

 

template<typename T>

class multi_array<T, 1>

{

public:

typedef DIM_INFO<1> THISDIM;

typedef multi_array<T, 1> THISTYPE;

 

typedef T ELETYPE;

enum {DIMENTION = 1};

typedef T VALTYPE;

typedef _share_array_data_<VALTYPE> DATATYPE;

 

~multi_array()

{

_pRef->Release();

_pRef = NULL;

}

 

multi_array() : _pRef(NULL)

{

}

 

multi_array(const THISDIM& diminfo) : _pRef(DATATYPE::NewData(diminfo.dimsize[0]))

{

InitFunc((_pRef->begin()), (_pRef->end()));

}

 

multi_array(const THISTYPE& src) : _pRef(src._pRef->Duplicate())

{

}

 

multi_array(THISTYPE *psrc) : _pRef(NULL)

{

if (psrc != NULL)

{

_pRef = psrc->_pRef->Duplicate();

delete psrc;

}

}

 

//

 

THISTYPE& operator = (const THISDIM& diminfo)

{

_pRef->Release();

_pRef = DATATYPE::NewData(diminfo.dimsize[0]);

InitFunc((_pRef->begin()), (_pRef->end()));

return *this;

}

 

THISTYPE& operator = (const THISTYPE& src)

{

if (_pRef != src._pRef)

{

_pRef->Release();

_pRef = src._pRef->Duplicate();

}

return *this;

}

 

THISTYPE& operator = (THISTYPE *psrc) // 只是为了适应JAVA语法[Object a; a = new Object;]

{

if (psrc != NULL)

{

if (_pRef != psrc->_pRef)

{

_pRef->Release();

_pRef = psrc->_pRef->Duplicate();

}

else if (this != psrc)

{

delete psrc;

}

}

else

{

_pRef->Release();

_pRef = NULL;

}

return *this;

}

 

inline VALTYPE& operator [] (int index)

{

return (_pRef->begin())[index];

}

 

inline const VALTYPE& operator [] (int index) const

{

return (_pRef->begin())[index];

}

 

inline int length() const {return _pRef->Size();}

 

inline VALTYPE *begin() {return (_pRef->begin());}

 

inline const VALTYPE *begin() const {return (_pRef->begin());}

 

inline VALTYPE *end() {return (_pRef->end());}

 

inline const VALTYPE *end() const {return (_pRef->end());}

 

inline operator boolean() const {return (_pRef != NULL);}

 

friend inline boolean operator == (const THISTYPE& _l, const THISTYPE& _r)

{

return (_l._pRef == _r._pRef);

}

friend inline boolean operator != (const THISTYPE& _l, const THISTYPE& _r)

{

return (_l._pRef != _r._pRef);

}

 

 

private:

DATATYPE *_pRef;

};

 

//

 

template <typename T, int DIMEN>

class multi_array

{

public:

typedef DIM_INFO<DIMEN> THISDIM;

typedef DIM_INFO<DIMEN - 1> NEXTDIM;

typedef multi_array<T, DIMEN> THISTYPE;

 

typedef T ELETYPE;

enum {DIMENTION = DIMEN};

typedef multi_array<T, DIMEN - 1> VALTYPE;

typedef _share_array_data_<VALTYPE> DATATYPE;

 

~multi_array()

{

_pRef->Release();

_pRef = NULL;

}

 

multi_array() : _pRef(NULL)

{

}

 

multi_array(const THISDIM& diminfo) : _pRef(DATATYPE::NewData(diminfo.dimsize[DIMEN - 1]))

{

if (_pRef)

{

VALTYPE *pdata = _pRef->begin();

int size = _pRef->Size();

const NEXTDIM& d_1 = (const NEXTDIM&)diminfo;

for (int i = 0; i < size; ++i) pdata[i] = d_1;

}

}

 

multi_array(const THISTYPE& src) : _pRef(src._pRef->Duplicate())

{

}

 

multi_array(THISTYPE *psrc) : _pRef(NULL)

{

if (psrc != NULL)

{

_pRef = psrc->_pRef->Duplicate();

delete psrc;

}

}

 

//

 

 

THISTYPE& operator = (const THISDIM& diminfo)

{

_pRef->Release();

_pRef = DATATYPE::NewData(diminfo.dimsize[DIMEN - 1]);

if (_pRef)

{

VALTYPE *pdata = _pRef->begin();

int size = _pRef->Size();

const NEXTDIM& d_1 = (const NEXTDIM&)diminfo;

for (int i = 0; i < size; ++i) pdata[i] = d_1;

}

return *this;

}

 

THISTYPE& operator = (const THISTYPE& src)

{

if (_pRef != src._pRef)

{

_pRef->Release();

_pRef = src._pRef->Duplicate();

}

return *this;

}

 

THISTYPE& operator = (THISTYPE *psrc) // 只是为了适应JAVA语法[Object a; a = new Object;]

{

if (psrc != NULL)

{

if (_pRef != psrc->_pRef)

{

_pRef->Release();

_pRef = psrc->_pRef->Duplicate();

}

else if (this != psrc)

{

delete psrc;

}

}

else

{

_pRef->Release();

_pRef = NULL;

}

return *this;

}

 

inline VALTYPE& operator [] (int index)

{

return (_pRef->begin())[index];

}

 

inline const VALTYPE& operator [] (int index) const

{

return (_pRef->begin())[index];

}

 

inline int length() const {return _pRef->Size();}

 

inline VALTYPE *begin() {return (_pRef->begin());}

 

inline const VALTYPE *begin() const {return (_pRef->begin());}

 

inline VALTYPE *end() {return (_pRef->end());}

 

inline const VALTYPE *end() const {return (_pRef->end());}

 

inline operator boolean() const {return (_pRef != NULL);}

 

friend boolean operator == (const THISTYPE& _l, const THISTYPE& _r)

{

return (_l._pRef == _r._pRef);

}

friend boolean operator != (const THISTYPE& _l, const THISTYPE& _r)

{

return (_l._pRef != _r._pRef);

}

 

private:

DATATYPE *_pRef;

};

 

 

//

 

#endif

 

 

mars_man
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一组新的多维数组模板类
03-16
一组新的多维数组模板类 by chen3feng(RoachCock@smth) email: chen3feng@163.com, chen3fengx@163.com, chen3fengx@hotmail.com [引言] 在C/C++开发中,多维数组是一个让很多人感到棘手的问题.原因是C/C++中,多维数组被看 作是数组的数组. 在向函数传递参数的时候,多维数组经常让人感到是麻烦的制造者,通常都是传递首地址 和每一维的大小: void foo(int *,int ,int);; int a[10][10];; foo(&a[0][0],10,10);; //... 十分的麻烦,在函数中访问时也得自己用乘法来计算元素的位置,更是十分麻烦. C99标准推出了可变大小的多维数组,当然,实现该标准的编译器还不多,但是也从一个方 面说明了变量大小的多维数组是很有用的. C++标准直到现在还不支持,明年(2003年)的新标准也不知道会不会加进去.但是C++程序 员自己有办法,利用C++的模板,运算符重载等技巧,完全可以构建出方便实用的多维数组类 我抢在明年之前做出这组模板类,也希望即使新标准增加了变量大小的多维数组,我的工 作也仍有一些意义, :) 另外，多维数组的空间是连续的，这跟用vector of vector实现的不一样，可以用迭代器 从头到脚挨个摸一遍. boost库也提供了多维数组类,当然还有别的几个数组类.我感觉boost多维数组类的缺点 就是只支持动态数组,对静态和动态数组没有一个统一的非GP的接口,因此我着重于这方 面的改进, [简介] 该组类有以下几个类模板组成 1. template <;typename T, size_t DimNum>; class array_base;; 该类是其他几个数组类的基类 // 由于编译器对C++标准实现参差不齐的原因,该类实际 上不是根类,不过应用中不需要知道这一点. 提供了基本的功能,比如[]运算符,迭代器的类型声明,迭代器的获取,value_type等的定 义等 等 2. template <;typename T, size_t d1, size_t d2 = -1, size_t d3 = -1>; class static_array;; 静态的数组类,从array_base派生而来,因此除了兼容也是由array_base派生出来的其他 类外,还有自己的特点,就是提供了一个elements的public成员,直接暴露给用户,访问 速度可以很快. 3. template<;typename T,size_t DimNum, typename A=std::allocator<;T>; >; class dynamic_array;; //:public array_base<;T, DimNum>; 看得出也是从array_base派生的,另外,他是可以resize的.还支持reserve等STL容器的操 作. 4. template <;typename T, size_t DimNum, typename A=std::allocator<;T>; >; class shared_array;; //: public array_base<;T, DimNum>; 就是支持引用计数的动态数组啦.不过刚写了个外皮,内容还没开工,因为我最近要回家. sorry! [用法] 先要包含各自的头文件: #include ";static_array.hpp"; #include ";dynamic_array.hpp"; #include ";shared_array.hpp"; 1.然后就可以定义对象 cfc::static_array<;int,10>; sa1;; cfc::static_array<;int,10, 10>; sa2;; cfc::static_array<;int,10, 10, 10>; sa3;; cfc::dynamic_array<;int, 1>; da1(cfc::extents[10],10);; cfc::dynamic_array<;int, 2>; da2(cfc::extents[10][10], 10);; cfc::dynamic_array<;int, 3>; da3(cfc::extents[10][10][10], 10);; cfc::shared_array<;int,1>; sha1(cfc::extents[10]]);; cfc::shared_array<;int,2>; sha2(cfc::extents[10][10]);; cfc::shared_array<;int,3>; sha3(cfc::extents[10][10][10]);; extents是一个数组的维度生成器,用起来的很方便,跟boost学的,不过没仔细看它的实现 ,我觉得我的也不错,哈哈 2.访问元素: sa1[0] = 0;; da1[0] = 0;; sa2[0][0] = 0;; da2[0][0] = 0;; sa3[0][0][0] = 0;; da3[0][0][0] = 0;; 3.比较相等与否: bool f;; f = sa1==sb1;; f = da1==da1;; f = sa1==da1;; // 说明:只提供了==和!=,别的没提供,我觉得别的意义大 4.交换: cfc::swap(da1,db1);; cfc::swap(sa1,sb1);; cfc::swap(sa1,db1);; //说明:动态数组的交换很高效,换个指针而已, :) 5.resize: da3.resize(cfc::extents[10][100][1]);; da3.resize(cfc::extents[10][50][1]);; da3.resize(cfc::extents[10][10][20]);; da3.resize(cfc::extents[10][10][10]);; //说明:只有动态数组才能resize, 还有将来的shared_array, zz 6.赋值: da3 = db3;; sa1 = sb1;; da1 = db1;; 静态数组维度不一样不能赋值,否则会引起编译错误 动态数组和丢失了静态大小成为了array_base的数组维度不一样时,赋值引发 std::length_error异常,可以捕捉到, 比较也是这样 7.作为函数的参数 还举开头的那个例子 void foo(array_base<;int,2>; &a) { a[0][0]=10;; } 8.重要概念 <;子数组>; 高维数组的子类型,也就是低一维的数组. 子数组的类型为array_base,支持array_base的所有操作,但是不再支持原来数组的特定 操作子数组由[]运算符得到, sa3[0] da3[0] //类型均为array_base<;int,2>; 子数组还可以在取子数组 da3[0][1];;//类型为array_base<;int,1>; [性能] 三维大小均为100的静态,动态,原生数组以及boost::multi_array.以三重循环每次隔一个 填充, 我测试的结果,速度大概是原生数组的60%,boost数组的速度是原生数组的1/5,因此速度 大概是boost的3倍. 如果用迭代器顺序访问的话,跟原生数组相比就区别不大了.但是代码要好写一点,而且直 接支持STL算法. [实现与移植] 由于要兼顾各种编译器,而且是在VC6上做的,因此像模板偏特化等特性都不能用,需要变 通,因此相当繁琐,由此可见一个好的编译器多么重要啊. 不过话说回来,这样的代码移植性才好呢.想想连VC6都能编译的代码,移植性应该不错, :) [后记] 这是对以前的那个多维数组类的扩充与改进,增加了不少功能,去掉了不少限制, 现在静态数组的最大维数做到了3,动态数组的维数不限//你需要多高维数的?维数越高越 慢, :) 由于时间不多,精力和水平有限,其中的缺点和错误欢迎指正,也十分欢迎哪位能帮我进一 步提高访问速度. 谢谢! 附带测试程序,其中包括与boost::multi_array<;>;的速度比较代码. //the end. ^=^
C/C++中传递多维数组的各种方法
11-29
C/C++的函数中传递多维数组的各种方法,包括数组和指针的各种用法.
C\C++中的多维数组
hanxv_1987的专栏
08-01 348
（1）针对多维数组，要记住《C++Primer》中关于多维数组的描述，多维数组的数组名指向最外层的变量。int ip[6][3][3]; int ip1[3][3];可以这么理解，ip表示一个指针，该指针指向的地址存放的数据数据类型为一个3x3的int型数组。（2）多维数组中的数据在内存中是连续存储，但是遍历时不能直接使用数组名加第一层索引的形式进行遍历，int ip[6][3][3]; for (
C++ 多维数组练习
wdany的专栏
06-13 801
int ia[3][4]; int cnt = 0; for (auto &amp;row : ia){ for (auto &amp;col : row){ col = cnt++; cout&lt;&lt;col&lt;&lt;" "; } } cout&lt;&lt;endl; ...
C++类实现三维数组算法
weixin_30332705的博客
04-11 490
在学习北京大学教授的《程序设计实习 / Practice on Programming》中，遇到了一个习题，花了很长时间研究，现在分享出来： 课题地址：https://class.coursera.org/pkupop-001/human_grading/view/courses/972168/assessments/9/submissions 课题描述： 实现一个三维数组模版C...
下标操作符重载模拟多维数组详解
09-05
在给定的例子中，我们有一个名为`CMap`的模板类，用于模拟二维数组。`CMap`类有两个常量成员`m_ROW_NUM`和`m_COL_NUM`，分别表示地图的行数和列数，以及一个私有成员`_m_map_data`，它是`vector<T_CELL_STYLE>`类型...
遵循STL精神的C ++多维数组-C/C++开发
05-27
秉承STL精神，C ++多维数组关于此库提供了C ++的多维数组类，其设计目标如下：启用将数组参数指定为编译时常量，从而在某些情况下显着提高代码生成效率。 尽可能提供遵循C ++ STL约定的API。 最小的依赖关系和要求...
浅析多维数组的下标重载
09-05
在C++编程中，下标重载是一种常见技术，它允许我们自定义对象使用方括号([])操作符的行为...通过这种方式，我们可以构建出灵活且易于使用的多维数组类，同时保留了与传统数组相似的语法，提高了代码的可读性和易用性。
详解C++编程中数组的基本用法
09-02
下面将详细讲解数组的基本用法，包括初始化、访问元素、多维数组、初始化数组、静态成员数组以及数组在表达式中的表现。 1. **数组的初始化**： 在C++中，数组可以在声明时被初始化。例如，声明一个字符数组`char ...
C++实现一个二维数组类
12-22
#ifndef __H_MATRIX_H__ #define __H_MATRIX_H__ #include using namespace std; template class matrix { public: matrix(int rows， int cols):array(rows) { for (int i=0; i & operator[](int row)const { return a
c++实现任意维数向量类的操作
11-01
用c++实现任意维数的向量的各种操作！对c++初学者来说是一个很好的代码！
【Numpy库学习笔记】Numpy中dim、shape和size的理解
计算机科研杂货铺
11-20 8905
dim 理解： dim就是维数，比如数组会有一维数组，二维数组……。numpy的dim维数同理。 那如何判断numpy的维数，最简单的方法就是数一数"中括号"的数量。没有中括号，dim=0； 1个中括号，dim=1； 2个中括号，dim=2 …… 代码： import numpy as np a = np.array(3) print(a.ndim) # a的维度ndim=3 b = np.array([2]) print(b.ndim) # b的维度ndim=1 c = np.array([[
Tensorflow一些常用基本概念与函数（1）
热门推荐
lenbow的博客
08-08 15万+
摘要：本文主要对tf的一些常用概念与方法进行描述。
C++ 二维数组类练习
wwxy1995的博客
09-27 4264
#include &lt;iostream&gt; #include &lt;cstring&gt; using namespace std; class Array2 { // 在此处补充你的代码 }; int main() { Array2 a(3,4); int i,j; for( i = 0;i &lt; 3; ++i ) for( j =...
C++：简单的二维数组模板类
小豪之家
11-19 4888
这是我自己封闭的简单的二维数组模板类。欢迎大家试用 我用它来代替二维数组或二维vector（二维数组容易出错，二维vector效率太低）
c和c++分别实现动态分配二、三维数组
荒乱的没日没夜。。。
07-25 6664
本文主要目的是用c和c++分别实现动态分配二、三维数组。一般而言，在C中用malloc和free实现，而在C++中用new和delete。 new和delete是c++操作符，malloc和free是c语言函数，它们都可以用来为对象动态分配空间，最大的区别在于：当用new和 delete为对象分配空间或delete对象时，将缺省的调用对象的构造函数及析购函数，而malloc和free是原来c库
C/C++如何传递二维数组？
liyongbao1988的专栏
04-15 4万+
用二维数组作为参数传递（用二维数组处理矩阵），但是希望接受传递二维数组参数的函数可以处理任意维度的数组（希望矩阵的行数和列数都是不固定的）。 【以下转帖】 ---------------------------------------------------------------------------------------------- 但一般传递二维数组的基本规则好像是这样的：可
C++实现动态多维数组
sjhuangx的专栏
04-04 4679
在C++中多维数组是利用数组的数组来实现的，即int *ia = new int[n];可以动态创建包含n个元素的数组，如果把每个元素换成数组就成为多维数组了，int (*ia)[10]; ia = new int[10][10];不能使用int* ia[10]来声明多维数组，此时表示的是包含10个指向int*元素的数组，上面创建的数组需要指定第二维后面元素的大小，为了创建不定大小的动态多维数组，我
c++ eigen 数组赋值
最新发布
11-13
在Eigen库中，Array类是用于存储多维数组的数据结构，其特点是大小固定，连续存储，并且支持各种元素级别的运算。要对Eigen数组赋值，可以通过以下几种方式实现： 1. 使用Array的构造函数进行初始化。可以将整数、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值