C++如何动态申请二维数组

最新推荐文章于 2024-05-01 06:59:00 发布
最新推荐文章于 2024-05-01 06:59:00 发布
阅读量3.3k 收藏 5
点赞数
分类专栏： C++知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38036750/article/details/83550980
版权

最近在写cuda相关的代码遇到矩阵的问题就避免不了二维动态数组的内存申请。所以实际测了一下，一下代码可以用。

#include <iostream>
#include <stdlib.h>
int main()
{

	double **V,*h_c;
	V = (double**)malloc(10*sizeof(double*));//正确格式
	h_c = (double*)malloc(10*sizeof(double));
	for(int i = 0;i < 10;i++)
	{
		V[i] = (double*)malloc(10*sizeof(double));
	}
	
	for(int i = 0;i < 10;i++)
	{
		for(int j = 0;j < 10;j++)
		{
			V[i][j] = (double) (i+1) * j;
		}
	}
	for(int i = 0;i < 10;i++)
	{
		h_c[i] = V[0][i] + V[1][i];
		std::cout << "h_c[" << i << "]=" << h_c[i] << std::endl;
	}
	
	for(int i = 0;i < 10;i++)        //释放内存格式
	{
		free(V[i]);
	}
	free(V);
	return 0;
}

上面那个不好看；这是最新更新的。

#include <iostream>
#include <stdlib.h>
int main()
{

	double **V;
	int n, m;
	std::cin >> n;//n为行m为列
	V = (double**)malloc(n * sizeof(double*));//正确格式	
	for (int i = 0; i < n; i++)
	{
		V[i] = (double*)malloc(m * sizeof(double));
	}	
	std::cin >> m;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			V[i][j] = 0;
		}
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			std::cout << "V[" << i << "][" << j << "] = " << V[i][j] << "\t";		
		}
		std::cout << std::endl;
	}

	for (int i = 0; i < n; i++)        //释放内存格式
	{
		free(V[i]);
	}
	free(V);
	return 0;
}

在C++中动态创建一个二维的数组矩阵：

main.cpp

#include "head.h"

int main()
{
	
	DBN dbn(1);//初始化要创建的向量的维数n=1。维数为4*（2*n）的矩阵，这里我写的是行数固定的矩阵
	dbn.DBn_init(dbn.GetDBn());//这个是初始化矩阵
	dbn.print();//打印矩阵信息
	return 0;
}

DBN.cpp

#include "head.h"


DBN::DBN(int n):DBn(n)//构造函数设置n的初始值。
{
	pMatrix = creatMatrix();//创建矩阵

}
DBN::~DBN()//析构函数
{
}
pMAT DBN::creatMatrix()//创建矩阵函数
{
	pMAT pMatrix = (MAT*)malloc(sizeof(MAT));//先申请一块pMAT数据类型的内存，叫pMatrix
	pMatrix -> filter = (double**)malloc(4 * sizeof(double*));//在申请pMartix中的filter的内存。这个参考申请二维数组内存的方式
	for (int i = 0; i < 4; ++i)
	{
		pMatrix->filter[i] = (double*)malloc(2 * DBn * sizeof(double));
	}
	for (int i = 0; i < 4; ++i)//给矩阵初始化为0矩阵
	{
		for (int j = 0; j < 2 * DBn; ++j)
		{
			pMatrix->filter[i][j] = 0;
		}
	}
	return pMatrix;返回pMartix的指针
}
void DBN::print()//打印矩阵的数据 
{
	for (int i = 0; i < 4; ++i)
	{
		for (int j = 0; j < 2 * DBn; ++j)
		{
			std::cout << "filter[" <<i <<"]["<<j<<"]= " << pMatrix->filter[i][j] << "\t";
		}
		std::cout << std::endl;
	}
}


void DBN::DBn_init(int n)//初始化函数
{
	switch (n)
	{
	case 1:
		for (int i = 0; i < 2 * n; ++i)
		{
			pMatrix -> filter[0][i] = db1_Lo_D[1 - i];
			pMatrix -> filter[1][i] = db1_Hi_D[1 - i];
			pMatrix -> filter[2][i] = db1_Lo_R[1 - i];
			pMatrix -> filter[3][i] = db1_Hi_R[1 - i];
		}
		break;
	default:
		break;
	}
}

