定义：

int *pia = new int[10]; //array of 10 uninitialized ints

此 new 表达式分配了一个含有 10 个 int 型元素的数组，并返回指向该数组第一个元素的指针，此返回值初始化了指针 pia。

在自由存储区中创建的数组对象是没有名字的，只能通过其地址间接地访问堆中的对象。

注意：C++使用new和delete在堆(自由存储区)上分配和释放动态数组。

动态数组初始化：

1. 元素只能初始化为元素类型的默认值，而不能像数组变量一样，用初始化列表为数组元素提供各不相同的初值。

2. 对于内置数据类型元素的数组，必须使用()来显示指定程序执行初始化操作，否则程序不执行初始化操作：

int *pia = new int[10]; //每个元素都没有初始化

int *pia2 = new int[10] (); //每个元素初始化为0

3.类类型元素的数组，则无论是否使用()，都会自动调用其默认构造函数来初始化：

string *psa = new string[10]; //每个元素调用默认构造函数初始化

string *psa = new string[10](); //每个元素调用默认构造函数初始化

动态分配空数组：

char *cp = new char[0];

之后，可以动态改变cp的维数。

动态释放：

delete [] pia;

典型使用示例：

const char *pc = "a very long literal string"; //处理C风格字符串时使用const指针

const size_t len = strlen(pc) +1; //size_t用于数组的大小和下标

for (size_t ix = 0; ix != 1000000; ++ix) {char *pc2 = new char[len]; //pc2指向的存储空间的内容会动态改变，因此不使用const

strncpy (pc2, pc, len);//使用strncpy比使用strcpy安全//do something;

delete[] pc2;

}

一、数组定义和初始化

1: 一维数组初始化：2: 标准方式一： int value[100]; //value[i]的值不定，没有初始化

3: 标准方式二： int value[100] = {1,2}; //value[0]和value[1]的值分别为1和2，而没有定义的value[i>1]

4: //则初始化为0

5: 指针方式： int* value = new int[n]; //未初始化

6: delete []value; //一定不能忘了删除数组空间

7:8: 二维数组初始化：9: 标准方式一： int value[9][9]; //value[i][j]的值不定，没有初始化

10: 标准方式二： int value[9][9] = {{1,1},{2}}； //value[0][0,1]和value[1][0]的值初始化，其他初始化为0

11: 指针方式一： int (*value)[n] = new int[m][n];12: delete []value; //n必须为常量，调用直观。未初始化

13: 指针方式二： int** value = new int*[m];14: for(i) value[i] = new int[n];15: for(i) delete[]value[i];16: delete []value; //多次析构，存储麻烦，未初始化

17: 指针方式三： int * value = new int[3][4]; //数组的存储是按行存储的

18: delete []value; //一定要进行内存释放，否则会造成内存泄露

19:20: 多维数组初始化：21: 指针方式： int * value = new int[m][3][4]; //只有第一维可以是变量，其他几维必须都是常量，否则会报错

22: delete []value; //一定要进行内存释放，否则会造成内存泄露

数组初始化的大括号后面要加“;”来表示结束。

数组访问：

指针形式：如二维数组value[i][j]的访问：

*(value[i] + j) 或

(*(value + i))[j]

二、数组作为参数传递

1: 一维数组参数传递：2: void Func(int *value);3: 或者是4: void Func(intvalue[]);5:6: 二维数组传递：7: 定义是 int **value;的传递8: void Func(int **value);9: 定义是 int (*value)[n] = new int[m][n];的传递10: void func(int (*value)[n]); //sizeof(p)=4,sizeof(*value)=sizeof(int)*n;

三、数组与指针关系

1、数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组；

2、数组名的外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量；

3、指向数组的指针则是另外一种变量类型，(在win32平台下，长度为4)，仅仅意味着数组存放地址。

4、数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针，而且在其失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

四、数组的存储格式

多维数组在内存中存储时是按照最低维连续的格式存储的，如二维数组{{1,2}，{3,4}}在内存中的位置是这样顺序的“1,3,2,4”，这跟matlab是有区别的，matlab是按列进行存储的。在使用指针进行索引时很有用。

五、字符数组

char类型的数组被称作字符数组，通常用来存储字符串。字符串是附加有特殊字符(串尾标志)的字符序列。串终止字符表明字符串已经结束，该字符由转义序列‘\0’定义，有时被称为空字符，占用一个字节，其中8位全为0。这种形式的字符串通常被称为C型字符串，因为以这样的方式定义字符串是在C语言中推出的，在C++一般使用string，而MFC中则定义了CString类。

