Lập trình căn bản - Chương 7: Kiểu con trỏ

ho con tro pa tro toi=%d",*pa); 
 printf("\nNoi dung cua o nho con tro pb tro toi=%d ",*pb); 
 *pa=20; /* Thay đổi giá trị của *pa*/ 
*pb=20; /* Thay đổi giá trị của *pb*/ 
 printf("\nGia tri moi cua bien a=%d \n 
Gia tri moi cua bien b=%d ",a,b); /* a, b thay đổi theo*/ 
 getch(); 
 return 0; 
} 
Kết quả thực hiện chương trình: 
II.2.3 Cấp phát vùng nhớ cho biến con trỏ 
 Trước khi sử dụng biến con trỏ, ta nên cấp phát vùng nhớ cho biến con trỏ này 
quản lý địa chỉ. Việc cấp phát được thực hiện nhờ các hàm malloc(), calloc() trong thư 
viện alloc.h. 
 Cú pháp các hàm: 
 void *malloc(size_t size): Cấp phát vùng nhớ có kích thước là size. 
 void *calloc(size_t nitems, size_t size): Cấp phát vùng nhớ có kích 
thước là nitems*size. 
 Ví dụ: Giả sử ta có khai báo: 
 int a, *pa, *pb; 
 pa = (int*)malloc(sizeof(int)); /* Cấp phát vùng nhớ có kích thước bằng 
với kích thước của một số nguyên */ 
 pb= (int*)calloc(10, sizeof(int)); /* Cấp phát vùng nhớ có thể chứa được 
10 số nguyên*/ 
 Lúc này hình ảnh trong bộ nhớ như sau: 
 0 1 2 3 4 5 6 7 8 9 
 pa 2 byte pb 2 byte 
 Lưu ý: Khi sử dụng hàm malloc() hay calloc(), ta phải ép kiểu vì nguyên mẫu 
các hàm này trả về con trỏ kiểu void. 
II.2.4 Cấp phát lại vùng nhớ cho biến con trỏ 
 Trong quá trình thao tác trên biến con trỏ, nếu ta cần cấp phát thêm vùng nhớ 
có kích thước lớn hơn vùng nhớ đã cấp phát, ta sử dụng hàm realloc(). 
 Cú pháp: void *realloc(void *block, size_t size) 
 Ý nghĩa: 
- Cấp phát lại 1 vùng nhớ cho con trỏ block quản lý, vùng nhớ này có kích 
thước mới là size; khi cấp phát lại thì nội dung vùng nhớ trước đó vẫn tồn tại. 
Trang 83 
Lập trình căn bản 
- Kết quả trả về của hàm là địa chỉ đầu tiên của vùng nhớ mới. Địa chỉ này có 
thể khác với địa chỉ được chỉ ra khi cấp phát ban đầu. 
 Ví dụ: Trong ví dụ trên ta có thể cấp phát lại vùng nhớ do con trỏ pa quản lý 
như sau: 
 int a, *pa; 
 pa=(int*)malloc(sizeof(int)); /*Cấp phát vùng nhớ có kích thước 2 byte*/ 
 pa = realloc(pa, 6); /* Cấp phát lại vùng nhớ có kích thước 6 byte*/ 
II.2.5 Giải phóng vùng nhớ cho biến con trỏ 
 Một vùng nhớ đã cấp phát cho biến con trỏ, khi không còn sử dụng nữa, ta sẽ 
thu hồi lại vùng nhớ này nhờ hàm free(). 
 Cú pháp: void free(void *block) 
 Ý nghĩa: Giải phóng vùng nhớ được quản lý bởi con trỏ block. 
 Ví dụ: Ở ví dụ trên, sau khi thực hiện xong, ta giải phóng vùng nhớ cho 2 biến 
con trỏ pa & pb: 
 free(pa); 
 free(pb); 
II.2.6 Một số phép toán trên con trỏ 
 a. Phép gán con trỏ: Hai con trỏ cùng kiểu có thể gán cho nhau. 
 Ví dụ: 
 int a, *p, *a ; float *f; 
a = 5 ; p = &a ; q = p ; /* đúng */ 
f = p ; /* sai do khác kiểu */ 
 Ta cũng có thể ép kiểu con trỏ theo cú pháp: 
 (*) 
 Chẳng hạn, ví dụ trên được viết lại: 
 int a, *p, *a ; float *f; 
a = 5 ; p = &a ; q = p ; /* đúng */ 
f = (float*)p; /* Đúng nhờ ép kiểu*/ 
b. Cộng, trừ con trỏ với một số nguyên 
 Ta có thể cộng (+), trừ (-) 1 con trỏ với 1 số nguyên N nào đó; kết quả 
trả về là 1 con trỏ. Con trỏ này chỉ đến vùng nhớ cách vùng nhớ của con trỏ hiện tại N 
phần tử. 
 Ví dụ: Cho đoạn chương trình sau: 
 int *pa; 
 pa = (int*) malloc(20); /* Cấp phát vùng nhớ 20 byte=10 số nguyên*/ 
 int *pb, *pc; 
 pb = pa + 7; 
 pc = pb - 3; 
 Lúc này hình ảnh của pa, pb, pc như sau: 
 0 1 2 3 4 5 6 7 8 9 
 pa pc pb 
 c. Con trỏ NULL: là con trỏ không chứa địa chỉ nào cả. Ta có thể gán giá trị 
