目錄

複習題

a.

b.

a.

b.

8.

程式設計練習

複習題

1.下面的程式將列印什麼內容

#include　<stdio.h> 
int　main(void)
{ 
    int　ref[]　=　{　8,　4,　0,　2　}; 
    int *ptr; 
    int　index; 
    for　(index　=　0,　ptr　=　ref;　index　<　4;　index++,　ptr++) 
        printf("%d %d\n", ref[index], *ptr); 
    return　0; 
}
 

8 8

4 4

0 0

2 2

2.在複習題1中，ref有多少個元素

4

3.在複習題1中，ref的地址是什麼？ref + 1是什麼意思？++ref指向什麼

1. 該陣列的第一個元素的地址
2. 該陣列第二個元素的地址
3. ++ref不是個有效的表示式，ref是常量，不是變數

4.在下面的程式碼中，*ptr和*(ptr + 2)的值分別是什麼

a.

int *ptr; int torf[2][2] = {12, 14, 16};

ptr = torf[0];

b.

int * ptr;

int fort[2][2] = { {12}, {14,16} };

ptr = fort[0];

a.

12  16

b.

12  14//多維陣列是按連續的儲存空間儲存的

5.在下面的程式碼中，**ptr和**(ptr + 1)的值分別是什麼？

a.

int (*ptr)[2];

int torf[2][2] = {12, 14, 16};

ptr = torf;

b.

int (*ptr)[2];

int fort[2][2] = { {12}, {14,16} };

ptr = fort;

a.

12  16

b.

12  14

6.假設有下面的宣告：

int grid[30][100];

a.用1種寫法表示grid[22][56]的地址

b.用2種寫法表示grid[22][0] 的地址

c.用3種寫法表示grid[0][0]的地址

a.

&grid[22][56]

b.

grid[22]

&grid[22][0]

c.

grid

grid[0]

&grid[0][0]

7.正確宣告以下各變數：

a.digits是一個內含10個int型別值的陣列

b.rates是一個內含6個float型別值的陣列

c.mat是一個內含3個元素的陣列，每個元素都是內含5個整數的陣列

d.psa是一個內含20個元素的陣列，每個元素都是指向int的指標

e.pstr是一個指向陣列的指標，該陣列內含20個char型別的值

a. int gigits[10];

b. float rates[6];

c. int mat[3][5];

d. int *pas[20];

e. char (*pstr)[20];

8.

a.宣告一個內含6個int型別值的陣列，並初始化各元素為1、2、4、8、16、32

b.用陣列表示法表示a宣告的陣列的第3個元素（其值為4）

c.假設編譯器支援C99/C11標準，宣告一個內含100個int型別值的陣列，並初始化最後一個元素為-1，其他元素不考慮

d.假設編譯器支援C99/C11標準，宣告一個內含100個int型別值的陣列，並初始化下標為5、10、11、12、3的元素為101，其他元素不考慮

a. int a[] = {1, 2, 4, 8, 16, 32};

b. a[2]

c. int a[]={[99] = -1};//可以指明或不指明陣列大小，不指明預設100，指明比100小編譯器報錯

d. int a[100] = {[5] = 101, [10] = 101, 101, 101, [3] = 101};//不能寫成[5] = [10] = ... = 101

9.內含10個元素的陣列下標範圍是什麼

0-9

10.假設有下面的宣告：

float rootbeer[10], things[10][5], *pf, value = 2.2;

int i = 3;

判斷以下各項是否有效：

a.rootbeer[2] = value;

b.scanf("%f", &rootbeer );

c.rootbeer = value;

d.printf("%f", rootbeer);

e.things[4][4] = rootbeer[3];

f.things[5] = rootbeer;

g.pf = value; h.pf = rootbeer;

a. o        b. x        c. x        d. x        e. o        f. x      g. x

11.宣告一個800×600的int型別陣列

int a[800][600];

12.下面聲明瞭3個數組：

double trots[20];

short clops[10][30];

long shots[5][10][15];

a.分別以傳統方式和以變長陣列為引數的方式編寫處理trots陣列的void函式原型和函式呼叫 b.分別以傳統方式和以變長陣列為引數的方式編寫處理clops陣列的void函式原型和函式呼叫