字符串中每个字符占用一个字节，算上最后的空字符，字符串需要的字节数要比包含的字节数多一个。如：

char movie_star[15] = “Marilyn Monroe”;

这里字符串是14个字符，但是要定义15个字符串的数组。也可以不指定字符数组的个数。如：

char movie_star[] = “Marilyn Monroe”;

六、内存泄露

我们定义了一个指针，然后给它赋予了一个地址值，然后又不再使用，但是没有delete，那么当给指针赋予其他的地址值时，原来的内存将无法释放，这就叫做内存泄露。

1、定义的时候直接用字符串赋值

char a[10]="hello";

注意：不能先定义再给它赋值，如char a[10]; a[10]="hello";这样是错误的！

2、对数组中字符逐个赋值

char a[10]={'h','e','l','l','o'};

3、利用strcpy

char a[10]; strcpy(a, "hello");

易错情况：

1、char a[10]; a[10]="hello";//一个字符怎么能容纳一个字符串？况且a[10]也是不存在的！

2、char a[10]; a="hello";//这样的情况easy出现，a尽管是指针，可是它已经指向在堆栈中分配的10个字符空间，如今这个情况a又指向数据区中的hello常量，这里的指针a出现混乱，不同意！

还有：不能使用关系运算符“＝＝”来比較两个字符串，仅仅能用strcmp() 函数来处理。

C语言的运算符根本无法操作字符串。在C语言中把字符串当作数组来处理，因此，对字符串的限制方式和对数组的一样，特别是，它们都不能用C语言的运算符进行复制和比較操作。

直接尝试对字符串进行复制或比較操作会失败。比如，假定str1和str2有例如以下声明：

char str1[10], str2[10];

利用=运算符来把字符串拷贝到字符数组中是不可能的：

str1 = "abc"; /*** WRONG ***/

str2 = str1; /*** WRONG ***/

C语言把这些语句解释为一个指针与还有一个指针之间的(非法的)赋值运算。可是，使用=初始化字符数组是合法的：

char str1[10] = "abc";

这是由于在声明中，=不是赋值运算符。

试图使用关系运算符或判等运算符来比較字符串是合法的，但不会产生预期的结果：

if (str1==str2) ... /*** WRONG ***/

这条语句把str1和str2作为指针来进行比較，而不是比較两个数组的内容。由于str1和str2有不同的地址，所以表达式str1 == str2的值一定为0。

动态数组的定义使用：

数组究竟应该有多大才合适，有时可能不得而知。所以希望可以在执行时具有改变数组大小的能力。

动态数组就行在不论什么时候改变大小。

通俗的说静态数组就是在定义数组的时候，由操作系统分配的空间，比方

int a[10];

这就是在定义时由系统给你分配了10个int类型的空间，这个空间是能够初始化的，比方

int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}；

那么在这个定义之后，系统会首先分配10个int类型的存储空间，然后把大括号中面的数字分别的，按顺序放到这10个空间里。你所做的仅仅是写这么一句，而数组赋值的操作就由系统完毕了。当然，初始化与否看你的需求，初始化不是强制性操作，想初始化就初始化，不想也没问题，还是上面的样例继续：

int a[10];

这里定义了，可是没初始化，这没有不论什么问题，以后你能够自己往里面赋值，比方

a[1] = 8;

a[5] = 3;

或者

for(int i = 0; i < 10; i++)

a[i] = i;

等等

对于动态数组，不能被初始化，由于动态数组在定义时仅仅是个指针，比方

int *a;

这里变量a仅仅是个指向int类型的指针，而不是数组。动态分配有10个int类型元素的数组，例如以下：

a = (int * ) malloc(10*sizeof(int));

非常明显，指针a在定义的时候不能被初始化，比方这样写就是错误的：

int a = {1,2,3,4,5,6,7,8,9,10}; / 错误！ */

由于a是仅仅有4个字节的指针，没有可用的存储空间给须要初始化的变量。

在C语言编程中，当我们声明一个字符串数组的时候，常常需要把它初始化为空串。总结起来有以下三种方式：

(1) char str[10]="";

(2) char str[10]={'\0'};

(3) char str[10]; str[0]='\0';

第(1)(2)种方式是将str数组的所有元素都初始化为'\0'，而第(3)种方式是只将str数组的第一个元素初始化为'\0'。如果数组的size非常大，那么前两种方式将会造成很大的开销。

所以，除非必要(即我们需要将str数组的所有元素都初始化为0的情况)，我们都应该选用第(3)种方式来初始化字符串数组。

1. 基本问题

数组可以初始化，即在定义时，使它包含程序马上能使用的值。