int DBN::GetDBn()//设置矩阵维数的函数
{
	return this->DBn;
}

DBN.h

#ifndef __DBN_H__
#define __DBN_H__

typedef struct Matrix//定义矩阵数据类型
{
	double** filter;
}MAT, *pMAT;

class DBN
{
private:
	int DBn;	
	pMAT pMatrix;//声明矩阵，占一块内存
public:
	DBN(int n);
	~DBN();
	pMAT creatMatrix();
	void DBn_init(int n);
	void print();
	int GetDBn();
};

#endif

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <iostream>
#include "DBN.h"



const double  db1_Lo_D[2] = { 0.70710678118654752440084436210485, 0.70710678118654752440084436210485 };
const double  db1_Hi_D[2] = { -0.70710678118654752440084436210485, 0.70710678118654752440084436210485 };
const double  db1_Lo_R[2] = { 0.70710678118654752440084436210485, 0.70710678118654752440084436210485 };
const double  db1_Hi_R[2] = { 0.70710678118654752440084436210485, -0.70710678118654752440084436210485 };

const double db2_Lo_D[4] = { -0.129409522550921, 0.224143868041857, 0.836516303737469, 0.482962913144690 };      // 小波变换分解低通滤波器
const double db2_Hi_D[4] = { -0.482962913144690, 0.836516303737469, -0.224143868041857, -0.129409522550921 };    // 小波变换分解高通滤波器
const double db2_Lo_R[4] = { 0.482962913144690, 0.836516303737469, 0.224143868041857, -0.129409522550921 };      // 小波变换重构低通滤波器
const double db2_Hi_R[4] = { -0.129409522550921, -0.224143868041857, 0.836516303737469, -0.482962913144690 };    // 小波变换重构高通滤波器

const double  db3_Lo_D[6] = { 0.0352262918857095, -0.0854412738820267, -0.1350110200102546, 0.4598775021184914, 0.8068915093110924, 0.3326705529500825 };
const double  db3_Hi_D[6] = { -0.3326705529500825, 0.8068915093110924, -0.4598775021184914, -0.1350110200102546, 0.0854412738820267, 0.0352262918857095 };
const double  db3_Lo_R[6] = { 0.3326705529500825, 0.8068915093110924, 0.4598775021184914, -0.1350110200102546, -0.0854412738820267, 0.0352262918857095 };
const double  db3_Hi_R[6] = { 0.0352262918857095, 0.0854412738820267, -0.1350110200102546, -0.4598775021184914, 0.8068915093110924, -0.3326705529500825 };

const double db4_Lo_D[8] = { -0.0105974017850690, 0.0328830116668852, 0.0308413818355607, -0.1870348117190931, -0.0279837694168599, 0.6308807679398587, 0.7148465705529154, 0.2303778133088964 };
const double db4_Hi_D[8] = { -0.2303778133088964, 0.7148465705529154, -0.6308807679398587, -0.0279837694168599, 0.1870348117190931, 0.0308413818355607, -0.0328830116668852, -0.0105974017850690 };
const double db4_Lo_R[8] = { 0.2303778133088964, 0.7148465705529154, 0.6308807679398587, -0.0279837694168599, -0.1870348117190931, 0.0308413818355607, 0.0328830116668852, -0.0105974017850690 };
const double db4_Hi_R[8] = { -0.0105974017850690, -0.0328830116668852, 0.0308413818355607, 0.1870348117190931, -0.0279837694168599, -0.6308807679398587, 0.7148465705529154, -0.2303778133088964 };

const double  db5_Lo_D[10] = { 0.1601, 0.6038, 0.7243, 0.1384, -0.2423, -0.0322, 0.0776, -0.0062, -0.0126, 0.0033 };
const double  db5_Hi_D[10] = { 0.0033, 0.0126, -0.0062, -0.0776, -0.0322, 0.2423, 0.1384, -0.7243, 0.6038, -0.1601 };
const double  db5_Lo_R[10] = { 0.1601, 0.6038, 0.7243, 0.1384, -0.2423, -0.0322, 0.0776, -0.0062, -0.0126, 0.0033 };
const double  db5_Hi_R[10] = { 0.0033, 0.0126, -0.0062, -0.0776, -0.0322, 0.2423, 0.1384, -0.7243, 0.6038, -0.1601 };