c.分別以傳統方式和以變長陣列為引數的方式編寫處理shots陣列的void函式原型和函式呼叫

a.
void func(double []);
void func(int, double [*]);

/*
題目說的是呼叫- -自閉
void func(double a[]){}
void func(int a, double b[a]){}
*/
func(trots);
func(20, trots);

b.
void func(short [][30]);
void func(int, int, short [*][*]);

/*
void func(short a[][30]){}
void func(int a, int b, short c[a][b]){}
*/
func(clops);
func(10, 30, clops);

c.
void func(long [][10][15]);
void func(int, int, int, long[*][*][*]);

/*
void func(long a[][10][15]){}
void func(int a, int b, int c, long d[a][b][c]){}
*/
func(shots);
func(5, 10, 15, shots);

13.下面有兩個函式原型：

void show(const double ar[], int n); // n是陣列元素的個數

void show2(const double ar2[][3], int n); // n是二維陣列的行數

a.編寫一個函式呼叫，把一個內含8、3、9和2的複合字面量傳遞給show()函式。

b.編寫一個函式呼叫，把一個2行3列的複合字面量（8、3、9作為第1行，5、4、1作為第2行）傳遞給show2()函式

a.
void show((double []){8, 3, 9, 2}, 4);
b.
void show((double [][3]){{8, 3, 9},{5, 4, 1}}, 6);//二維裡的3不能落下

程式設計練習

1.修改程式清單10.7的rain.c程式，用指標進行計算（仍然要宣告並初始化陣列）

#include <stdio.h>
#include <stdlib.h>

#define MONTHS 12   // 一年的月份數
#define YEARS  5    // 年數
int main(void)
{ // 用2010～2014年的降水量資料初始化陣列
    const float rain[YEARS][MONTHS] =
    {
        { 4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.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.8, 2.8, 3.8, 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.1f\n", 2010 + year, subtot);
        total += subtot;  // 5年的總降水量
    }
    printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);
    printf("MONTHLY AVERAGES:\n\n");
    printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct ");
    printf(" Nov  Dec\n");
    for (month = 0; month < MONTHS; month++)
    {             // 每個月，5年的總降水量
        for (year = 0, subtot = 0; year < YEARS; year++)
            subtot += *(*(rain + year) + month);
        printf("%4.1f ", subtot / YEARS);
    }
    printf("\n");
    return 0;
}

2.編寫一個程式，初始化一個double型別的陣列，然後把該陣列的內容拷貝至3個其他陣列中（在main()中宣告這4個數組）。使用帶陣列表示法的函式進行第1份拷貝。使用帶指標表示法和指標遞增的函式進行第2份拷貝。把目標陣列名、源陣列名和待拷貝的元素個數作為前兩個函式的引數。第3個函式以目標陣列名、源陣列名和指向源陣列最後一個元素後面的元素的指標。也就是說，給定以下宣告，則函式呼叫如下所示：

double source[5] = {1.1, 2.2, 3.3, 4.4, 5.5};

double target1[5];

double target2[5];

double target3[5];

copy_arr(target1, source, 5);

copy_ptr(target2, source, 5);

copy_ptrs(target3, source, source + 5);

#include <stdio.h>
#include <stdlib.h>

void copy_arr(double *target1, double *source, int n)
{
    for(int i = 0; i < n; i++)
    {
        target1[i] = source[i];
    }
}
void copy_ptr(double *target2, double *source, int n)
{
    for(int i = 0; i < n; i++)
    {
        *(target2 + i) =  *(source + i);
    }
}
void copy_ptrs(double *target3, double *source1, double *source2)
{
    double *i;
    int j;
    for(i = source1, j = 0; i < source2; i++, j++)
    {
        *(target3 + j) = *i;
    }
}

void xxx(double a[])
{
    for(int i = 0; i < 5; i++)
    {
        printf("%.1lf ", a[i]);
    }
    printf("\n");
}