例如，下面的代码定义了一个全局数组，并用一组Fibonacci数初始化：

1 int iArray[10]={1，1，2，3，5，8，13，21，34，55)； //初始化

2 void main()

3 　{

4 　　　　//...

5 　}

初始化数组的值的个数不能多于数组元素个数，初始化数组的值也不能通过跳过逗号的方式来省略，这在C中是允许的，但在C++中不允许。

初始化值的个数可少于数组元素个数。当初始化值的个数少于数组元素个数时，前面的按序初始化相应值， 后面的初始化为0(全局或静态数组)或为不确定值(局部数组)。

2．初始化字符数组

初始化字符数组有两种方法，一种是：

char array[10]={"hello"}；

另一种是：

char array[10]={'h','e','l','l','\0'}；

第一种方法用途较广，初始化时，系统自动在数组没有填值的位置用，'\0'补上。另外， 这种方法中的花括号可以省略，即能表示成：

char array[10]="hello"；

第二种方法一次一个元素地初始化数组，如同初始化整型数组。这种方法通常用于输入不容易在键盘上生成的那些不可见字符。

例如，下面的代码中初始化值为若干制表符：

char chArray[5]={'\t','\t','\t','\t','\0')；

这里不要忘记为最后的，'\0'分配空间。如果要初始化一个字符串"hello"，那为它定义的数组至少有6个数组元素。

例如，下面的代码给数组初始化，但会引起不可预料的错误：

char array[5]="hello"；

该代码不会引起编译错误，但由于改写了数组空间以外的内存单元，所以是危险的。

3．省略数组大小

有初始化的数组定义可以省略方括号中的数组大小。

例如，下面的代码中数组定义为5个元素：

int a[]={2，4，6，8，10}；

编译时必须知道数组的大小。通常，声明数组时方括号内的数字决定了数组的大小。有初始化的数组定义又省略方括号中的数组大小时，编译器统计花括号之间的元素个数，以求出数组的大小。

例如，下面的代码产生相同的结果：

static int a1[5]={1，2，3，4，5};

static int a2[]={1，2，3，4，5}；

让编译器得出初始化数组的大小有几个好处。它常常用于初始化一个元素个数在初始化中确定的数组，提供程序员修改元素个数的机会。

在没有规定数组大小的情况下，怎么知道数组的大小呢? sizeof操作解决了该问题。

1、字符数组的定义与初始化

字符数组的初始化，最容易理解的方式就是逐个字符赋给数组中各元素。

char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'};

即把10个字符分别赋给str[0]到str[9]10个元素

如果花括号中提供的字符个数大于数组长度，则按语法错误处理；若小于数组长度，则只将这些字符数组中前面那些元素，其余的元素自动定为空字符(即'\0' )。

2、字符数组与字符串

在c 语言中，将字符串作为字符数组来处理。(c++中不是)在实际应用中人们关心的是有效字符串的长度而不是字符数组的长度，例如，定义一个字符数组长度为100，而实际有效字符只有40个，为了测定字符串的实际长度，C 语言规定了一个“字符串结束标志”，以字符'\0’代表。如果有一个字符串，其中第10个字符为'\0'，则此字符串的有效字符为9个。也就是说，在遇到第一个字符'\0'时，表示字符串结束，由它前面的字符组成字符串。

系统对字符串常量也自动加一个'\0'作为结束符。例如"C Program”共有9个字符，但在内存中占10个字节，最后一个字节'\0'是系统自动加上的。(通过sizeof()函数可验证)

有了结束标志'\0'后，字符数组的长度就显得不那么重要了，在程序中往往依靠检测'\0'的位置来判定字符串是否结束，而不是根据数组的长度来决定字符串长度。当然，在定义字符数组时应估计实际字符串长度，保证数组长度始终大于字符串实际长度。(在实际字符串定义中，常常并不指定数组长度，如char str[ ])说明：'\0代表ASCII 码为0的字符，从ASCII 码表中可以查到ASCII 码为0的字符不是一个可以显示的字符，而是一个“空操作符”，即它什么也不干。用它来作为字符串结束标志不会产生附加的操作或增加有效字符，只起一个供辨别的标志。

对C 语言处理字符串的方法由以上的了解后，再对字符数组初始化的方法补充一种方法——即可以用字符串常量来初始化字符数组：

char str[ ]={"I am happy"};

可以省略花括号，如下所示

char str[ ]="I am happy";

注意：上述这种字符数组的整体赋值只能在字符数组初始化时使用，不能用于字符数组的赋值，字符数组的赋值只能对其元素一一赋值，下面的赋值方法是错误的