const double  db6_Lo_D[12] = { -0.0011, 0.0048, 0.0006, -0.0316, 0.0275, 0.0975, -0.1298, -0.2263, 0.3153, 0.7511, 0.4946, 0.1115 };
const double  db6_Hi_D[12] = { -0.1115, 0.4946, -0.7511, 0.3153, 0.2263, -0.1298, -0.0975, 0.0275, 0.0316, 0.0006, -0.0048, -0.0011 };
const double  db6_Lo_R[12] = { 0.1115, 0.4946, 0.7511, 0.3153, -0.2263, -0.1298, 0.0975, 0.0275, -0.0316, 0.0006, 0.0048, -0.0011 };
const double  db6_Hi_R[12] = { -0.0011, -0.0048, 0.0006, 0.0316, 0.0275, -0.0975, -0.1298, 0.2263, 0.3153, -0.7511, 0.4946, -0.1115 };

const double  db7_Lo_D[14] = { 0.0004, -0.0018, 0.0004, 0.0126, -0.0166, -0.0380, 0.0806, 0.0713, -0.2240, -0.1439, 0.4698, 0.7291, 0.3965, 0.0779 };
const double  db7_Hi_D[14] = { -0.0779, 0.3965, -0.7291, 0.4698, 0.1439, -0.2240, -0.0713, 0.0806, 0.0380 - 0.0166, -0.0126, 0.0004, 0.0018, 0.0004 };
const double  db7_Lo_R[14] = { 0.0779, 0.3965, 0.7291, 0.4698, -0.1439, -0.2240, 0.0713, 0.0806, -0.0380, -0.0166, 0.0126, 0.0004, -0.0018, 0.0004 };
const double  db7_Hi_R[14] = { 0.0004, 0.0018, 0.0004, -0.0126, -0.0166, 0.0380, 0.0806, -0.0713, -0.2240, 0.1439, 0.4698, -0.7291, 0.3965, -0.0779 };

const double  db8_Lo_D[16] = { -0.0001, 0.0007, -0.0004, -0.0049, 0.0087, 0.0140, -0.0441, -0.0174, 0.1287, 0.0005, -0.2840, -0.0158, 0.5854, 0.6756, 0.3129, 0.0544 };
const double  db8_Hi_D[16] = { -0.0544, 0.3129, -0.6756, 0.5854, 0.0158, -0.2840, -0.0005, 0.1287, 0.0174, -0.0441, -0.0140, 0.0087, 0.0049, -0.0004, -0.0007, -0.0001 };
const double  db8_Lo_R[16] = { 0.0544, 0.3129, 0.6756, 0.5854, -0.0158, -0.2840, 0.0005, 0.1287, -0.0174, -0.0441, 0.0140, 0.0087, -0.0049, -0.0004, 0.0007, -0.0001 };
const double  db8_Hi_R[16] = { -0.0001, -0.0007, -0.0004, 0.0049, 0.0087, -0.0140, -0.0441, 0.0174, 0.1287, -0.0005, -0.2840, 0.0158, 0.5854, -0.6756, 0.3129, -0.0544 };

const double  db9_Lo_D[18] = { 0.0000, -0.0003, 0.0002, 0.0018, -0.0043, -0.0047, 0.0224, 0.0003, -0.0676, 0.0307, 0.1485, -0.0968, -0.2933, 0.1332, 0.6573, 0.6048, 0.2438, 0.0381 };
const double  db9_Hi_D[18] = { -0.0381, 0.2438, -0.6048, 0.6573, -0.1332, -0.2933, 0.0968, 0.1485, -0.0307, -0.0676, -0.0003, 0.0224, 0.0047, -0.0043, -0.0018, 0.0002, 0.0003, 0.0000 };
const double  db9_Lo_R[18] = { 0.0381, 0.2438, 0.6048, 0.6573, 0.1332, -0.2933, -0.0968, 0.1485, 0.0307, -0.0676, 0.0003, 0.0224, -0.0047, -0.0043, 0.0018, 0.0002, -0.0003, 0.0000 };
const double  db9_Hi_R[18] = { 0.0000, 0.0003, 0.0002, -0.0018, -0.0043, 0.0047, 0.0224, -0.0003, -0.0676, -0.0307, 0.1485, 0.0968, -0.2933, -0.1332, 0.6573, -0.6048, 0.2438, -0.0381 };

