动态二维数组（C++如何动态创建二维数组）

本文目录

• C++如何动态创建二维数组
• C++怎么定义一个动态二维数组
• 利用c++中的vector创建动态二维数组
• c++ 里面怎样可以实现2维动态数组的分配和释放
• 怎么定义一个二维动态数组
• QT如何定义动态二维数组
• 在c++里如何动态定义1个2维数组
• python 如何定义动态二维数组
• C语言，动态定义一个char二维数组，在设置行列值的时候，小一点的就可以，大一点就会报错
• c语言如何动态创建二维数组

C++如何动态创建二维数组

float(*cp)； //
cp=new float；//
第一条语句是申明数组指针，即cp指向一个float型的数组。
第二条语句是开辟了一个【8】【9】【8】的三位数组空间，将首地址赋给指针cp ，再给cp的操作也就是对float的空间扩大了8被，用指针操作其实是一样的，比如要取第20个元素就直接 float f = *(cp+20-1)
下面是网上找的比较详细的解释，应该比较明了了
int (*p);
定义了一个数组指针，这个指针与一般的指针没有什么区别，仅仅是这个指针指向一个数组。这里我们把数组作为了基本的元素处理。也就是说，将整个数组作为一种类型，而数组名就是这个类型的一个具体变量。例如：
int a;
一个数组类型，形状就是这样：int ;a就是新定义的一个变量。
int b;
一个数组类型，形状就是这样：int ;b就是新定义的一个变量。
因为这两个类型形状不一样，因此是两个不同的类型，因此a,b就是不同类型的变量。这就好比int a和double b ：a和b不一样。不知道大家是否已经对数组类型有了基本的印象？
那么把数组名作为该数组类型的一个具体变量，我们就可以定义指向这个变量的指针，即数组指针。
对于数组类型：int 。其余情况以此类推。

C++怎么定义一个动态二维数组

#include《stdlib.h》

#include《stdio.h》

#include《malloc.h》

#defineRANK10

#defineCOLUMN7

intmain()

{

inti,j;

int(*p);

//动态生成二维数组,指定列数为COLUMN，如果想改,可以进行修改

//的参数,如果想定义n行2列就为:p=(int(*))malloc(n*2*sizeof(int));

p=(int(*))malloc(RANK*COLUMN*sizeof(int));//动态申请n行COLUMN列的二维数组

for(i=0;i《RANK;i++)

for(j=0;j《COLUMN;j++)

p=i*j;

for(i=0;i《RANK;i++)

{

for(j=0;j《COLUMN;j++)

printf("%d,",p);

printf("\n");

}

free(p);

system("pause");

return0;

}

扩展资料

定义一个三维数组：

intx;

定义了一个三维数组，数组的名字是x，数组的长度为3，每个数组的元素又是一个二维数组，这个二维数组的长度是4。

并且这个二维数组中的每个元素又是一个一维数组，这个一维数组的长度是5，元素类型是int。多维数组在实际的工作中使用不多，并且使用方法与二维数组相似。

利用c++中的vector创建动态二维数组

    vector为C++中的一个容器类，其功能相当于动态数组。使用vector需要包含头文件vector。

    vector的常用操作：

1. v.push_back(t)    在容器的最后添加一个值为t的数据，容器的size变大。
    另外list有push_front()函数，在前端插入，后面的元素下标依次增大。
2. v.size()        返回容器中数据的个数，size返回相应vector类定义的size_type的值。

3. v.empty()     判断vector是否为空
4. v           返回v中位置为n的元素
5. v.insert(pointer,number, content)    向v中pointer指向的位置插入number个content的内容。
6. v.pop_back()    删除容器的末元素，并不返回该元素。
7.v.erase(pointer1,pointer2) 删除pointer1到pointer2中间（包括pointer1所指）的元素。
8. v1==v2          判断v1与v2是否相等。
9. ！=、《、《=、》、》=      保持这些操作符惯有含义。
10. vector《typeName》::iterator p=v1.begin( ); p初始值指向v1的第一个元素。*p取所指向元素的值。
11.   p=v1.end( ); p指向v1的最后一个元素的下一位置。
12.v.clear()      删除容器中的所有元素。12.v.clear()      删除容器中的所有元素。

    若要用vector实现二维动态数组，可用vector作模板类型参数：

vector《vector《int》 》 arr;

c++ 里面怎样可以实现2维动态数组的分配和释放

假设二维数组的元素是 Class T, 则可生成一个 template 《class T》的动态二维数组。 必须注意以下几点。
1，必须自定义一个以行数、列数为参数的构造函数。
2，必须自定义析构函数，以保证在析构该二维数组类的同时确实清除所有元素的内存空间。
3，为了使用方便，建议重载括号操作符，实现对元素的引用。
4, 建议查看 CArray 的源码，以确认每个步骤。
下面是基本框架：
头文件：
#include 《afxtempl.h》
template 《class T》 class C2dArray: public CArray《CArray《T, T&》, CArray《T,T&》&》
{
protected:
short row, col;
public:
C2dArray();
C2dArray(short row, short col);
SetSize(short row, short col);
virtual ~C2dArray();

T& operator () (short row, short col); // 重载括号操作

};

