精华内容
下载资源
问答
  • C++:简单的二维数组模板类

    千次阅读 2013-11-19 18:09:04
    这是我自己封闭的简单的二维数组模板类。欢迎大家试用 我用它来代替二维数组或二维vector(二维数组容易出错,二维vector效率太低)
    这是我自己封闭的简单的二维数组模板类。欢迎大家试用
    

    我用它来代替二维数组或二维vector(二维数组容易出错,二维vector效率太低)

    #ifndef DOUBLE_D_ARRAY
    #define DOUBLE_D_ARRAY
    
    #include <string>
    #include <iostream>
    #include <cassert>
    #include <cstdio>
    using namespace std;
    
    //这是一个简单的二维数组的封装类,类似于二维的vector,是用一维数组实现的
    //效率比较高,但不提供改变行数和列数的功能
    template<class Type>
    class DoubleDArray
    {
    private:
    	bool m_HaveInit;		//判断该类是否已经初始化
    	Type *m_Array;			//存放数据的数组
    	int m_Row;				//行数
    	int m_Column;			//列数
    
    	//将二维数据的行列转成一维数组的索引
    	int GetIndex(int row, int column) const;
    
    	//清空数组(变成末初始化状态)
    	void ClearArray();
    
    	//复制该数组
    	void CloneArray(const DoubleDArray &array);
    
    public:
    	DoubleDArray();
    	DoubleDArray(int row, int column);
    	DoubleDArray(const DoubleDArray &array);
    	~DoubleDArray();
    	DoubleDArray &operator=(const DoubleDArray &array); // 赋值运算符  
    
    	//初始化该数组, row,column分别是行数和列数
    	void InitArray(int row, int column);
    
    	//设置和获取数据
    	void SetValue(int row, int column, Type value);
    	Type GetValue(int row, int column) const;
    };
    
    template<class Type>
    DoubleDArray<Type>::DoubleDArray()
    {
    	m_HaveInit = false;
    	m_Array = NULL;
    	m_Column = m_Row = 0;
    }
    
    template<class Type>
    DoubleDArray<Type>::DoubleDArray(int row, int column)
    {
    	DoubleDArray();
    	InitArray(row, column);
    }
    
    template<class Type>
    DoubleDArray<Type>::DoubleDArray(const DoubleDArray<Type> &array)
    {
    	m_Array = NULL;
    	CloneArray(array);
    }
    
    template<class Type>
    DoubleDArray<Type>::~DoubleDArray()
    {
    	ClearArray();
    }
    
    template<class Type>
    DoubleDArray<Type> &DoubleDArray<Type>::operator=(const DoubleDArray<Type> &array)
    {
    	if( this != &array )
    		CloneArray(array);
    	return *this;
    	
    }
    
    template<class Type>
    int DoubleDArray<Type>::GetIndex(int row, int column) const
    {
    	assert(m_HaveInit);
    	assert(column < m_Column);
    	assert(row < m_Row);
    	return row * m_Column + column;
    }
    
    template<class Type>
    void DoubleDArray<Type>::CloneArray(const DoubleDArray &array)
    {
    	ClearArray();
    	if( !array.m_HaveInit )
    		return;
    	InitArray(array.m_Row, array.m_Column);
    	int all = array.m_Row * array.m_Column;
    	for(int i=0; i<all; i++)
    		m_Array[i] = array.m_Array[i];
    }
    
    
    template<class Type>
    void DoubleDArray<Type>::ClearArray()
    {
    	if( !m_HaveInit )
    		return;
    	m_HaveInit = false;
    	m_Row = m_Column = 0;
    	if( m_Array != NULL )
    	{
    		delete [] m_Array;
    		m_Array = NULL;
    	}
    }
    
    template<class Type>
    void DoubleDArray<Type>::InitArray(int row, int column)
    {
    	if( m_Array != NULL )
    		delete [] m_Array;
    	m_Array = new Type[row*column];
    	m_HaveInit = true;
    	m_Row = row;
    	m_Column = column;
    }
    
    template<class Type>
    void DoubleDArray<Type>::SetValue(int row, int column, Type value)
    {
    	int index = GetIndex(row, column);
    	m_Array[index] = value;
    }
    
    template<class Type>
    Type DoubleDArray<Type>::GetValue(int row, int column) const
    {
    	int index = GetIndex(row, column);
    	return m_Array[index];
    }
    
    #endif
    
    //测试例子
    int main()
    {
    	DoubleDArray<int> dd;
    	dd.InitArray(10, 10);
    	for(int i=0; i<10; i++)
    		for(int j=0; j<10; j++)
    			dd.SetValue(i, j, i+j);
    
    	for(int i=0; i<10; i++)
    	{
    		for(int j=0; j<10; j++)
    			printf("%d ", dd.GetValue(i, j));
    		printf("\n");
    	}
    
    	DoubleDArray<int> copy(dd);
    	copy.SetValue(5, 5, 2345);
    	printf("\n%d  %d\n", copy.GetValue(5, 5), dd.GetValue(5, 5));
    	return 0;
    }


    展开全文
  • 简单二维数组模板类

    2008-05-28 20:16:00
    templateclass Array{ public: Array(int row,int col); ~Array(); T** GetArray(){return array;} int GetRow(){return _row;} int GetCol(){return _col;}private: int _row; int _col;...
    template<class T>
    class Array{ 
    public:
     Array(int row,int col);
     ~Array();
     T** GetArray(){return array;}
     int GetRow(){return _row;}
     int GetCol(){return _col;}
    private:
     int _row;
     int _col;
     T** array;
    };
    template<class T>
    Array<T>::Array(int row,int col):_row(row),_col(col)
    {
     array=new T*[row];
     for(int i=0;i<row;i++)
      array[i]=new T[col]; 
    }
     
    template<class T>
    Array<T>::~Array()
    {
     for(int i=0;i<_row;i++)
      delete [] array[i];
     delete [] array;
    }
    展开全文
  • CArray3d三维数组模板类(简洁操作)

    千次阅读 2019-09-28 11:30:13
    003:很难蒙混过关的CArray3d三维数组模板类 这是一个比较简洁的写法: template<class T> class CArray3D { public: T***arr; CArray3D(int X,int Y,int Z) { arr=new T**[X]; for(int j=0;j<X;j++) ...

    003:很难蒙混过关的CArray3d三维数组模板类

    这是一个比较简洁的写法:

    template<class T>
    class CArray3D
    {
        public:
         T***arr;
         CArray3D(int X,int Y,int Z)
         {
          arr=new T**[X];
          for(int j=0;j<X;j++)
          {
           arr[j]=new T*[Y];
           for(int k=0;k<Y;k++)
           {
            arr[j][k]=new T[Z];
        }
       }
      }
      T** operator[](const int index) const
      {
       return arr[index];//为了方便理解,这里也可以改成return *(arr+index);
      }
    };

    嗯,直接通过申请一个三级指针并对[ ]进行重载,就可以了。
    返回值必须是一个二级指针,因为库里的[ ]原本就有对二级指针的操作,对一级指针和二级指针就不需要重载了。

    同样对二维数组的操作也一样,只要把T**变成T*就OK了。
    对于使用const,不是写给自己看的,而是给别人和编译器看的,告诉它们,这里不要修改,间接修改也不行。

    展开全文
  • 实现一个三维数组模版CArray3D,可以用来生成元素为任意类型变量的三维数组,输出指定结果 #include <iostream> #include <iomanip> #include <cstring> using namespace std; template <...

    描述
    实现一个三维数组模版CArray3D,可以用来生成元素为任意类型变量的三维数组,输出指定结果

    #include <iostream>
    #include <iomanip> 
    #include <cstring>
    using namespace std;
    template <class T>
    class CArray3D
    {
    // 在此处补充你的代码
    };
    
    CArray3D<int> a(3,4,5);
    CArray3D<double> b(3,2,2);
    void PrintA()
    {
    	for(int i = 0;i < 3; ++i) {
    		cout << "layer " << i << ":" << endl;
    		for(int j = 0; j < 4; ++j) {
    			for(int k = 0; k < 5; ++k) 
    				cout << a[i][j][k] << "," ;
    			cout << endl;
    		}
    	}
    }
    void PrintB()
    {
    	for(int i = 0;i < 3; ++i) {
    		cout << "layer " << i << ":" << endl;
    		for(int j = 0; j < 2; ++j) {
    			for(int k = 0; k < 2; ++k) 
    				cout << b[i][j][k] << "," ;
    			cout << endl;
    		}
    	}
    }
    
    int main()
    {
    
    	int No = 0;
    	for( int i = 0; i < 3; ++ i ) {
    		a[i];
    		for( int j = 0; j < 4; ++j ) {
    			a[j][i];
    			for( int k = 0; k < 5; ++k )
    				a[i][j][k] = No ++;
    			a[j][i][i];	
    		}
    	}
    	PrintA();
    	memset(a[1],-1 ,20*sizeof(int));	
    	memset(a[1],-1 ,20*sizeof(int));
    	PrintA(); 
    	memset(a[1][1],0 ,5*sizeof(int));	
    	PrintA();
    
    	for( int i = 0; i < 3; ++ i )
    		for( int j = 0; j < 2; ++j )
    			for( int k = 0; k < 2; ++k )
    				b[i][j][k] = 10.0/(i+j+k+1);
    	PrintB();
    	int n = a[0][1][2];
    	double f = b[0][1][1];
    	cout << "****" << endl;
    	cout << n << "," << f << endl;
    		
    	return 0;
    }
    

    输入

    输出
    等同于样例
    样例输入

    样例输出

    layer 0:
    0,1,2,3,4,
    5,6,7,8,9,
    10,11,12,13,14,
    15,16,17,18,19,
    layer 1:
    20,21,22,23,24,
    25,26,27,28,29,
    30,31,32,33,34,
    35,36,37,38,39,
    layer 2:
    40,41,42,43,44,
    45,46,47,48,49,
    50,51,52,53,54,
    55,56,57,58,59,
    layer 0:
    0,1,2,3,4,
    5,6,7,8,9,
    10,11,12,13,14,
    15,16,17,18,19,
    layer 1:
    -1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,
    layer 2:
    40,41,42,43,44,
    45,46,47,48,49,
    50,51,52,53,54,
    55,56,57,58,59,
    layer 0:
    0,1,2,3,4,
    5,6,7,8,9,
    10,11,12,13,14,
    15,16,17,18,19,
    layer 1:
    -1,-1,-1,-1,-1,
    0,0,0,0,0,
    -1,-1,-1,-1,-1,
    -1,-1,-1,-1,-1,
    layer 2:
    40,41,42,43,44,
    45,46,47,48,49,
    50,51,52,53,54,
    55,56,57,58,59,
    layer 0:
    10,5,
    5,3.33333,
    layer 1:
    5,3.33333,
    3.33333,2.5,
    layer 2:
    3.33333,2.5,
    2.5,2,
    ****
    7,3.33333
    

    提示
    建议做法:

    1. a[i][j][k] 这个表达式的第一个[]返回一个内部类的对象,该内部类也重载了[],且返回值为指针。
    2. 必要时需重载对象到指针的强制类型转换运算符

    解题
    先复习二维数组的做法,
    即建立初始数组 a[i * j],大小为二维数组大小,
    找寻 a[n][0] 地址即为 a[n * j];
    找寻a[n][m]即为a[n * j][m];
    由此考虑三维数组的表示方法——构建指针T *p = new T [i * j * k];


    故先定义共有成员——ijk以及指针 * p
    构造函数—— * p的赋值;

    
    public:
    int i;
    int j;
    int k;
    T *p; 
    
    CArray3D(int a, int b, int c){
    	i=a;
    	j=b;
    	k=c;
    	p=new T[i*j*k];
    }
    
     ~CArray3D() { delete [] p; }
    

    先考虑实现三维数组内的二维数组
    构造类中类Aid;
    成员函数 ip为该二维数组的起始地址——即三维数组的 * (ip)= * (p + i * j * k]);
    成员函数 k每列的元素——即二维数组的a[i][j]=* (ip+j*k)中所需的k ;
    得到这俩再后面添加第三个括号即可得到三维数组的地址。

    
    class Aid {
    	public:
    		T * ip;      //指向i层元素的起始地址 
    		int k;        //每个j层有k个元素
    		
    		Aid(T* a, int b):ip(a),k(b){}   //构造函数 
    		
    		T* operator [](int j){     //重构【】 , 返回指针——及第三维的数组指针
    		//第二个框——到j行,返回j行的开头位置
    		//再调用第三个框——即可得到j行的第k个位置了 
    			return ip+j*k;       //返回i层的j行的起始位置 
    		}
    		
    		//类型转换运算符重载,将对象转换成T *类对象,不写返回值类型 
    		operator T *(){        // T* a[i],返回a[i]的ip,类型为T* 
    			return ip;      //ip表示第i行的起始位置——故a[1]对象可被强制转换为起始位置指针 
    		}
    };
    

    重载CArray3D的[ ]符号
    重载返回值为类中类Aid,且附上参数——ip,k
    ip = p+i * j * k;
    k = k;

    Aid operator[](int i) {        //a[i],返回Aid对象 
    	T * ip =p+i*j*k;			//第一个框——到第i层 
    	return Aid(ip,k);      //每层j行,每行k个元素      
    }
    

    完整代码

    class CArray3D
    {
    //实现一个三维数组模版CArray3D,
    //可以用来生成元素为任意类型变量的三维数组,输出指定结果
    // 在此处补充你的代码
    //建议做法:
    //1. a[i][j][k] 这个表达式的第一个[]返回一个内部类的对象,该内部类也重载了[],且返回值为指针。
    //2. 必要时需重载对象到指针的强制类型转换运算符
    
    public:
    int i;
    int j;
    int k;
    T *p; 
    
    CArray3D(int a, int b, int c){
    	i=a;
    	j=b;
    	k=c;
    	p=new T[i*j*k];
    }
    
     ~CArray3D() { delete [] p; }
    
    class Aid {
    	public:
    		T * ip;      //指向i层元素的起始地址 
    		int k;        //每个j层有k个元素
    		
    		Aid(T* a, int b):ip(a),k(b){}   //构造函数 
    		
    		T* operator [](int j){     //重构【】 , 返回指针——及第三维的数组指针
    		//第二个框——到j行,返回j行的开头位置
    		//再调用第三个框——即可得到j行的第k个位置了 
    			return ip+j*k;       //返回i层的j行的起始位置 
    		}
    		
    		
    		//类型转换运算符重载,将对象转换成T *类对象,不写返回值类型 
    		operator T *(){        // T* a[i],返回a[i]的ip,类型为T* 
    			return ip;      //ip表示第i行的起始位置——故a[1]对象可被强制转换为起始位置指针 
    		}
    };
    
    Aid operator[](int i) {        //a[i],返回Aid对象 
    	T * ip =p+i*j*k;			//第一个框——到第i层 
    	return Aid(ip,k);      //每层j行,每行k个元素      
    }
    //
    };
    
    展开全文
  • 实现一个三维数组模版CArray3D,可以用来生成元素为任意类型变量的三维数组,输出指定结果 #include <iostream> #include <iomanip> #include <cstring> using namespace std; template <...
  • ​最近项目中遇到一个需求,编写一个一维数组模板类和二维数组模板类让公司框架支持,要求拥有静态数组的大部分功能。 可能简短的几行代码并不能看出难在哪里,但是对我来说确实是为它的设计方法苦思冥想了一两天,...
  • c++二维数组

    2016-11-11 00:03:03
    这是我自己封闭的简单的二维数组模板类。欢迎大家试用 我用它来代替二维数组或二维vector(二维数组容易出错,二维vector效率太低) [cpp] view plain copy  print? #ifndef DOUBLE_D_...
  • #ifndef __H_MATRIX_H__ #define __H_MATRIX_H__ #include using namespace std; template class matrix { public: matrix(int rows, int cols):array(rows) ... i<rows> & operator[](int row)const ...
  • 一、二维数组以及多维数组 1、二维数组定义: ​ 在一维数组中定义每一个元素也是一个数组元素,这样的数组称为“二维数组” ​ 多维数组就是在一维数组上再次定义二维数组或三维数组等。 ​ 一维数组定义 int [] ...
  • 使用模板创建二维数组

    千次阅读 2016-03-16 11:45:42
    使用模板类创建数组 以及 二维数组模板类递归) */ #include using namespace std; template //默认类型参数 和 非类型参数(只能传递常量/常变量/常量表达式) class Array{ private: T m_array[S]; public...
  • vector的两种构造方式 vecotr的初始化中,有这么一个方式 vector<int> vec(n);...知道了上面的两种方法,我们就可以快速构造一个m*n的vector二维数组 vector<int> tmp(n); vector<vector&l
  • vector本来就是可以用来代替一维数组的,vector提供了operator[]函数,可以像数组一样的操作,而且还有边界检查,动态改变大小。这里只介绍用它来代替二维的数组,二维以上的可以依此类推。1、定义二维vectorvector ...
  • C++模板编程实现二维数组

    千次阅读 2014-12-18 12:04:46
    数组在C语言里面经常使用,有一个缺陷就是必须在定义的...使用模板的通用性很强,数组可能是int类型,也可能是bool类型……,使用模板就避免了为每一种类型去量身定制一套相同的功能。我想,这也是C++模板的初衷吧。
  • 动态二维数组的创建,先挖个坑。有人看的话会更吧。打算写一个类模板,然后用allocate申请内存配置(逃创建二维动态数组的方法: 假设需要一个 n * n 的二维 int 数组,由于 new 只能创建一维数组,所以先创建一个...
  • 二维数组 在数组中定义数组,第二维数组是第一维数组的每一个数据。 定义: 动态: 数据类型[][] 数组名 =new 数据类型[外层一维的长度][内层二维的长度] 数据类型 数组名[][] = new 数据类型[外层一维的长度][]; ...
  • 二维数组 所谓二维数组,可以简单的理解为是一种“特殊”的一维数组,它的每个数组空间中保存的是一个一维数组。 那么如何使用二维数组呢,步骤如下: 声明数组并分配空间 数据类型[][] 数组名= new 数据类型[行的...
  • carray是一个动态数组,且提供了无限扩展的能力,您可以用它来定义一个n维数组,并且每一序列的数组长度不需要相同。 carray<class T> name(long num) 表示创建一个初始长度为num,类型为T的数组 void ...
  • 【C++】重载二维数组下标 [ ][ ]

    千次阅读 2014-03-16 19:34:25
    1. 分析 重载一维数组下标很简单,通过下标传入的索引值,返回内部数组中...下面是两个 int 数组,第(1)个是熟悉的一维数组,第(2)个是熟悉的二维数组,现在你要做的就是将第(2)个数组看成是一个一维数组。
  • MFC CArray可实现大小可扩展的一...2. 本文方法---直接从CArray模板类嵌套产生,可实现任意类型的二维数组。 这里以int类型为例,在基于对话框的应用程序中,添加按钮的消息处理函数: void CxxxDlg::OnBnClicked...
  • 数组与面向对象数组一维数组 数组:[ ] 存储相同类型的多个数据 变量:单个数据 数组:多个数据 数组的特点: 引用数据类型 数据是个容器,长度一旦确定不可改变 一个数组中存放的多个数据的类型要求一致 数组...
  • 树状数组模板类

    2018-10-30 20:29:45
    //树状数组类 class BITree {//树状数组数值处理部分:1~BITree_num //实际操作中建议数组开大一点 public: BITree(int dim,int x,int y); //构造(数,树状数组长度) ~BITree(); //析构 in...
  • 1. java.util.Arrays 数组工具 Arrays.toString (数组) 数组值链接字符串 Arrays.sort(数组) 基本类型: 优化的快速排序 引用类型: 优化的合并排序 Arrays.binarySearch(数组,目标值) 二分法查找 ...
  • C++ STL库中的vector类似于封装了一个动态的数组,非常的好用,关于vector的一些函数,见这篇博客: ...首先是一维数组的创建,一维数组可以直接创建,也可以通过数组的方式创建 int arr[] = {1, 2,...
  • C++中动态分配一维数组是十分常见的事,但会分配一维数组的人并不一定会分配二维数组。因为我想,不到特殊情况,我们可能很少想过要使用动态分配的二维数组。但不管怎么样,只要你是第一次想试着去分配一个二维数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,289
精华内容 8,915
关键字:

二维数组模板类