C++数组的创建及使用(静态数组与动态数组)

C++中使用指针 new申请内存、创建数组、传递 C++中使用指针new申请内存,创建数组,传递 阅读详情
AI摘要

本文详细介绍了C++中的数组,包括静态数组和动态数组的声明、初始化、使用以及内存管理。对于静态数组,重点讨论了一维和二维数组的声明、初始化和访问方式。动态数组则涉及如何使用new运算符在运行时分配和释放内存,以及一维和二维动态数组的访问方法。此外,文章还提到了字符串在C++中的表现形式,以及使用指针操作数组的方法。

C++数组的创建及使用

一、静态数组

静态数组:定义时就已经在栈**上分配了空间大小,在运行时这个大小不能改变

数组(array)是一种数据格式,能够存储多个同类型的值。

一维数组

1、一维数组的声明:

一般声明:typeName arrayName[arraysize];

要创建数组,可使用声明语句。数组的声明应该指出数组的

①存储在每个元素中的值的类型②数组名③数组中的元素数

注意:以上声明语句中的arraysize不能是变量,另外数组大小一旦确定之后就不能修改了!

例如:

short month[12]   //create an array of 12 shorts
2、数组的初始化及使用:

只有在定义数组的时候才能初始化,之后就不能使用了,也不能将一个数组的值赋给另外一个数组,然而可以使用下标分别给数组中的元素赋值。

int array1[4] = {1,2,3,4};  //okay
int array2[4];              //okay
array1[4] = {5,6,7,8};		//not allowed
array2 = array1;			//not allowed

int array3[4] = {2,7};		//okay 只初始化前两个元素,默认其他元素为0
int array4[] = {1,9,9,5};	//okay 编译器计算元素个数
double array5[4] {1.1, 2.2, 5.5, 1.7e4};  //okay in c++11,可省略=
double array6[20] {};       //okay,  所有元素被设为0
double array6[20] = {};     //okay,  同上,所有元素被设为0

long array7[] = {3.1,6,7};  //not allowed 浮点数转成整形是缩窄操作
char array8[5] {'h','i','120','65535','\0'};  //not allowed 因为65535超出了char的范围

其实在C++中,将数组名解释为地址。在多数情况下,C++将数组名解释为数组第一个元素的地址。例如以下程序:

int main()
{
    using namespace std;
    int months[3] = {5,7,12};
    double workhours[3] = {120.7, 110.5, 57};
    
// Here ara two ways to get the address of an array
    int * pm = months;  // name of array = address
    double * pw = &workhours[0];   // or use address operator
// With array elements
    cout << "pm = " << pm << ", *pm = " << *pm << endl;
    pm += 1;
    cout << "add 1 to the pm pointer:" << endl;
    cout << "pm = " << pm << ", *pm = " << *pm << endl << endl;
    
    cout << "pw = " << pw << ", *pw = " << *pw << endl;
    pw = pw + 1;//增加的值等于指向类型占用的字节数
    cout << "add 1 to the pw pointer:" << endl;
    cout << "pw = " << pw << ", *pw = " << *pw << endl << endl;
    
    cout << "access two elements with array notation " << endl;
    cout << "workhours[0] = " << workhours[0] << ", workhours[1] = " << workhours[1] << endl;
    cout << "access two elements with pointer notation " << endl;
    cout << "*workhours = " << *workhours << ", *(workhours+1) = " << *(workhours+1) << endl;
    
    cout << sizeof(months) << " = size of months array" << endl;
    cout << sizeof(pm) << " = size of pm pointer" << endl;
    return 0;
    
}

程序的输出结果为:

pm = 000000CC6FEFF848, *pm = 5
add 1 to the pm pointer:
pm = 000000CC6FEFF84C, *pm = 7

pw = 000000CC6FEFF878, *pw = 120.7
add 1 to the pw pointer:
pw = 000000CC6FEFF880, *pw = 110.5

access two elements with array notation
workhours[0] = 120.7, workhours[1] = 110.5
access two elements with pointer notation
*workhours = 120.7, *(workhours+1) = 110.5
12 = size of months array
8 = size of pm pointer

二维数组:

c++没有提供二维数组类型,但是可以创建每个元素本身都是数组的数组。

1、二维数组的声明