int main(void)
{
    double source[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
    double target1[5];
    double target2[5];
    double target3[5];
    xxx(source);
    copy_arr(target1, source, 5);
    copy_ptr(target2, source, 5);
    copy_ptrs(target3, source, source + 5);
    xxx(target1);
    xxx(target2);
    xxx(target3);
    return 0;
}

3.編寫一個函式，返回儲存在int型別陣列中的最大值，並在一個簡單的程式中測試該函式

#include <stdio.h>
#include <stdlib.h>

int maxa(int a[], int n)
{
    /*
    不能寫 sizeof(a) / sizeof(int), a是指標，大小和int一樣, 把形參改為a[10]也不行
    int x = sizeof(a) / sizeof(int);
    printf("%d\n", x);
    */
    int num = 0;
    while(n--)
    {
        num = num > a[n] ? num : a[n];
        //不知道為什麼，寫成 num = num > a[n] ? : a[n] 的話，在a[4]那裡返回值會讓num變成1
    }
    return num;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    int a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }
    printf("%d\n", maxa(a, n));
    return 0;
}
/*
測試資料
10
4 3 2 1 0 9 8 7 6 5
*/

4.編寫一個函式，返回儲存在double型別陣列中最大值的下標，並在一個簡單的程式中測試該函式

#include <stdio.h>
#include <stdlib.h>

double maxa(double a[], int n)
{
    double num = 0;
    while(n--)
    {
        num = num > a[n] ? num : a[n];
    }
    return num;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    double a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    printf("%lf\n", maxa(a, n));
    return 0;
}
/*
測試資料
10
4 3 2 1 0 9 8 7 6 5
*/

5.編寫一個函式，返回儲存在double型別陣列中最大值和最小值的差值，並在一個簡單的程式中測試該函式

#include <stdio.h>
#include <stdlib.h>
#include <float.h>

double maxsmin(double a[], int n)
{
    double num1 = 0;
    double num2 = DBL_MAX;
    while(n--)
    {
        num1 = num1 > a[n] ? num1 : a[n];
        num2 = num2 > a[n] ? a[n] : num2;
    }
    return num1 - num2;
}

int main(void)
{
    int n;
    scanf("%d", &n);
    double a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    printf("%lf\n", maxsmin(a, n));
    return 0;
}
/*
測試資料
10
4 3 2 1 0 9 8 7 6 5
*/

6.編寫一個函式，把double型別陣列中的資料倒序排列，並在一個簡單的程式中測試該函式

/*順便複習了下快排- -，列印了交換過程*/
#include <stdio.h>
#include <stdlib.h>
#include <float.h>

void func(double a[])
{
    for(int i = 0; i < 10; i++)
    {
        printf("%.0lf ", a[i]);
    }
    printf(" | ");
}

int xx(double a[], int s, int e)
{
    double t = a[s];
    double x = a[s];
    while(s < e)
    {
        while(s < e && a[e] <= x)
        {
            e--;
        }
        a[s] = a[e];
        func(a);
        printf("%d %d s = %.0lf\n", s, e, a[s]);
        while(s < e && a[s] >= x)
        {
            s++;
        }
        a[e] = a[s];
        func(a);
        printf("%d %d e = %.0lf\n", s, e, a[e]);
    }
    a[s] = t;
    return s;
}

void sortd(double a[], int s, int e)
{
    if(s < e)
    {
        int x = xx(a, s, e);
        printf("-------------------------------\n");
        sortd(a, s, x - 1);
        sortd(a, x + 1, e);
    }
}

int main(void)
{
    int n;
    scanf("%d", &n);
    double a[n];
    for(int i = 0; i < n; i++)
    {
        scanf("%lf", &a[i]);
    }
    sortd(a, 0, n - 1);
    for(int i = 0; i < n; i++)
    {
        printf("%.1lf ", a[i]);
    }
    printf("\n");
    return 0;
}
/*
測試資料
10
4 3 5 1 0 9 2 7 6 8
*/

7.編寫一個程式，初始化一個double型別的二維陣列，使用程式設計練習2中的一個拷貝函式把該陣列中的資料拷貝至另一個二維陣列中（因為二維陣列是陣列的陣列，所以可以使用處理一維陣列的拷貝函式來處理陣列中的每個子陣列）

#include <stdio.h>
#include <stdlib.h>

void copy_ptrs(double *target3, double *source1, double *source2)
{
    double *i;
    int j;
    for(i = source1, j = 0; i < source2; i++, j++)
    {
        *(target3 + j) = *i;
    }
}

