float数组初始化 |
您所在的位置：网站首页 › float数组赋值 › float数组初始化 |
float数组初始化
|
1. 数组
1.1. 初始化数组
只储存单个值的变量有时也称为标量变量（scalar variable）。 在声明变量前加上 const，设置成只读。持续只能检索数组值，而不能写入新值。 在初始化数组时，初始化的值少于元素个数时，剩余的元素也会被初始化为 0。 初始化时省略方括号内的数字，编译器会自动通过列表里的项数来确定数组的大小。 index = sizeof 数组 / sizeof 数组[0]sizeof 得出整个数组大小（以字节为单位），sizeof 数组[0] 得出一个元素的大小，除得到数组的元素个数。 1.2. 指定初始化 #include #define MONTHS 12 int main(void) { int days[MONTHS] = {31, 28, [4] = 31, 30, 31, [1] = 29}; int i; for (i = 0; i < MONTHS; i++) printf("%2d %dn", i+1, days[i]); return 0; }
[4] = 31,30,31,
编译器将 4，5，6 初始化了。 同时后面的初始化会覆盖前面的初始化。 days = years; //不允许一个数组直接赋值给另一个数组 days[size] = {5,3,2,8}; //除了初始化，其他时候都不能用花括号赋值C 不检查下标是否正确。 int n = 5; float a[n];a 称为变长数组（variable-length array）。 2. 多维数组 #include #define MONTHS 12 #define YEARS 5 int main(void) { const float rain[YEARS][MONTHS] = { {4.3,1.3,4.3,3.0,2.0,1.2,0.2,0.2,0.4,0.4,3.5,6.6}, {8.5,8.2,1.2,1.6,2.4,0.0,5.2,0.9,0.3,0.9,1.4,7.3}, {9.1,8.5,6.7,4.3,2.1,0.8,0.2,0.2,1.1,2.3,6.1,8.4}, {7.2,9.9,8.4,3.3,1.2,0.8,0.4,0.0,0.6,1.7,4.3,6.2}, {7.6,5.6,3.9,2.8,2.3,0.2,0.0,0.0,0.0,1.3,2.6,5.2} }; int year, month; float subtot, total; printf(" YEAR RAINFALL (inches)n"); for (year = 0, total = 0; year < YEARS; year++) { for (month = 0, subtot = 0; month < MONTHS; month++) subtot += rain[year][month]; printf("%5d %15.1fn", 2010 + year, subtot); total += subtot; } printf("nThe yearly average is %.1f inches.nn", total / YEARS); printf("MONTHLY AVERAGES: nn"); printf(" Jan Feb Mar apr may jun jul aug sep oct "); printf("nov decn"); for (month = 0; month < MONTHS; month++) { for (year = 0, subtot = 0; year < YEARS; year++) subtot += rain[year][month]; printf("%4.1f ", subtot / YEARS); } printf("n"); return 0; }
float rain[5][12]；
数组的数组，主数组（master array）有5个元素，而每个元素里面含有12个 float 类型的元素。 程序使用了嵌套 for 循环，一个循环处理数组的第1个下标，另一个循环处理数组的第2个下标。 初始化多维数组时，每个数值列表用花括号括起来，用逗号分割。 上面的内容同样适用于三维数组等更高维的数组。 3. 数组和指针指针把程序员想要传达的指令以更接近机器的方式表达。 指针能够更有效地处理数组。 array == &array[0];数组名是数组首元素的内存地址，两者都是常量。 #include #define SIZE 4 int main(void) { short dates[SIZE]; short * pti; short index; double bills[SIZE]; double * ptf; pti = dates; ptf = bills; printf("%23s %15sn", "short", "double"); for (index = 0; index < SIZE; index++) printf("pointers + %d: %10p %10pn", index, pti + index, ptf + index); return 0; }
每一行是下一行指针加1后的值。 可以看到，short 每加1，指针加2；double每加1，指针加8。short 占用2字节，double占用8字节。 在C中，指针加1指的是增加一个存储单元，这意味着加1后的地址是下一个元素的地址。这就是需要声明指针指向对象的原因之一。 dates + 2 == &dates[2]; //相同的地址 *(dates + 2) == dates[2]; //相同的值*(dates + 2) 可以看作先到内存 dates 的位置，再移动2个单元。 指针表示法和数组表示法完全等效，编译器编译这两种写法生成的代码完全相同。 4. 数组、指针和函数 int sum(int * ar, int n); int sum(int *, int); int sum(int ar[], int n); int sum(int [], int);函数原型可以省略参数名，所以以上4种函数原型都是相等的。 但在函数定义中不能省略参数名。 #include #define SIZE 10 int sum(int ar[], int n); int main(void) { int marbles[SIZE] = {20,10,5,39,4,16,19,26,31,20}; long answer; answer = sum(marbles, SIZE); printf("The total number of marbles is %ld.n", answer); printf("The size of marbles is %zd bytes.n", sizeof marbles); return 0; } int sum(int ar[], int n) { int i; int total = 0; for (i = 0; i < n; i++) total += ar[i]; printf("The size of ar is %zd bytes.n", sizeof ar); return total; }
marbles 是一个数组，而 ar 是一个指向 marbles 数组首元素的指针。 marbles 含有10个int类型的值，每个值4字节，所以marbles 的大小为40字节。 系统中用8字节储存地址，所以指针变量大小为 8 字节。 上面的函数引用和函数定义可以改为： sum(marbles, marbles + SIZE); int sum(int * start, int * end) { int total = 0; while (start < end) { total += *start; start; } return total; }同时传递两个指针，一个指向数组开始处，一个指向数组的结束处。 while(start < end)使用第2个指针来结束循环。 marbles + SIZE这里实际上使用了越界，但是后续表达更加方便简洁。 5. 指针操作 #include int main(void) { int urn[5] = {100,200,300,400,500}; int * ptr1, * ptr2, * ptr3; ptr1 = urn; //把urn的第一个地址赋给ptr1 ptr2 = &urn[2]; printf("pointer value, dereferenced pointer, pointer address:n"); printf("ptr1 = %p, *ptr1 = %d, &ptr1 = %pn", ptr1, *ptr1, &ptr1); //指针加法 ptr3 = ptr1 + 4; printf("nadding an int to a pointer: n"); printf("ptr1 + 4 = %p, *(ptr1 + 4) = %dn", ptr1 + 4, *(ptr1 + 4)); //指针递增 ptr1++; printf("nvalues after ptr1++n"); printf("ptr1 = %p, *ptr1 = %d, &ptr1 = %pn", ptr1, *ptr1, &ptr1); //指针递减 printf("nvalues after --ptr2n"); printf("ptr2 = %p, *ptr2 = %d, &ptr2 = %pn", ptr2, *ptr2, &ptr2); //恢复初始值 --ptr1; //恢复初始值 ++ptr2; printf("nPonters reset to original values:n"); printf("ptr1 = %p, ptr2 = %dn", ptr1, ptr2); //一个指针减另一个指针 printf("nsubtracting one pointer from another:n"); printf("ptr2 = %p, ptr1 = %p, ptr2 - ptr1 = %tdn", ptr2, ptr1, ptr2 - ptr1); //指针减整数 printf("nsubtracting an int from a pointer: n"); printf("ptr3 = %p, ptr3 - 2 = %pn", ptr3, ptr3 - 2); return 0; }
赋值：把地址赋给指针，用数组名、带地址运算符（&）的变量名和另一个指针。地址应该和指针类型兼容。 解引用：* 运算符给出指针指向地址上储存的值。 取址：& 运算符给出指针本身的地址。&ptr1 是指向 ptr1 的指针，而 ptr1 是指向 utn[0] 的指针。 指针与整数相加减：以指针所指向类型的大小为单位。 指针求差：求差的两个指针分别指向同一个数组的不同元素，求出两个元素的距离。 不要解引用未初始化的指针：创建一个指针时，系统只分配了储存指针本身的内存，并没有分配储存数据的内存。先要用一个现有变量的地址初始化该指针。 6. 指针和多维数组 int zippo[4][2]; zippo == &zippo[0];zippo 是内含两个 int 值的数组的地址。 zippo[0] == &zippo[0][0];zippo[0] 是占用一个int 大小对象的地址。 但因为都开始于同一个地址，所以 zippo 和 zippo[0] 的值相同。 *zippo = &zippo[0][0]; **zippo = zippo[0][0];zippo 是地址的地址，即双重间接（double indirection），必须解引用两次才能获得原始值。 #include int main(void) { int zippo[4][2] = { {2,4},{6,8},{1,3},{5,7} }; printf(" zippo = %p, zippo + 1 = %pn",zippo, zippo+1); printf("zippo[0] = %p, zippo[0] + 1 = %pn",zippo[0], zippo[0]+1); printf(" *zippo = %p, *zippo + 1 = %pn",*zippo, *zippo+1); printf("zippo[0][0] = %dn", zippo[0][0]); printf(" *zippo[0] = %dn", *zippo[0]); printf(" **zippo = %dn", **zippo); printf(" zippo[2][1] = %dn", zippo[2][1]); printf("*(*(zippo+2) + 1) = %dn", *(*(zippo+2) + 1)); return 0; }
6.1. 指向多维数组的指针
int (* pz)[2];
pz 声明为指向内含两个int 类型值的数组的指针。 int * pax[2];pax 是一个内含两个指针元素的数组，每个元素都指向int。 #include int main(void) { int zippo[4][2] = { {2,4},{6,8},{1,3},{5,7} }; int (* pz)[2]; pz = zippo; printf(" pz = %p, pz + 1 = %pn",pz, pz+1); printf("pz[0] = %p, pz[0] + 1 = %pn",pz[0], pz[0]+1); printf(" *pz = %p, *pz + 1 = %pn",*pz, *pz+1); printf("pz[0][0] = %dn", pz[0][0]); printf(" *pz[0] = %dn", *pz[0]); printf(" **pz = %dn", **pz); printf(" pz[2][1] = %dn", pz[2][1]); printf("*(*(pz+2) + 1) = %dn", *(*(pz+2) + 1)); return 0; }
|
【本文地址】
今日新闻 |
推荐新闻 |