template 《class T》 inline T& C2dArray《T》::operator () (short row, short col)
{
.....
}

CPP 文件：
template 《class T》 C2dArray《T》::C2dArray()
{ SetSize(0,0);}
template 《class T》 C2dArray《T》::C2dArray(short row, short col)
{ SetSize(row,col);}
template 《class T》 C2dArray《T》::SetSize(short row, short col)
{
.....
}
template 《class T》 C2dArray《T》::~C2dArray()
{
...
}
C++ 的 new 操作直接支持多维数组的申请。详情可参考 new 的联机帮助。
new 支持多维数组的申请, 但仅对最高维是动态的，较低维的各维的长度必须是常数。本人编写了两个动态多维数组申请和释放的函数。 分别为mnew 和 mdelete. 代码如下。注意，其中可变参数列表中的数必须是长整型的。第二个参数 dimention 表示的是要申请的数组的维数，后面就是各维所对应的长度。
char * mnew (unsigned long typesize, unsigned short dimention, ...) /*=============================================================================
by Kan ZENG, 2000.02.16. tested on 2000.02.16

mnew and mdelete are couple of routines to deal with allocing and freeing
the memory for multi-dimention array.
para:
typesize -- the size in byte of one element
dimention - the number of dimention
... - the variational argument list. each one MUST BE long interger.
The further right, the lower the dimention is.

p - the pointer which was alloced by mnew

Return:
mnew return the first address of alloced memory block if successful or NULL
if fail.

Usage:
if a double type 3D dynamical array is required, the method to using mnew as
following:
double ***myarray =
(double ***) mnew(sizeof(double),3, (long)n3, (long)n2, (long)n1);

After that, you can refer the element as usual:
e.g. myarray=45.77;
=============================================================================*/
{
va_list vl;
long i, j;
long prdt1, prdt2;
long *dim;
char *res;

if (dimention 《1) return NULL;

dim= new long;

// dimention is the last argument specified; all
// others must be accessed using the variable-
// argument macros.
va_start( vl, dimention);

// Step through the list.
for(i=dimention-1; i》=0; i--)
dim=va_arg( vl, long );
va_end( vl );

if (dimention==1) {
res = new char;
delete dim;
return res;
}

prdt1=dim;
for(i=2; i ++prdt1 *= dim;
prdt2 *= dim;
}

if ((res=new char)==NULL) {
delete dim;
return NULL;
}

char *p;
void **q2, **p1, **p2;

p = res+prdt1*sizeof(void *) ;
q2 = (void **)p;
prdt2 /= dim;
q2 -= prdt2;

p2 = q2;
for(j=0; j *p2=p;
p2++;
p+=dim*typesize;
}

for(i=1; i《(dimention-1); i++) {
p1=q2;
prdt2 /= dim;
q2 -= prdt2;
p2 = q2;
for(j=0; j *p2=p1;
p2++; p1+=dim;
}
}

delete dim;
return res;
}

void mdelete(void * p)
{
if (p==NULL) return;
delete (char *)p;
p=NULL;
}
或者用两个宏，如下：
#define matrix_allocate(matrix, width, height, TYPE) {\
matrix = new TYPE* ;\
for(int _i = 0; _i 《 height; _i++)\
matrix;\
}
#define matrix_delete(matrix, width, height){\
for(int _i = 0; _i 《 height; _i++)\
delete ;\
delete matrix;\
matrix = 0;\
}

怎么定义一个二维动态数组

用new申请空间；
再在对每个数进行初始化；
//动态定义和初始化二维数组 部分代码
cout《《"输入二维数组的行，列 :";
cin》》row 》》col ;
int **p2 ;
p2 = new int* ;
for( i = 0 ; i 《 row ; i ++ )
p2 ;
//输入二维数组的值
for( i = 0 ; i 《 row ; i ++ )
for( j = 0 ; j 《 col ; j ++ )
p2 = rand() % 10 ;
//输出二维数组
cout《《"输出二位数组："《《endl;
for( i = 0 ; i 《 row ; i ++ )
{
for( j = 0 ;j 《 col ; j ++ )
cout《《p2《《’ ’ ;
cout《《endl;
}
//释放二维数组
for( i = 0 ; i 《 row ; i ++ )
delete ;
delete p2 ;

QT如何定义动态二维数组

我给你个动态分配二维数组的函数，访问二维数组就看范例的应用吧。
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
int **AllocIntArray(int row,int col)
{
int i,j;
int **pArray;
pArray=(int **)malloc(row*sizeof(int *));
if(pArray==NULL) return NULL;
for(i=0;i《row;i++)
{
pArray=(int *)malloc(col*sizeof(int));
if(pArray==NULL)
{
for(j=0;j《i;j++)
{
free(pArray);
}
free(pArray);
return NULL;
}
for(j=0;j《col;j++)
{
pArray=0;
}
}
return pArray;
}
int main(void)
{
int **pArray;
int row=15,col=16;
int i,j,n;
pArray=AllocIntArray(row,col);
if(pArray==NULL) return 1;/*内存分配失败*/
for(n=0,i=0;i《row;i++)
{
for(j=0;j《col;j++)
{
pArray=n++/*此处赋值*/
}
}
for(n=0,i=0;i《row;i++)
{
for(j=0;j《col;j++)
{
printf("%3d ",pArray);
}
printf("\n");
}
getch();
return 0;
}

