國立屏東大學 資訊工程學系 程式設計(二)
在字串這一章中，我們已經介紹過兩種C語言的字串：字串陣列與字串指標，請參考下面的程式：
#include <stdio.h> #include <string.h> int main() { char str[]="Hello"; char *p; int i; printf("str at %p\n", str); for(i=0;i<strlen(str);i++) { printf("str[%d] at %p\n", i, &str[i]); } p = str; for(i=0;i<strlen(str);i++) { printf("*(p+%d)=str[%d]=%c at %p\n", i, i, *(p+i), p+i); } str[0]='h'; *(p+3)='L'; puts(str); puts(p); return 0; }
在這個程式中，我們先宣告了一個字串陣列，然後讓指標p指向該字串，我們可以使用陣列與指標的方式來存取在記憶體中的這個字串。其實這兩種方式在記憶體中是使用同樣的配置，其差別只在於我們是以陣列的索引來存取，亦或是使用指標來存取。換句話說，一個字串陣列可以當成指標字串來使用，反之亦然。請參考下面的程式：
#include <stdio.h>
#include <string.h>
int main()
{
char str[]="Hello";
char *p;
p = str;
p[0]='H';
*(str+3) = 'L';
puts(str);
puts(p);
return 0;
}
我們也可以使用「malloc()函式」或「calloc()函式」來動態地在記憶體中配置字串所需的空間，例如：
#define LEN 10; char *str = malloc((LEN+1)*sizeof(char)); 或是 char *str = malloc(LEN+1);
但是要特別注意的是，這種動態配置的字串，從其配置開始至程式結束，都會一直存在記憶體中，除非我們以「free()函式」將之釋放。為了在程式執行時，不要過度佔用記憶體，當我們不再需要該字串時，應該以下列程式碼將其釋放：
free(str);
如果要動態地宣告由多個字串所組成的陣列，又該如何做呢？請參考下面的例子：
#include <stdio.h> #include <stdlib.h> #include <string.h> #define numString 10 #define LEN 20 int main() { char *strs[numString]; int i; for(i=0;i<numString;i++) { strs[i] = (char *)(malloc(LEN+1)); } for(i=0;i<numString;i++) { printf("String %d = ", i+1); scanf(" %[^\n]", strs[i]); } for(i=0;i<numString;i++) { puts(strs[i]); } return 0; }
我們也可以將上述程式，改成以指向指標的指標的方式來完成：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define numString 10
#define LEN 20
int main()
{
char **strs;
int i;
strs = malloc(numString*sizeof(void *));
for(i=0;i<numString;i++)
*(strs+i) = malloc(LEN+1);
for(i=0;i<numString;i++)
{
printf("String %d = ", i+1);
scanf(" %[^\n]", *(strs+i));
}
for(i=0;i<numString;i++)
puts(*(strs+i));
return 0;
}
我們以下列範例示範以指標進行各式的字串操作：
首先是實作計算字串長度的函式：
int strlen(const char *s) { int n; for(n=0; *s!='\0';s++) n++; return n; }
int strlen(const char *s) { int n=0; for(; *s!='\0';s++) n++; return n; }
int strlen(const char *s) { int n=0; for(; *s; s++) n++; return n; }
int strlen(const char *s) { int n=0; for(; *s++; ) n++; return n; }
int strlen(const char *s) { int n=0; while(*s++) n++; return n; }
int strlen(const char *s) { const char *p = s; while(*s) s++; return s-p; }
char *strcat(char *s1, const char *s2) { char *p = s1; while(*p !='\0') p++; while(*s2 != '\0') { *p = *s2; p++; s2++; } *p = '\0'; return s1; }
char *strcat(char *s1, const char *s2) { char *p = s1; while(*p) p++; while(*p++ = *s2++); return s1; }
設計一個trim()函式，將字串前與後的空白字元移除：
char *trim(char *s) { char *f = s; char *t = s; while(*t !='\0') { if(*f==' ') f++; t++; } t--; while((*t ==' ')||(*t =='\n')) { t--; } t++; *t='\0'; s = f; return s; }
下面這個程式利用動態配置的方法，建立了一個陣列，並在執行時間改變其大小：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *data;
int size, i;
printf("Array Size=? ");
scanf(" %d", &size);
data = malloc(size*sizeof(int));
for(i=0;i<size;i++)
data[i]=i;
// add 10 more numbers
data = realloc(data, (size+10)*sizeof(int));
for(i=0;i<size+10;i++)
{
data[i]=i;
}
// remove last 5 numbers
data = realloc(data, (size+5)*sizeof(int));
for(i=0;i<size+5;i++)
printf("%d ", data[i]);
printf("\n");
return 0;
}
下面的例子，則是動態建置一個二維的陣列：
#include <stdio.h>
#include <stdlib.h>
int main()
{
int **data;
int Row, Col;
int i,j;
Row=3;
Col=2;
data = malloc(sizeof(int *)*Row);
for(i=0;i<Row;i++)
data[i] = malloc(Col*sizeof(int));
for(i=0;i<Row;i++)
for(j=0;j<Col;j++)
data[i][j]=i*Col+(j+1);
for(i=0;i<Row;i++)
{
for(j=0;j<Col;j++)
printf("%d ", data[i][j]);
printf("\n");
}
return 0;
}
在這個例子中，「data」在語法上是一個指向整數的指標的指標(pointer to pointer)，但在語意上是一個以指標來操作的陣列，其中每個陣列的元素為一個以指標來操作的陣列，也就形成了一個二維陣列。我們稱此種「雙指標」為「pointer to pointers」。
下面這個程式動態產生了一個Point的結構體：
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int x;
int y;
} Point;
void showPoint(Point p)
{
printf("(%d,%d)\n", p.x, p.y);
}
int main()
{
Point *p1 = malloc(sizeof(Point));
p1->x=5;
p1->y=10;
showPoint(*p1);
return 0;
}
我們也可以產生一個動態的陣列用以存放多個結構體：
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int x;
int y;
} Point;
void showPoint(Point p)
{
printf("(%d,%d)\n", p.x, p.y);
}
#define LEN 10
int main()
{
Point *ps = malloc(sizeof(Point)*LEN);
int i;
for(i=0;i<LEN;i++)
{
ps[i].x=i;
ps[i].y=i;
showPoint(ps[i]);
// showPoint(*(ps+i));
}
return 0;
}
函式指標(function pointer)為指向函式的指標，在C語言裡，若使用函式名稱但不接後續的括號，就會被視為是一個指向該函式的指標(也就是該函式在記憶體中的位址)，請參考下例：
int foo(int f) { return f*f; } int main() { printf("Function foo at %p.\n", foo); printf("The address of Function foo is %p.\n", &foo); return 0; }
請執行上述的程式，看看其結果。就如同陣列「int data[]」，其「data」與「&data」的值是一樣的，使用「foo」與「&foo」都是代表foo函式在記憶體中的位址，因此，我們可以宣告一個指標指向該位址：
int (*f)(int); //其中第一個int是函式的傳回值，第二個int則是引數
我們可以在程式中以下列程式碼，讓「f」指向「foo函式」，並加以呼叫：
f=foo; printf("%d\n", f(3)); 或是 printf("%d\n", (*f)(3));
這樣一來，在程式執行時，我們也可以讓指標動態地指向不同的函式，以完成不同的操作。請參考下面的程式：
#include <stdio.h>
#include <math.h>
int maximum(int d[], int n)
{
int max=d[0];
int i;
for(i=1;i<n;i++)
if(max<d[i])
max=d[i];
return max;
}
int minimum(int d[], int n)
{
int min=d[0];
int i;
for(i=1;i<n;i++)
if(min>d[i])
min=d[i];
return min;
}
int median(int d[], int n)
{
double average=0.0;
int i,med;
double temp;
for(i=0;i<n;i++)
{
average+=d[i];
}
average/=n;
med=d[0];
for(i=1;i<n;i++)
if(abs(med-average) > abs(d[i]-average))
med=d[i];
return med;
}
int findANumber( int (*func)(int d[], int s), int data[], int size)
{
return (*func)(data,size);
}
int main()
{
int data[10] = { 113, 345, 23, 75, 923, 634, 632, 134, 232, 98 };
int num;
num = findANumber(maximum, data, 10);
printf("The maximum is %d.\n", num);
num = findANumber(minimum, data, 10);
printf("The minimum is %d.\n", num);
num = findANumber(median, data, 10);
printf("The median is %d.\n", num);
return 0;
}
我們也可以延伸此做法，設計宣告一個指向多個函式的指標陣列：
void (*funcs[])(void) = {insert, delete, update}; ... (*funcs[i])(); //呼叫第i個函式
C99開始提供一個新的功能，允許我們為結構體設計彈性的陣列成員(Flexible Array Member)，也就是未定義大小的陣列，但必須為所有成員的最後一個，且只能有一個。請參考下面的程式：
#include <stdio.h>
#include <stdlib.h>
struct vstring
{
int len;
char chars[];
// char *chars;
};
int main()
{
struct vstring *str = malloc(sizeof(struct vstring)+10);
str->len=10;
return 0;
}