例如:

int array[5][7];

该声明意味着array是一个包含5个元素的数组,其中每个元素都是一个由7个整数组成的数组,如下图所示。
在这里插入图片描述

2、二维数组的初始化及使用

创建二维数组时,可以初始化其所有元素。需要在一维数组的声明之上加上由逗号分隔的用花括号括起来的值列表,如:

int array[4][5] = 
{
    {0,1,2,3,4},
    {1,2,3,4,5},
    {2,3,4,5,6},
    {3,4,5,6,7}
}

对于上述初始化的二维数组也可看做如下结构

在这里插入图片描述

其中array是数组名,a数组包含4行,即4个元素:array[0]、array[1]、array[2]、array[3],每个行元素可以看作含有5个元素的一维数组。也就是说array[0]、array[1]、array[2]、array[3]分别是这4个一维数组的数组名。既然是数组名,上面说到一维数组的数组名表示的就是数组第一个元素的地址,所以array[0]表示的就是元素array[0][0]的地址,即array[0] = &array[0][0],所以在二维数组a中,a[i]]表示的就是元素array[i][0]的地址,即

a[i] == & a[i][0]

在一维数组中,数组名a代表数组的首地址,即第一个元素的地址,而a+1代表数组第二个元素的地址…所以既然array[0]、array[1]…代表二维数组第0行、第1行的首地址,同理array[0] + 1就是元素array[0][1]的地址…所以有:

a[i]+j = &a[i][j]

由上两式得:

&a[i][0] + j = &a[i][j]

又由于a[i]和*(a+1)等价,即

a[i] = *(a+i)

则对于二维数组有:

*(a+i)+j == &a[i][j]

注意上式返回的是地址,与以下有所差别,下式表示的是元素的值

*(a[i]+j)  ==  *(*(a+i)+j)  ==  a[i][j]
3、二维数组的首地址和数组名:

对于一维数组,数组名表示的是数组第一个元素的地址,对于二维数组,其实数组名也代表了首元素的地址。但是对于以上的数组array而言,数组名array代表的不是元素array[0][0]的地址。上面提到过二维数组也是通过一维数组嵌套形成的,即二维数组就是一维数组。二维数组array[4][5]是有4个元素array[0]、array[1]、array[2]、array[3]的一维数组,所以二维数组的首元素应该是array[0],而不是array[0][0]。所以有:

a == &a[0]

而a[0]又是a[0][0]的地址,即:

a[0] == &a[0][0]

所以二维数组a和元素a[0][0]的关系为:

a = &(&(a[0][0]))

即二维数组名a是地址的地址,必须两次取值才可以取出数组中存储的数据,对于二维数组a[m][n],数组名a的类型为int(*)[n],所以如果定义一个指针变量p(int*p),并希望这个指针变量指向二维数组a,那么不能把a赋给p,因为他们的类型不一样。①要么把 a[0] 赋给 p,要么把 *a 赋给 p。因为 a==&(&a[0][0]),所以*a==*(&(&a[0][0]))==&a[0][0]。
②另外还可以把指针变量 p 定义成 int(*)[n] 型,这时就可以把 a 赋给 p,这种方法也经常使用。

把 a[0] 赋给 p或者把 *a 赋给 p的情况
int* p = a[0];
int* p = *a;
int* p = &a[0][0];

对于二维数组a[m][n],如果将&a[0][0]赋给p的话,那么通过指针p访问二维数组元素的公式为:

p + i*n + j == &a[i][j];
把二维数组名直接赋给指针p的情况

如果将二维数组名 a直接赋给指针变量 p,即把指针变量 p 定义成 int(*)[n] 型,则:

p == a

那么此时用p指向元素a[0][0]是以行为单位进行访问,数组名a代表第一个元素a[0]的地址,则a+1就代表a[1]的地址,即a+1==&a[1],则

a+i = &a[i]

于是就有

p+i = &a[i]

对上式两端做"*"运算可得:

*(p+i) == a[i]

进一步(两端同时加上j行)可得:

*(p+i) + j == &a[i][j]

注意:数组指针应区别于指针数组

指针数组实际上是一个数组,数组的每个元素存放的是一个指针类型的元素。例如:

int * arr[7]  //[]的优先级比*高,说明arr是一个数组,而int*是数组里面的内容
			  //也就是arr是一个含有7个int*的数组

其结构形式如下:

在这里插入图片描述

数组指针实际上是一个指针,该指针指向一个数组。例如:

int (*arr)[7]  //由于[]的优先级比*高,因此在写数组指针的时候必须用括号将*arr括起来
    		   //这里arr先和*结合,表明arr是一个指针变量,也就是arr指向一个大小为7个整形的数组

可编程验证如下:两者输出的结果完全一致。

#include <stdio.h>
int main()	
{	
    int a[3][4] = { 11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34 };
	int(*p)[4] = a;  //把二维数组名直接赋给指针p,记住这种定义格式
	for (int i = 0; i < 3; ++i)
	{
		for (int j = 0; j < 4; ++j)
		{
			printf("%-2d\x20", *(*(p + i) + j));  
			//p+i表示a[i]的地址
			//%-2d中, '-'表示左对齐(无'-'默认为右对齐);2表示这个元素输出时占两个空格的空间
		}
		printf("\n");
	}
	printf("\n");

	int*p1 = *a;	 //把a[0]或者*a赋给指针p1
	for (int i = 0; i < 3; ++i)
	{
		for (int j = 0; j < 4; ++j)
		{
			printf("%-2d\x20", *(p1+ i*4 + j));
			//p+i表示a[i]的地址
            
			//%-2d中, '-'表示左对齐(无'-'默认为右对齐);2表示这个元素输出时占两个空格的空间
		}
		printf("\n");
	}
	printf("\n");
	return 0;
}
补充:(字符串)

字符串是存储在内存的连续字节中的一系列字符。之所以放在这里是因为存储在连续字节中的一系列字符意味着可以将字符存储在char数组中

1、C风格字符串(char数组)

char cat[9] = {'m', 'i', 'n', ' ', 'a', 'p', 'p', 'l', 'e'};  //not a string
char cats[10] = {'m', 'i', 'n',' ', 'a', 'p', 'p', 'l', 'e', '\0'}; //a string

这两个数组都是char数组,但是只有第二个数组是字符串,C-风格字符串具有一种特殊的性质,以空字符(null character)结尾,即\0,其ASCII码为0。用来标记字符串的结尾。

以上示例中,将数组初始化为字符串的工作特别冗长,还使用了大量的单引号。为了简化以上数组初始化为字符串,可以用以下方法,用引号括起的字符串隐式地包括结尾的空字符。

char cats[10] = "min apple";   // \0被默认添加
char fish[] = "Bubbles";  	   // 让编译器自动计数

补充:拼接字符串常量,

2、string类型

string str1 = "this is an example!"; //initial string
srting str2;			//create an empty string object;
str2 = str1;			//allowed, object assignment ok
string str3 = str1 + str2; //allowed  ,add string

二、动态数组

动态数组:运行时在堆上分配一定的存储空间,另外在运行时还可以改变其大小。虽然在栈上分配空间效率较高,但是栈空间有限,对于大型数据应使用new和delete在堆区分配空间。另外在很多情况下预编译过程阶段数组的长度是不能预先知道的,必须在程序运行的过程中动态给出。

一维数组

1、使用new创建动态数组

int * parray = new int[10];    // get a block of 10 ints

new运算符返回第一个元素的地址,以上示例中返回的第一个元素的地址被赋给指针parray。当程序使用完new分配的内存块时,需要使用delete来使用它们:

delete [] parray;    		//free a dynamic array

方括号告诉程序,应释放掉整个数组,而不仅仅是指针指向的元素,注意delete只是释放指针指向的存在,但不会删除指针本身,例如可以将parray重新指向另一个新分配的内存块。上述parray是指向一个int(数组的第一个元素)的指针。

2、使用动态数组

创建了动态数组之后,访问数组中的元素的话,对于第一个元素没有问题,因为parray指向数组中的第一个元素,因此*parray是第一个元素的值。这样还有9个元素,可以访问的方式为:只要把指针当作数组名使用即可:例如parray[0]表示第一个元素,parray[1]表示第二个元素…例如以下程序:

int main()
{
	using namespace std;
    double *p = new double[3];    //space for 3 doubles
    p[0] = 1.1;
    p[1] = 5.5;
    p[2] = 7.7;
    cout << "p[1] is " << p[1] << endl;
    p = p + 1; //increment the pointer (ok for the pointer, wrong for the array name.)
    cout << "now p[0] is " << p[0] << " and ";
    cout << "p[1] is " << p[1] << endl;
    p = p - 1;		// point back to begging
    delete [] p;	// free the memory
    return 0;
}

程序的输出结果为:

p[1] is 5.5
now p[0] is 5.5 and p[1] is 7.7

由以上可知,p+1后指针将指向下一个元素的地址,注意在delete之前p-1以便给delete提供正确的地址。

另外注意new和delete一定搭配使用,否则会造成内存泄露;还应注意野指针的问题,例如:

int* p = new int;  //表示在堆区分配了一块int型的空间,但是指针p在栈区
p++;  //原来指向int的指针没有了,但是new int还在,形成了内存泄漏,野指针。

最后要说明一个问题,在静态数组中如下定义是错误的,因为在定义数组时,必须明确给出数组的大小,要不然编译不通过。

int i=5;
int Array[i]; //错误 因为在编译阶段,编译器并不知道 i 的值是多少

就是基于以上,在很多预编译阶段,数组的长度是不能预先知道的,必须在程序运行时动态地给出。所以用new动态定义数组,这样下面的语句是正确的:

int size = 77;
int *p = new int[size];

二维数组

1.使用形如int (*p) [n]指针
type (*p)[N] = new type[][N]

其中type是某种数据类型,N是二维数组的列数。采用这种格式,列数必须指出,而行数无需指定。在这里指针p的类型是type*[N],即是指向一个有N列元素数组的指针。

同样讨论该二维动态数组,对于以下的语句是不能通过编译的:

int row=50,col=50;
int (*p)[col]=new int [row][col];

这是因为,首先new int [row][col]是在动态生成数组时确定的,所以后面的没有问题。但是前面的int (*p)[col],这是一个定义语句,定义语句要先经过编译器进行编译,当编译器编译到此时发现col不是常数,因此不能通过编译。而之所以编译器认为col不是常数,是因为编译阶段,编译器起的作用是查语法错误,和预分配空间,它并不执行程序,因此,没有执行那个赋值语句(只是对这个语句检查错误,和分配空间),因此编译阶段,它将认为col是个变量。所以上面的二维数组定义是错误的, 它不能通过编译。可以修改成:

int row = 50;
int (*p)[50]=new int [row][50]; //这样就可以编译通过了

由以上可得知这种动态分配数组,仅对一维数组空间是真正动态分配的。那么在预编译阶段不知道数组的列数时可以通过一维是真正的动态分配进行,如下所示使用int **p。

2.使用形如int **p二维动态数组指针

例如:

int **p;

注意与以上提到的二维静态数组指针int(*p)[n]的区别。int** a;表示一个内存空间,这个空间用来存放一个指针,这个指针指向一个存放指针的空间,并且指向的这个空间中的指针,指向一个整数; int (*p)[10];表示一个内存空间,这个空间用来存放一个指针,这个指针指向一个长度为10、类型为int的数组;和int** a的区别在于,++、+=1之后的结果不一样,其他用法基本相同。
补充: int (*a)(int);表示一个内存空间,这个空间用来存放一个指针,这个指针指向一个函数,这个函数有一个类型为int的参数,并且函数的返回类型也是int。

int **p的使用如下:

m = 5
n = 7;
int **p = new int*[n];
for(int i = 0; i < a; i++)
{
    p[i] = new int[m];
}

//相应的delete方法为:
for(int i = 0; i< n; i++)
{
    delete [] p[i];  // 要在指针前加[],否则就只释放p[i]所指的第一个单元所占的空间
}
delete [] p;	//最后还要释放掉开辟的指针数组

最后在C++中也封装了vector以及array等类,可以使用这些类来定义数组。

例如:

vector<vector<int> > array;//注意后面> >中间的空格

例如:

#include<vector>
vector<int> a[n];
for(int i = 0;i<n;i++)
    a[i].resize(m);   //m、n为二维数组的行和列数

参考:

《C++ Primer Plus》

http://c.biancheng.net/view/227.html