int main(void) {
    //double a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    double a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    double b[3][3];//不能寫成b[][3];
    //不能寫成copy_ptrs(b, a, a + 9), b的型別是(double*)[3], a同理
    for (int i = 0; i < 3; i++)
    {
        copy_ptrs(b[i], a[i], a[i] + 3);
    }
    /*
    for(int i = 0; i < 9; i++)
    {
        printf("%.0lf ", *(*b + i));//不能寫成*(b + i), 只有int型元素可以通過控制地址位置取值，b是陣列的指標,即(double*)[3]，*b才是元素的指標
    }
    printf("\n");
    printf("%p %p\n", b, *b);              000000000061FDA0 000000000061FDA0
    printf("%p %p\n", b + 1, *b + 1);      000000000061FDB8 000000000061FDA8
    */
    for (int j = 0; j < 3; ++j)
    {
        for (int i = 0; i < 3; ++i)
        {
            printf("%.0lf ", b[j][i]);
        }
        printf("\n");
    }
    return 0;
}

8.使用程式設計練習2中的拷貝函式，把一個內含7個元素的陣列中第3～第5個元素拷貝至內含3個元素的陣列中。該函式本身不需要修改，只需要選擇合適的實際引數（實際引數不需要是陣列名和陣列大小，只需要是陣列元素的地址和待處理元素的個數）

#include <stdio.h>
#include <stdlib.h>

void copy_ptrs(double *target3, double *source1, double *source2)
{
    double *i;
    int j;
    for(i = source1, j = 0; i < source2; i++, j++)
    {
        *(target3 + j) = *i;
    }
}

int main(void)
{
    double a[] = {1, 2, 3, 4, 5, 6, 7};
    double b[3];
    copy_ptrs(b, a + 2, a + 5);
    for (int i = 0; i < 3; ++i) {
        printf("%.0lf ", b[i]);
    }
    return 0;
}

9.編寫一個程式，初始化一個double型別的3×5二維陣列，使用一個處理變長陣列的函式將其拷貝至另一個二維陣列中。還要編寫一個以變長陣列為形參的函式以顯示兩個陣列的內容。這兩個函式應該能處理任意N×M陣列（如果編譯器不支援變長陣列，就使用傳統C函式處理N×5的陣列）

#include <stdio.h>
#include <stdlib.h>

void xx(int a, int b, double c[a][b], double d[a][b])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            d[i][j] = c[i][j];
        }
    }
}

void xxx(int a, int b, double c[a][b])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            printf("%-2.0lf ", c[i][j]);
        }
        printf("\n");
    }
}

int main(void)
{
    double a[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    double b[3][5];
    xx(3, 5, a, b);
    xxx(3, 5, a);
    xxx(3, 5, b);
    return 0;
}

10.編寫一個函式，把兩個陣列中相對應的元素相加，然後把結果儲存到第 3 個數組中。也就是說，如果陣列1中包含的值是2、4、5、8，陣列2中包含的值是1、0、4、6，那麼該函式把3、4、9、14賦給第3個數組。函式接受3個數組名和一個數組大小。在一個簡單的程式中測試該函式

#include <stdio.h>
#include <stdlib.h>

void xxx(int a, int b[a], int c[a], int d[a])
{
    for (int i = 0; i < a; ++i) {
        d[i] = b[i] + c[i];
    }
}

int main(void)
{
    int a;
    scanf("%d", &a);
    int b[a], c[a], d[a];
    for (int i = 0; i < a; ++i) {
        scanf("%d", b + i);
    }
    for (int i = 0; i < a; ++i) {
        scanf("%d", c + i);
    }
    xxx(a, b, c, d);
    for (int i = 0; i < a; ++i) {
        printf("%d ", d[i]);
    }
    return 0;
}

11.編寫一個程式，宣告一個int型別的3×5二維陣列，並用合適的值初始化它。該程式列印陣列中的值，然後各值翻倍（即是原值的2倍），並顯示出各元素的新值。編寫一個函式顯示陣列的內容，再編寫一個函式把各元素的值翻倍。這兩個函式都以陣列名和行數作為引數

#include <stdio.h>
#include <stdlib.h>

void xxx(int a, int b[][5])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < 5; ++j) {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
}

void xx(int a, int b[][5])
{
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < 5; ++j) {
            b[i][j] *= 2;
        }
    }
}