NULL cho 1 con trỏ có kiểu bất kỳ. 
 d. Lưu ý: 
 - Ta không thể cộng 2 con trỏ với nhau. 
Trang 84 
Lập trình căn bản 
 - Phép trừ 2 con trỏ cùng kiểu sẽ trả về 1 giá trị nguyên (int). Đây chính là 
khoảng cách (số phần tử) giữa 2 con trỏ đó. Chẳng hạn, trong ví dụ trên pc-pa=4. 
III. CON TRỎ VÀ MẢNG 
III.1 Con trỏ và mảng 1 chiều 
 Giữa mảng và con trỏ có một sự liên hệ rất chặt chẽ. Những phần tử của mảng 
có thể được xác định bằng chỉ số trong mảng, bên cạnh đó chúng cũng có thể được xác 
lập qua biến con trỏ. 
III.1.1 Truy cập các phần tử mảng theo dạng con trỏ 
 Ta có các quy tắc sau: 
 &[0] tương đương với 
& [] tương đương với + 
 [] tương đương với *( + ) 
 Ví dụ: Cho 1 mảng 1 chiều các số nguyên a có 5 phần tử, truy cập các phần tử 
theo kiểu mảng và theo kiểu con trỏ. 
#include 
#include 
 /* Nhập mảng bình thường*/ 
void NhapMang(int a[], int N){ 
 int i; 
 for(i=0;i<N;i++) 
 { 
 printf("Phan tu thu %d: ",i);scanf("%d",&a[i]); 
 } 
} 
 /* Nhập mảng theo dạng con trỏ*/ 
void NhapContro(int a[], int N) 
{ 
 int i; 
 for(i=0;i<N;i++){ 
 printf("Phan tu thu %d: ",i);scanf("%d",a+i); 
 } 
} 
int main() 
{ 
 int a[20],N,i; 
 clrscr(); 
 printf("So phan tu N= ");scanf("%d",&N); 
 NhapMang(a,N); /* NhapContro(a,N)*/ 
 printf("Truy cap theo kieu mang: "); 
 for(i=0;i<N;i++) 
 printf("%d ",a[i]); 
 printf("\nTruy cap theo kieu con tro: "); 
 for(i=0;i<N;i++) 
 printf("%d ",*(a+i)); 
 getch(); 
 return 0; 
} 
Kết quả thực thi của chương trình: 
Trang 85 
Lập trình căn bản 
III.1.2 Truy xuất từng phần tử đang được quản lý bởi con trỏ theo dạng 
mảng 
 [] tương đương với *( + ) 
 &[] tương đương với ( + ) 
 Trong đó là biến con trỏ, là 1 biểu thức số nguyên. 
 Ví dụ: Giả sử có khai báo: 
#include 
#include 
#include 
int main(){ 
 int *a; 
 int i; 
 clrscr(); 
 a=(int*)malloc(sizeof(int)*10); 
 for(i=0;i<10;i++) 
 a[i] = 2*i; 
 printf("Truy cap theo kieu mang: "); 
 for(i=0;i<10;i++) 
 printf("%d ",a[i]); 
 printf("\nTruy cap theo kieu con tro: "); 
 for(i=0;i<10;i++) 
 printf("%d ",*(a+i)); 
 getch(); 
 return 0; 
} 
Kết quả chương trình: 
 Với khai báo ở trên, hình ảnh của con trỏ a trong bộ nhớ: 
 0 1 2 3 4 5 6 7 8 9 
 0 2 4 6 8 10 12 14 16 18 
 a 2 byte 
III.1.3 Con trỏ chỉ đến phần tử mảng 
 Giả sử con trỏ ptr chỉ đến phần tử a[i] nào đó của mảng a thì: 
 ptr + j chỉ đến phần tử thứ j sau a[i], tức a[i+j] 
 ptr - j chỉ đến phần tử đứng trước a[i], tức a[i-j] 
 Ví dụ: Giả sử có 1 mảng mang_int, cho con trỏ contro_int chỉ đến phần tử thứ 5 