char str[ ];

str="I am happy";//错误，字符数组的赋值只能按元素一一赋值

不是用单个字符作为初值，而是用一个字符串(注意：字符串的两端是用双引号“”而不是单引号‘’括起来的)作为初值。显然，这种方法更直观方便。(注意：数组str 的长度不是10，而是11，这点请务必记住，因为字符串常量"I am happy"的最后由系统自动加上一个'\0')

因此，上面的初始化与下面的初始化等价

char str[ ]={'I',' ','a','m',' ','h','a','p','p','y','\0'};

而不与下面的等价

char str[ ]={'I',' ','a','m',' ','h','a','p','p','y'};

前者的长度是11，后者的长度是10.

说明：字符数组并不要求它的最后一个字符为'\0'，甚至可以不包含'\0'，向下面这样写是完全合法的。

char str[5]={'C','h','i','n','a'};

可见，用两种不同方法初始化字符数组后得到的数组长度是不同的。

include

void main(void)

{

char c1[]={'I',' ','a','m',' ','h','a','p','p','y'};

char c2[]="I am happy";

int i1=sizeof(c1);

int i2=sizeof(c2);

printf("%d\n",i1);

printf("%d\n",i2);

}

结果：10 11

3、字符串的表示形式

在C 语言中，可以用两种方法表示和存放字符串：

(1)用字符数组存放一个字符串

char str[ ]="I love China";

(2)用字符指针指向一个字符串

char* str="I love China";

对于第二种表示方法，有人认为str 是一个字符串变量，以为定义时把字符串常量"I love China"直接赋给该字符串变量，这是不对的。C 语言对字符串常量是按字符数组处理的，在内存中开辟了一个字符数组用来存放字符串常量，程序在定义字符串指针变量str 时只是把字符串首地址(即存放字符串的字符数组的首地址)赋给str。

两种表示方式的字符串输出都用

printf("%s\n",str);

%s 表示输出一个字符串，给出字符指针变量名str(对于第一种表示方法，字符数组名即是字符数组的首地址，与第二种中的指针意义是一致的)，则系统先输出它所指向的一个字符数据，然后自动使str 自动加1，使之指向下一个字符，如此，直到遇到字符串结束标识符" \0 "。

4、对使用字符指针变量和字符数组两种方法表示字符串的讨论

虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但它们二者之间是有区别的，不应混为一谈。

4.1、字符数组由若干个元素组成，每个元素放一个字符；而字符指针变量中存放的是地址(字符串/字符数组的首地址)，绝不是将字符串放到字符指针变量中(是字符串首地址)

4.2、赋值方式：

对字符数组只能对各个元素赋值，不能用以下方法对字符数组赋值

char str[14];

str="I love China"; //错误，不是初始化，这是赋值，只能一一进行。

(但在字符数组初始化时可以，即char str[14]="I love China";)

而对字符指针变量，采用下面方法赋值：

char* a;

a="I love China";//指针赋值，可以

或者是char* a="I love China"; 都可以

4.3、对字符指针变量赋初值(初始化)：

char* a="I love China";

等价于：

char* a;

a="I love China";

而对于字符数组的初始化

char str[14]="I love China";

不能等价于：

char str[14];

str="I love China"; (这种不是初始化，而是赋值，而对数组这样赋值是不对的)

4.4、如果定义了一个字符数组，那么它有确定的内存地址,不能进行多次赋值；而定义一个字符指针变量时，它并未指向某个确定的字符数据，并且可以多次赋值。

5、字符串处理函数

5.1 字符串连接

char *strcat(char *str1,const char *2 );

char *strcat(char *strDestination,const char *strSource );

功能：函数将字符串str2 连接到str1的末端，并返回指针str1

注：连接前两个字符串的后面都有一个' \0 '，连接时将字符串1后面的' \0 ‘去掉，只在新串最后保留一个' \0 ‘

5.2 字符串复制

char *strcpy(char *str1,const char *2 );

char *strcpy(char *strDestination,const char *strSource );

功能：复制字符串strSource 中的字符到字符串strDestination，包括空值结束符。返回值为指针strDestination。

注：

1、“字符数组1”必须写成数组名形式，“字符串2"可以是字符数组名，也可以是一个字符串常量

2、复制时连同字符串后面的' \0 ' 一起复制到数组1中

3、不能用赋值语句直接将一个字符串常量或者字符数组直接赋给一个字符数组(同普通变量数组是一样的)，而只能用strcpy 函数处理。

4、可以用strcpy 函数将字符串2中的前若干个字符复制到字符数组1中去。