int main(void)
{
    int a[3][5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    xxx(3, a);
    xx(3, a);
    xxx(3, a);
    return 0;
}

12.重寫程式清單10.7的rain.c程式，把main()中的主要任務都改成用函式來完成

#include <stdio.h>
#include <stdlib.h>

#define MONTHS 12   // 一年的月份數
#define YEARS  5    // 年數

void yearaver(const float rain[YEARS][MONTHS])
    {
    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.1f\n", 2010 + year, subtot);
        total += subtot;  // 5年的總降水量
    }
    printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);
}

void monthaver(const float rain[YEARS][MONTHS])
{
    int year, month;
    float subtot, total;
    printf("MONTHLY AVERAGES:\n\n");
    printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct ");
    printf(" Nov  Dec\n");
    for (month = 0; month < MONTHS; month++)
    {             // 每個月，5年的總降水量
        for (year = 0, subtot = 0; year < YEARS; year++)
            subtot += *(*(rain + year) + month);
        printf("%4.1f ", subtot / YEARS);
    }
    printf("\n");
}

int main(void)
{ // 用2010～2014年的降水量資料初始化陣列
    const float rain[YEARS][MONTHS] =
            {
                    { 4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.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.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2 }
            };
    yearaver(rain);
    monthaver(rain);
    return 0;
}

13.編寫一個程式，提示使用者輸入3組數，每組數包含5個double型別的數（假設使用者都正確地響應，不會輸入非數值資料）。該程式應完成下列任務。

a.把使用者輸入的資料儲存在3×5的陣列中

b.計算每組（5個）資料的平均值

c.計算所有資料的平均值

d.找出這15個數據中的最大值

e.列印結果 每個任務都要用單獨的函式來完成（使用傳統C處理陣列的方式）。

完成任務b，要編寫一個計算並返回一維陣列平均值的函式，利用迴圈呼叫該函式3次。對於處理其他任務的函式，應該把整個陣列作為引數，完成任務c和d的函式應把結果返回主調函式

#include <stdio.h>
#include <stdlib.h>

double aver(double a[5])
{
    double sum = 0;
    for (int i = 0; i < 5; ++i) {
        sum += a[i];
    }
    return sum / 5;
}

double allaver(double a[3][5])
{
    double sum = 0;
    for (int i = 0; i < 3; ++i) {
        sum += aver(a[i]);
    }
    return sum / 3;
}

double maxx(double* a, double* b)
{
    double max = 0;
    for(;a < b; a++)
    {
        max = max > *a ? max : *a;
    }
    return max;
}

int main(void)
{
    double a[3][5];
    for (int i = 0; i < 3; ++i)
    {
        printf("input a sequence of 5 number:");
        for (int j = 0; j < 5; ++j) {
            scanf("%lf", &a[i][j]);
        }
    }
    double sum = 0;
    for (int k = 0; k < 3; ++k) {
        printf("%.2lf ", aver(a[k]));
    }
    printf("\n");
    printf("%.2lf\n", allaver(a));
    printf("%.2lf\n", maxx(*a, *a + 15));
    return 0;
}

14.以變長陣列作為函式形參，完成程式設計練習13

#include <stdio.h>
#include <stdlib.h>

double aver(int a, double b[a])
{
    double sum = 0;
    for (int i = 0; i < a; ++i) {
        sum += b[i];
    }
    return sum / 5;
}

double allaver(int b, int c, double a[b][c])
{
    double sum = 0;
    for (int i = 0; i < b; ++i) {
        sum += aver(c, a[i]);
    }
    return sum / 3;
}

double maxx(int a, int b, double c[a][b])
{
    double max = 0;
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            max = max > c[i][j] ? max : c[i][j];
        }
    }
    return max;
}

int main(void)
{
    double a[3][5];
    for (int i = 0; i < 3; ++i)
    {
        printf("input a sequence of 5 number:");
        for (int j = 0; j < 5; ++j) {
            scanf("%lf", &a[i][j]);
        }
    }
    double sum = 0;
    for (int k = 0; k < 3; ++k) {
        printf("%.2lf ", aver(5, a[k]));
    }
    printf("\n");
    printf("%.2lf\n", allaver(3, 5, a));
    printf("%.2lf\n", maxx(3, 5, a));
    return 0;
}