https://blog.csdn.net/KYJL888/article/details/77846122

https://blog.csdn.net/u014546553/article/details/53644898

https://www.cnblogs.com/aminxu/p/4685962.html

C++数据结构数组类的创建     在C或C++的原生数组里,有一点不好的就是数组越界是察觉不到,代码也不会提醒,至于越界产生的bug什么时候引发系统问题,我们也无从知晓。在这里我们可以创建一个数组类,内部包含数组长度、数组越界访问时能主动发现。     数组类的创建我们还是按照顺序表的思路,创建一个Array类,实现基本的操作,再创建StaticArray与DynamicArray一个静态一个动态数组类,数组存储位置及大... 阅读详情

相关推荐

C++数组:动态数组的创建和使用

我们可以使用静态数组来存储固定数量的元素,也可以使用动态数组来根据需要动态地分配内存。无论是静态数组还是动态数组,我们都可以使用索引来访问数组中的元素,并对其进行操作。在C++中,数组是一种常用的数据结构,它允许我们在单个变量中存储多个相同类型的元素。在上面的示例中,我们创建了一个固定长度的数组。在创建数组后,我们可以通过索引访问数组中的元素,并将值存储到数组中。要访问数组中的元素,我们可以使用数组的索引。接下来,使用循环语句将数组的元素初始化为递增的整数,并将它们打印到控制台。运算符释放动态数组的内存。

m0_47037246的博客 694

c++创建数组的三种方式

#include<iostream> using namespace std; int main() { //c++创建数组的三种方式。 int tab[] = { 1,2,3 }; //方法二 int tab1[10]; //方法三 int tab2[10] = { 1,2,3 }; cout << tab2[2] << endl; cout << tab2[3] << endl; cout << size

dawnButterfly的博客 3万+

【C++】静态数组array、动态数组vector创建及优化

C++给我们提供一个叫做Vector的类,这个Vector在std命名空间中。Vector不是向量的意思,更为准确的说是ArrayList,因为它的本质是一个动态数组。但与我们之前讲的数组类型不同的是,它可以调整数组的大小。意思就是当你创建一个vector时,它是没有固定大小的(当然你也可以初始化一个特定的大小,但一般我们不这样做),我们也不需要care它的大小,只要把元素放进去就行。每次你放入一个元素,数组的大小就会增长。

因为热爱所以坚持 1671

C++数组

数组的特点: 1. 放在一块连续的内存空间中 2. 数组中每个元素都是相同的数据类型 我们可以通过下标访问数组中的元素 一维数组名称的用途: 1. 可以统计整个数组在内存中的长度 2. 可以获取数组在内存中的首地址 数组名是一个常量,不可以进行赋值的操作练习案例:五只小猪称重 案例描述: 在一个数组中记录了五只小猪的体重,如:int array[5] = {300,20,120,320,21}; 找出并打印最重的小猪。 练习案例:数据元素逆置 案例描述: 请声名一个5个元素的数组

m0_58233509的博客 7255

Xilinx VU+系列多DIE FPGA时序约束与跨DIE信号优化策略

本文深入探讨了Xilinx VU+系列多DIE FPGA的时序约束与跨DIE信号优化策略。针对2.5D/3D封装技术带来的时序挑战,详细解析了SLR区域约束、Laguna寄存器配置及跨时钟域约束等关键技术,提供了实用的TCL脚本和RTL优化示例,帮助开发者有效提升设计性能和时序收敛效率。

weixin_29209801的博客 662

BetaFlight代码解析(5)— PID控制器

Betaflight的PID控制器是保持飞行器稳定的核心算法,通过比例、积分、微分三组件实时校正姿态误差。该系统还包含前馈、动态D项限制、反重力等高级功能,通过多PID配置文件实现灵活调参,并提供多种调试模式分析性能。这些优化使控制器在保证稳定性的同时提高响应速度,是飞行调优的关键部分。

rainercool的专栏 1501

C++中new和delete来创建和释放动态数组

在C++编程中,使用new创建数组然后用delete来释放。 一、创建并释放一维数组 #include<iostream> using namespace std; int main() { int n; cin>>n; //分配动态一维数组 int *arr=new int[n]; for(int i=0;i&lt...

CSDN131137的博客 1万+