trong mảng. In ra các phần tử của contro_int & mang_int. 
#include 
Trang 86 
Lập trình căn bản 
#include 
#include 
int main() 
{ 
 int i,mang_int[10]; 
 int *contro_int; 
 clrscr(); 
 for(i=0;i<=9;i++) 
 mang_int[i]=i*2; 
 contro_int=&mang_int[5]; 
 printf("\nNoi dung cua mang_int ban dau="); 
 for (i=0;i<=9;i++) 
 printf("%d ",mang_int[i]); 
 printf("\nNoi dung cua contro_int ban dau ="); 
 for (i=0;i<5;i++) 
 printf("%d ",contro_int[i]); 
 for(i=0;i<5;i++) 
 contro_int[i]++; 
 printf("\n--------------------------------------------------------"); 
 printf("\nNoi dung cua mang_int sau khi tang 1="); 
 for (i=0;i<=9;i++) 
 printf("%d ",mang_int[i]); 
 printf("\nNoi dung cua contro_int sau khi tang 1="); 
 for (i=0;i<5;i++) 
 printf("%d ",contro_int[i]); 
 if (contro_int!=NULL) 
 free(contro_int); 
 getch(); 
 return 0; 
} 
Kết quả chương trình 
III.2 Con trỏ và mảng nhiều chiều 
Ta có thể sử dụng con trỏ thay cho mảng nhiều chiều như sau: 
Giả sử ta có mảng 2 chiều và biến con trỏ như sau: 
 int a[n][m]; 
 int *contro_int; 
Thực hiện phép gán contro_int=a; 
Khi đó phần tử a[0][0] được quản lý bởi contro_int; 
 a[0][1] được quản lý bởi contro_int+1; 
 a[0][2] được quản lý bởi contro_int+2; 
... 
 a[1][0] được quản lý bởi contro_int+m; 
 a[1][1] được quản lý bởi contro_int+m+1; 
... 
 a[n][m] được quản lý bởi contro_int+n*m; 
Tương tự như thế đối với mảng nhiều hơn 2 chiều. 
Trang 87 
Lập trình căn bản 
Ví dụ: Sự tương đương giữa mảng 2 chiều và con trỏ. 
#include 
#include 
#include 
int main() 
{ 
 int i,j; 
int mang_int[4][5]={1,2,3,4,5,6,7,8,9,10,11,12,13,14, 
15,16,17,18,19,20}; 
 int *contro_int; 
 clrscr(); 
 contro_int=(int*)mang_int; 
 printf("\nNoi dung cua mang_int ban dau="); 
 for (i=0;i<4;i++) 
 { 
 printf("\n"); 
 for (j=0;j<5;j++) 
 printf("%d\t",mang_int[i][j]); 
 } 
 printf("\n---------------------------------"); 
 printf("\nNoi dung cua contro_int ban dau \n"); 
 for (i=0;i<20;i++) 
 printf("%d ",contro_int[i]); 
 for(i=0;i<20;i++) 
 contro_int[i]++ ; 
 printf("\n--------------------------------------------------------"); 
 printf("\nNoi dung cua mang_int sau khi tang 1="); 
 for (i=0;i<4;i++) 
 { 
 printf("\n"); 
 for (j=0;j<5;j++) 
 printf("%d\t",mang_int[i][j]); 
 } 
 printf("\nNoi dung cua contro_int sau khi tang 1=\n"); 
 for (i=0;i<20;i++) 
 printf("%d ",contro_int[i]); 
 if (contro_int!=NULL) 
 free(contro_int); 
 getch(); 
 return 0; 
} 
Kết quả thực hiện chương trình như sau: 
Trang 88 
Lập trình căn bản 
IV. CON TRỎ VÀ THAM SỐ HÌNH THỨC CỦA HÀM 
 Khi tham số hình thức của hàm là một con trỏ thì theo nguyên tắc gọi hàm ta 
dùng tham số thực tế là 1 con trỏ có kiểu giống với kiểu của tham số hình thức. Nếu 
lúc thực thi hàm ta có sự thay đổi trên nội dung vùng nhớ được chỉ bởi con trỏ tham số 
hình thức thì lúc đó nội dung vùng nhớ được chỉ bởi tham số thực tế cũng sẽ bị thay 
đổi theo. 
 Ví dụ : Xét hàm hoán vị được viết như sau : 
#include 
#include 
void HoanVi(int *a, int *b) 
{ 
 int c=*a; 
 *a=*b; 
 *b=c; 
} 
int main() 
{ 
 int m=20,n=30; 
 clrscr(); 
 printf("Truoc khi goi ham m= %d, n= %d\n",m,n); 
 HoanVi(&m,&n); 
 printf("Sau khi goi ham m= %d, n= %d",m,n); 
 getch(); 
 return 0; 
} 
 Kết quả thực thi chương trình: 
Trước khi gọi hàm Khi gọi hàm Sau khi gọi hàm: 
 a=&m; b= &n; Con trỏ a, b bị giải phóng 
 Lúc này : *a=m; *b=n; m, n đã thay đổi: 
 Đổi chỗ ta được : 
 *a=m=30; *b=n=20; 
m=20 n=30 
&m &n 
m=20 n=30 
a b 
m=30 n=20 
&m &n 
m=30 n=20 
&m &n 
Trang 89 
Lập trình căn bản 
V. BÀI TẬP 
 V.1 Mục tiêu 
 Tiếp cận với một kiểu dữ liệu rất mạnh trong C là kiểu con trỏ. Từ đó, sinh viên có thể 
xây dựng các ứng dụng bằng cách sử dụng cấp phát động thông qua biến con trỏ. 
 V.2 Nội dung 
 Thực hiện các bài tập ở chương trước (chương VI : Kiểu mảng) bằng cách sử dụng 
con trỏ. 
Trang 90