const double  db10_Lo_D[20] = { -0.0000, 0.0001, -0.0001, -0.0007, 0.0020, 0.0014, -0.0107, 0.0036, 0.0332, -0.0295, -0.0714, 0.0931, 0.1274, -0.1959, -0.2498, 0.2812, 0.6885, 0.5272, 0.1882, 0.0267 };
const double  db10_Hi_D[20] = { -0.0267, 0.1882, -0.5272, 0.6885, -0.2812, -0.2498, 0.1959, 0.1274, -0.0931, -0.0714, 0.0295, 0.0332, -0.0036, -0.0107, -0.0014, 0.0020, 0.0007, -0.0001, -0.0001, -0.0000 };
const double  db10_Lo_R[20] = { 0.0267, 0.1882, 0.5272, 0.6885, 0.2812, -0.2498, -0.1959, 0.1274, 0.0931, -0.0714, -0.0295, 0.0332, 0.0036, -0.0107, 0.0014, 0.0020, -0.0007, -0.0001, 0.0001, -0.0000 };
const double  db10_Hi_R[20] = { -0.0000, -0.0001, -0.0001, 0.0007, 0.0020, -0.0014, -0.0107, -0.0036, 0.0332, 0.0295, -0.0714, -0.0931, 0.1274, 0.1959, -0.2498, -0.2812, 0.6885, -0.5272, 0.1882, -0.0267 };





#endif

使用new

void TestFunc_pointer(unsigned int height, unsigned int width)  
{  
    unsigned int i, j;  
  
    //  数组的元素类型为‘int *’，可赋值给指向‘int *’的指针.  
    int **array2D = new int *[height];  
    for(i=0; i<height; ++i)  
    {  
        array2D[i] = new int[width];  
    }  
  
    // 访问.  
    for(i=0; i<height; ++i)  
    {  
        for(j=0; j<width; ++j)  
        {  
            // 内存非连续，注意防止越界.  
            array2D[i][j] = i * width + j;  
        }  
    }  
  
    // 首先回收低一级的动态数组.  
    for(i=0; i<height; ++i)  
    {  
        delete[] array2D[i];  
    }  
    // 然后回收高一级的动态数组.  
    delete[] array2D;  
}

 