在c++里如何动态定义1个2维数组

c++里动态定义2维数组方法为：

1. 定义二维指针

2. 分配”行指针“数组

3. 为每行分配数据数组

4. 使用二维数组

5. 释放每行的数据数组 （不再使用该内存后，要手工完成内存的释放）

6. 释放”行指针“数组

参考代码：

#include 《iostream》
#include 《iomanip》
using namespace std ;
#define ROW 5
#define COL 10
int main()
{
    int **pp,i,j;
    pp=new int *; //分配行指针数组，返回数组首地址给pp
    for( i=0;i《ROW;i++ )
        pp; //为每行分配数据数组
for( i=0;i《ROW;i++ ){
        for( j=0;j《COL;j++ )
            pp=(i+1)*(j+1) ; //向二维数组中存储数据
    }
cout 《《 "ARRAY’s ADDRESS: " 《《 pp 《《endl;
    for( i=0;i《ROW;i++ ){
        cout 《《 "ROW_"《《i+1《《"’s ADDRESS: "《《 pp ; //输出每行的地址
        for( j=0;j《COL;j++ )
            cout 《《 setw(3)《《pp ; //输出数组元素
        cout 《《endl ;
    }
    for( i=0;i《ROW;i++ )
        delete ; //释放每行的指针
    delete pp ; //释放指针数组
    return 0;
}

c++动态定义2维数组，实际上是先分配一个指针数组，然后再为每个指针数组分配相应的数据数组。与真正的二维数组的差别是：

1. 二维数组的存储空间是在内存中连续的，实际上还是个一维数组，只是将一维数组分成了N段；而动态分配的二维数组，其行指针数组是一个连续的一维数组，其中存储的是一维指针，这些指针值不一定是连续的，与内存使用情况有关。

2. 从中还可以看出，动态二维数组，比真正的二维数组多了一个行指针数组的多余内存消耗。

3. 动态定义的二维数组每一行的列宽可以是变化的（一般情况下是一样宽的）；真正的二维数组每行的列宽必须且只能一样。
   

4. 真正的二维数组在其所定义的函数结束后，内存自动释放；动态定义的二维数组，需要用显式的代码进行内存释放。

python 如何定义动态二维数组

Python中创建二维列表/数组，即创建一个list，并且这个list的元素还是list。可以用列表解析的方法实现。
创建例子如下：
2d_list =
其中cols, rows变量替换为你需要的数值即可，例如：
2d_list = # 9*9的二维列表

C语言，动态定义一个char二维数组，在设置行列值的时候，小一点的就可以，大一点就会报错

 p=(char **)malloc(x*sizeof(char*));

如此修改就可以了。

c语言如何动态创建二维数组

既然是动态创建，那么，所创建的二维数组的行、列数应该具有“普适”性，即，应由“用户”确定二维数组的规模。这是有难度的。因为，二维数组要牵扯行指针，且需要固定每行的列元素个数，用这种思路就没有办法达到“普适”。
为此，必须清醒地知道，所谓二维数组，其元素在内存中依然是以一维的方式存放的。说实话，二维数组本质上是不存在的。
既然如此，那么，“构造”一个所谓的二维数组，只要能提供足够实用的函数（工具）操作这个二维数组就可以了。
综上，接受由用户决定的二维数组行、列值，申请一个一维数组的空间，按照二维数组方式进行定位和操作就可以了。
为简便起见，我用如下定义，你可以更改里面的类型，以适应自己的需要：
typedef int USER_TYPE;
// 定义一个控制二维数组（矩阵）的“控制头”，由三个成员组成
typedef struct MATRIX
{
USER_TYPE *data; // 真正用来存储二维数组元素的空间
int Row; // 二维数组行数
int Col; // 二维数组列数
}MATRIX;
MATRIX *initMatrix(int row, int col); // 初始化二维数组
USER_TYPE getElementAt(MATRIX matrix, int i, int j); // 取得指定下标的元素
void setElementAt(MATRIX matrix, int i, int j, USER_TYPE val); // 给指定下标的元素赋值
void destroyMatrix(MATRIX *matrix); // 销毁二维数组
void destroyMatrix(MATRIX *matrix)
{
free(matrix-》data);
free(matrix);
}
void setElementAt(MATRIX matrix, int i, int j, USER_TYPE val)
{
matrix.data = val;
}
USER_TYPE getElementAt(MATRIX matrix, int i, int j)
{
return matrix.data;
}
MATRIX *initMatrix(int row, int col)
{
MATRIX *mp;
mp = (MATRIX *)malloc(sizeof(MATRX));
mp-》data = (USER_TYPE *)malloc(sizeof(USER_TYPE) * row * col);
mp-》Row = row;
mp-》Col = col;
return mp;
}
把上面的函数当成工具，完成二维数组初始化、赋值、取值等一系列操作，如果需要比较，还需要编写比较的函数。