最近看一段代码有所迷惑，先简单总结一下。有关结构体数组初始化的问题

struct  _m_usmart_nametab usmart_nametab[]=

{

#if USMART_USE_WRFUNS==1 //如果使能了读写操作

(void*)read_addr,"u32 read_addr(u32 addr)",

(void*)write_addr,"void write_addr(u32 addr,u32 val)",

#endif

(void*)delay_ms,"void delay_ms(u16 nms)",

(void*)delay_us,"void delay_us(u32 nus)",

(void*)LCD_Clear,"void LCD_Clear(u16 Color)",

(void*)LCD_Fill,"void LCD_Fill(u16 xsta,u16 ysta,u16 xend,u16 yend,u16 color)",

(void*)LCD_DrawLine,"void LCD_DrawLine(u16 x1, u16 y1, u16 x2, u16 y2)",

(void*)LCD_DrawRectangle,"void LCD_DrawRectangle(u16 x1, u16 y1, u16 x2, u16 y2)",

(void*)Draw_Circle,"void Draw_Circle(u16 x0,u16 y0,u8 r)",

(void*)LCD_ShowNum,"void LCD_ShowNum(u16 x,u16 y,u32 num,u8 len,u8 size)",

(void*)LCD_ShowString,"void LCD_ShowString(u16 x,u16 y,u16 width,u16 height,u8 size,u8 *p)",

(void*)LCD_ReadPoint,"u16 LCD_ReadPoint(u16 x,u16 y)",

(void*)fsmc_sram_test_write,"void fsmc_sram_test_write(u8 data,u32 addr)",

(void*)fsmc_sram_test_read,"u8 fsmc_sram_test_read(u32 addr)",

(void*)mymalloc,"void *mymalloc(u8 memx,u32 size)",

(void*)myfree,"void myfree(u8 memx,void *ptr)",

(void*)mf_mount,"u8 mf_mount(u8 drv)",

(void*)mf_open,"u8 mf_open(u8*path,u8 mode)",

(void*)mf_close,"u8 mf_close(void)",

(void*)mf_read,"u8 mf_read(u16 len)",

(void*)mf_write,"u8 mf_write(u8*dat,u16 len)",

(void*)mf_opendir,"u8 mf_opendir(u8* path)",

(void*)mf_readdir,"u8 mf_readdir(void)",

(void*)mf_scan_files,"u8 mf_scan_files(u8 * path)",

(void*)mf_showfree,"u32 mf_showfree(u8 *drv)",

(void*)mf_lseek,"u8 mf_lseek(u32 offset)",

(void*)mf_tell,"u32 mf_tell(void)",

(void*)mf_size,"u32 mf_size(void)",

(void*)mf_mkdir,"u8 mf_mkdir(u8*pname)",

(void*)mf_fmkfs,"u8 mf_fmkfs(u8 drv,u8 mode,u16 au)",

(void*)mf_unlink,"u8 mf_unlink(u8 *pname)",

(void*)mf_rename,"u8 mf_rename(u8 *oldname,u8* newname)",

(void*)mf_gets,"void mf_gets(u16 size)",

(void*)mf_putc,"u8 mf_putc(u8 c)",

(void*)mf_puts,"u8 mf_puts(u8*c)",

};

_m_usmart_nametab的结构体如下

//函数名列表

struct _m_usmart_nametab

{

void* func; //函数指针

const u8* name; //函数名(查找串)

};

一开始一直不明白，为什么下边的只有两个参数，而上边的确有那么多，难道不是一一对应？

其实上边的是一个table表，就像 u8 table[]={}；

而上边的定义的是一个结构体的数组，其成员很多。但每一个成员应该和结构体类型一致，这只不是定义一个这样结构类型的结构体数组而已。

看下面例子

typedef struct _TEST_T {

int i;

char c[10];

}TEST_T;

TEST_T gst = {1, “12345”};//可以初始化，设置i为1，s为一个字符串.

TEST_T gst = {1};//初始化个数少于实际个数时，只初始化前面的成员。

TEST_Tgst = {.c=“12345”};//有选择的初始化成员。

复合字面量。

gst = (TEST_T){122, "1256"};//这是一个赋值语句，也可以作为初始化。可以出现在程序的任何地方。

当然也可以使用复合字面量来初始化：

gst = (TEST_T){.i=122, .c="123"};

3、结构体数组

可以用多个大括号括起来：

TEST_T gst[10] = {{},{},{},{}}

也可以初始化其中的一个元素：

TEST_T gst[10] = {[2]={}, [3]={}}

也可以使用复合字面量：

TEST_T gst[10] = {[2].i=0, [3].i={}}