波雅_汉库克
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++中动态申请二维数组
小村长技术blog
08-26 2036
这里主要介绍C++中动态申请二维数组的两种方式，直接给出代码，很容易明白，简单的作为一个笔记。 #include #include // 输入输出操纵 #include using namespace std; // 法一：new 方式申请 void dynamicArray() { int rows, cols; cin >> rows >> cols; i
C++中动态申请二维数组并释放方法
热门推荐
牟尼的专栏
11-17 5万+
C/C++中动态开辟一维、二维数组是非常常用的，以前没记住，做题时怎么也想不起来，现在好好整理一下。  C++中有三种方法来动态申请多维数组   (1)C中的malloc/free   (2)C++中的new/delete    (3)STL容器中的vector  下面逐一介绍： 第一种：malloc/free 1.动态开辟一维数组 //动态开辟一维数组 void dynamicC
C/C++中动态申请二维数组
SZU_黄其才
10-10 4687
C/C++中动态申请二维数组 C语言动态申请二维数组 在C语言中，数组的大小必须在编译期就作为一个常数确定下来。如果提前不知道数组的大小，那必须使用malloc函数来进行动态申请。 使用malloc/free函数来动态申请二维数组 示例代码如下： #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int width = 3; int height = 3;
在C++中二维数组初始化的几种不同方法
最新发布
book_dw5189的博客
05-01 1395
C++中的二维数组是一种多维数组，通常是一个由多个数组组成的数组，每个数组本身又是一个一维数组。
C++ 动态创建二维数组
菜鸟学编程
11-02 1万+
背景知识： 对二维数组的理解方式至关重要：把二维数组看成是一种特殊的一维数组，它的元素又是一个一维数组。 例如：int a[3][4], 可以理解为定义了3个一维数组，即相当于 a[0], a[1], a[2], 而它们的每个元素又是一个包含4个元素的一维数组，即： a[0]: a[0][0], a[0][1], a[0][2], a[0][3] a[1]: a[1][0], a[1][...
c++用动态创建二维数组的几种方法
AJIOY的专栏
08-21 2338
我们在这篇文章中将会为大家总结几种C++二维数组new的常用方法，并对此进行详细的点评，让大家充分了解其中的优缺点。 AD： C++编程语言中有一种叫做new的二维数组，它的应用方式比较灵活，可以有多种方法来帮助我们实现一些特定功能。在这里我们将会总结几种C++二维数组new的应用方式，来进行逐一的点评。 C++二维数组new应用方式一： A (*ga
C++动态申请二维数组
王甲评的博客
09-21 698
转自http://blog.csdn.net/u012027907/article/details/16370625 C++中有三种方法来动态申请多维数组   (1)C中的malloc/free   (2)C++中的new/delete    (3)STL容器中的vector  下面逐一介绍： 第一种：malloc/free 1.动态开辟一维数组 [cpp] vie
C++创建动态二维数组的两种方法
bingboygogo的博客
05-06 1587
今天给大家分享一下C++里创建动态数组的两种方法，第一种是用new来申请空间，第二种用vector(向量)模板来创建。下面分别给大家讲解一下思路。 MUSIC！ 1、使用new来申请内存 我们用new申请内存来创建一个二维数组的思路是先用一个二级指针指向指针数组，之后使指针数组的每个元素指向分配的空间。 int *p = new int[size]; p[i] =
C++动态申请二维数组方法与应用
09-05
这是我初学C++是遇到的问题－－就是如何动态地申请二维数组？ 现在把我的经验分享给大家！ 里面包含三个源代码： 一个是动态申请一维数组，一个是动态申请二维数组，另一个是动态申请二维数组的应用－－...
C++动态二维数组的申请、赋值、使用、释放以及作参数示例
03-14
C++动态二维数组的申请、赋值、使用、释放以及作参数示例
c++创建二维动态数组与内存释放问题
01-21
如下： #include #include using namespace std; int main() ... // 申请 double** array = new double*[sizeX]; for (int i = 0; i < sizeX; i++) { array[i] = new double[sizeY]; } for
动态申请二维数组
02-13
动态申请二维数组
最新C++二维动态数组的申请与-释放汇总.pdf
11-23
动态创建二维数组时，首先需要为这些指针分配内存，然后逐行申请所需的内存空间。 以下是一个创建和释放二维动态数组的示例： ```cpp #include int main() { int x = 3; // 行数 int y = 4; // 列数 int **p;...
C++ 中动态二维数组的申请
时有限
08-29 595
动态二维数组的申请，主要是nei
动态二维数组类（C++ Vector)
weixin_54186646的博客
03-12 1万+
C++、vector、类实现二维动态数组，运算符重载，矩阵相加、矩阵相乘
【C++学习】创建二维动态数组
m0_74183164的博客
05-12 2292
使用指针的指针可以很方便地创建动态的二维数组，其关键在于使用两层指针进行分配。以下是一个动态创建n行m。
C++中创建二维数组的几种方法
u011555996的博客
09-24 3572
c++
C++ 动态申请二位数组
u011269801的专栏
07-22 577
方法一： int _tmain(int argc, _TCHAR* argv[]) { int row,column; cin>>row>>column; //方法一 //申请空间 int ** a = new int *[row]; for(int i = 0;i a[i] = new int[column]; //使用空间 for(int j = 0;j
【C\C++动态创建二维数组的方法】
weixin_43845530的博客
08-05 793
数组指针和指针数组的方式分别动态申请二维数组。
c++ 动态申请二维数组
12-11
动态申请二维数组是在C++中非常常见的操作，可以使用指针和new运算符来实现。以下是一个简单的例子： ```c++ int row = 3, col = 4; int **arr = new int*[row]; // 动态申请一维指针数组 for(int i = 0; i ; i++){...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

波雅_汉库克

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值