c语言【分糖果】2023蓝桥杯4124(枚举,递归,dfs)

但是这是不符合我们糖果刚好分完的条件的,我们应该往回退到上一层,也就是孩子6这层,然后j+1=3,孩子7分到3个第二种糖果,这也不符合我们糖果刚好分完的条件,然后就会再次回退到孩子6这里,然后j+1=4,让我们的孩子7获得5块第二种糖果,然后还是不符合糖果刚分完的条件,于是再一次退回到孩子6这里,然后就会有外循环i+1=1,j=1,孩子7分到1块第一种糖果1块第二块糖果......然后就是这样的不停地回溯,试探,直到把整棵树遍历一遍,并且记录所有的满足条件的组合。先放一下我的代码,我的代码超时啦救命!

weixin_74331419的博客 733

动态创建高维数组

数组可以进行静态创建和动态创建,平时最常用的还是动态创建:动态创建一维数组,测试代码如下:int *array1; int n; cin >> n; array1 = new int[n]; for (int i = 0; i  {  array1[i] = i; } for (int j = 0; j  {  cout  }动态创建二维数组,测试代码如下:int **array2

gukesdo的专栏 1674

ZYNQ:【1】深入理解PS端的TTC定时器(Part1:原理+官方案例讲解)

基于UG585详细讲解其中TTC的原理和使用案例。

Alex的技术博客 7893

CTransformers: 高效的Python语言模型绑定库

CTransformers是一个为C/C++实现的Transformer模型提供Python绑定的开源库。它基于GGML库构建,旨在为开发者提供一种高效且易用的方式来在Python中使用各种流行的语言模型。支持多种流行的语言模型,如GPT-2、LLaMA、Falcon等提供统一的简单API接口支持GPU加速(CUDA和Metal)与Hugging Face Transformers和LangChain集成支持流式输出和嵌入计算。

helloaiworld的博客 1270

《C++ Primer Plus》学习笔记——使用new来创建动态数组

使用new来创建动态数组 在C++的使用过程中,我们可以通过创建数组的方式来管理同一类型的数据。声明一个数组的方式就必须知道数组的长度,如果我们并不知道数组的具体长度,我们就需要将数组的长度设置得足够大这必然会造成内存的浪费。因此,我们可以采用指针来创建动态数组。 在编译时给数组分配内存被称为静态联编(static binding),意味着数组实在编译时加入到程序中的。但使用new时,如果在运行阶段需要数组,则创建它;如果不需要,则不创建。还可以在程序运行时选择数组的长度。这被称为动态联编(dynamic

qq_41789960的博客 414

微博scheme

微博scheme

qq_42278595的博客 326

C++ 动态创建二维数组int** B = new int* [n];

#include <iostream> using namespace std; int main() { //动态创建一维数组 int* A = new int[10]; //int A[10]; //动态创建二维数组 int n = 10,m=10; int** B = new int* [n]; //int* B[n]=new int[m]; int B[n][m...

weixin_41733275的博客 2664

【声纳技术】声呐时间反转镜技术:从被动聚焦到主动空间复用

时间反转镜技术以其独特的物理机制,为水声通信与声呐探测提供了一条绕过传统自适应均衡器的新路径。被动时间反转利用接收端的空间分集实现脉冲压缩,结构简洁、计算高效;主动时间反转则通过发射端预编码,将多径能量引导至目标位置,为多用户下行链路的空间复用奠定了物理基础。从Kuperman等人在海洋中首次验证声学时间反转镜,到TR-MIMO声呐的湖试验证,再到VTRM-CRK多用户通信系统的海试成功,该技术已从理论概念逐步走向工程实用。

u012133341的博客 57

innovus:像ICC2一样设置placement label

ICC2有placement label/placement rule功能,能控制各种类型cell 之间的spacing规则,包括top和bottom edge的spacing。innovus也有相同的功能,以下示例方便大家了解用法。我们需要给所有OAI* cell之间设置一个spacing rule,让他们不要上下或者挨着。效果如下图,这个spacing指的是同一边的间距,不是cell间距。我正在「拾陆楼」和朋友们讨论有趣的话题,你⼀起来吧?

m0_61544122的博客 848

C++自学笔记23(动态数组和静态数组)

动态数组、静态数组、原始数组区别差异?如何使用?

weixin_64418869的博客 697

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

ca32a_demo_c++创建动态数组

/* ca32a_demo_c++创建动态数组20200127 静态是在堆栈上创建的,动态实在堆(heap)上创建的 堆(heap)-自由存储区(free store)-内存的一个区域 c语言:malloc创建和free释放 c++语言:new和delete() 动态数组的定义 初始化动态分配的数组 const对象的动态数组 允许动态分配空数组 动态空间的释放 动态数组的使用 */ //静态数...

Txwtech 425

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

动态数组和静态数组的区别

一、创建方法 静态数组: int a[5]; a[5] = {1, 2, 3, 4, 5}; 数组的长度预先设定好且为常量 动态数组: int lenth; int *a = new int[lenth]; delete []a; //释放空间 或者 int *a = (int*)malloc(sizeof(int)); free(a); //释放空间 可以在程序运行过程中输入...

没有西瓜汁 3529

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

[C++] 动态数组及其应用

动态数组存在的意义: ​ 很多情况下,在预编译过程阶段,数组的长度无法预先知道,必须在程序运行时动态给出。但C++要求定义数组时,必须明确给定数组的大小,否则编译无法通过。 动态数组和静态数组的区别 ​ 静态数组[]是在栈上创建,不需要自行释放空间,效率高,但是栈空间有限。 ​ 动态数组new是在堆上创建,堆为自由存储区(free store),需要自行释放空间,效率低。 在c和c++中,动态数组的分配方式略有区别: C:malloc和free C++:new和delete new在内部做

mouliu6141的博客 967

关于[]静态数组和new分配的动态数组的区别

(1) 对静态数组名进行sizeof运算时,结果是整个数组占用空间的大小; 因此可以用sizeof(数组名)/sizeof(*数组名)来获取数组的长度。 int a[5];则sizeof(a)=20,sizeof(*a)=4.因为整个数组共占20字节,首个元素(int型)占4字节。 int *a=newint[4];则sizeof(a)=sizeof(*a)=4,因为地址位数为4字节,in

wliu0828的专栏 470

创建动态数组

常见动态数组的方法包含c++和python

m0_64372178的博客 1027

C++中关于[]静态数组和new分配的动态数组的区别分析

一、静态数据及动态数组的创建 静态数据: int a[10]; int a[]={1,2,3}; 数组的长度必须为常量。 动态数组: int len; int *a=new int [len]; delete a; ...

u011555996的博客 315

指针与动态数组

不要把指向月亮的手指头当成是月亮. ___禅语 指针是变量的内存地址. 指针可存储到变量中,虽然指针是地址,地址是数字,但也不能将它存储到int或double类型的变量中.容纳指针的变量必须声明为指针类型. 操作符 作用 提领操作符* 指针变量前的操作符*生成它所指向的变量. 取址操作符& 普通变量前的操作符&生成那个变量...

2020 3737

C++语言的动态数组

在 C++ 编程中,数组是一种基础的数据结构,用于存储相同类型的数据集合。虽然静态数组在程序设计中非常方便,但其固有限制性让它在处理动态数据时显得力不从心。因此,了解如何在 C++ 中使用动态数组不仅能帮助我们更好地管理内存,还能提升程序的灵活性和效率。动态数组是指在程序运行时根据需要分配的数组,其大小可以根据实际需求进行调整,这使得它在处理不确定长度的数据集时显得尤为重要。本文将详细探讨 C++ 中动态数组的相关概念、实现方法以及使用场景,并提供一些示例代码来帮助读者更好地理解这一主题。

2501_91310406的博客 1135

C++通过输入数来确定一个数组的动态大小

这个和编译器有关 一维: cin>>n;int* a=new int[n]; 但是new出来的一定不要忘了delete掉 delete []a; // 正确的用法 delete a; // 错误的用法后者相当于delete a[0],漏掉了另外n-1个对象。 二维: 设有m行n列 cin>>m>>n; int a = new int [m]; for(int i...

zhpfeng10的博客 3784
上一篇: Hough变换检测直线的原理
下一篇: 高斯滤波及其原理
声希Censh
博客等级 码龄8年 39粉丝 27原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址