Bài 10.3. / CẤP PHÁT ĐỘNG NEW , DELETE , MẢNG XÂU KÝ TỰ .

1. Cấp phát động, toán tử cấp phát, thu hồi new, delete 
Khi tiến hành chạy chương trình, chương trình dịch sẽ bố trí các ô nhớ cụ thể cho 
các biến được khai báo trong chương trình. Vị trí cũng như số lượng các ô nhớ này tồn 
tại và cố định trong suốt thời gian chạy chương trình, chúng xem như đã bị chiếm dụng 
và sẽ không được sử dụng vào mục đích khác và chỉ được giải phóng sau khi chấm dứt 
chương trình. Việc phân bổ bộ nhớ như vậy được gọi là cấp phát tĩnh (vì được cấp sẵn 
trước khi chạy chương trình và không thể thay đổi tăng, giảm kích thước hoặc vị trí 
trong suốt quá trình chạy chương trình). Ví dụ nếu ta khai báo một mảng nguyên chứa 
1000 số thì trong bộ nhớ sẽ có một vùng nhớ liên tục 2000 bytes để chứa dữ liệu của 
mảng này. Khi đó dù trong chương trình ta chỉ nhập vào mảng và làm việc với một vài 
số thì phần mảng rỗi còn lại vẫn không được sử dụng vào việc khác. Đây là hạn chế 
thứ nhất của kiểu mảng. Ở một hướng khác, một lần nào đó chạy chương trình ta lại 



cần làm việc với hơn 1000 số nguyên. Khi đó vùng nhớ mà chương trình dịch đã dành 
cho mảng là không đủ để sử dụng. Đây chính là hạn chế thứ hai của mảng được khai 
báo trước. 
Khắc phục các hạn chế trên của kiểu mảng, bây giờ chúng ta sẽ không khai báo 
(bố trí) trước mảng dữ liệu với kích thước cố định như vậy. Kích thước cụ thể sẽ được 
cấp phát trong quá trình chạy chương trình theo  đúng yêu cầu của NSD. Nhờ vậy 
chúng ta có đủ số ô nhớ để làm việc mà vẫn tiết kiệm được bộ nhớ, và khi không dùng 
nữa ta có thể thu hồi (còn gọi là giải phóng) số ô nhớ này để chương trình sử dụng vào 
việc khác. Hai công việc cấp phát và thu hồi này được thực hiện thông qua các toán tử 
new, delete và con trỏ p. Thông qua p ta có thể làm việc với bất kỳ địa chỉ nào của 
vùng được cấp phát. Cách thức bố trí bộ nhớ như thế này được gọi là cấp phát động. 
Sau đây là cú pháp của câu lệnh new. 



p = new <kiểu> ;    // cấp phát 1 phần tử 
p = new <kiểu>[n] ;     // cấp phát n phần tử 
Ví dụ:   
int *p ; 
p = new int ;  // cấp phát vùng nhớ chứa được 1 số nguyên  
p = float int[100] ;  // cấp phát vùng nhớ chứa được 100 số thực 
Khi gặp toán tử new, chương trình sẽ tìm trong bộ nhớ một lượng ô nhớ còn rỗi 
và liên tục với số lượng đủ theo yêu cầu và cho p trỏ đến địa chỉ (byte đầu tiên) của 
vùng nhớ này. Nếu không có vùng nhớ với số lượng như vậy thì việc cấp phát là thất 
bại và p = NULL (NULL là một địa chỉ rỗng, không xác định). Do vậy ta có thể kiểm 
tra việc cấp phát có thành công hay không thông qua kiểm tra con trỏ p bằng hay khác 
NULL. Ví dụ: 
float *p ; 



int n ; 
cout << "Số lượng cần cấp phát = "; cin >> n; 
p = new double[n]; 
if (p == NULL) {  
cout << "Không đủ bộ nhớ" ;  
exit(0) ;      
}  
Ghi chú: lệnh exit(0) cho phép thoát khỏi chương trình, để sử dụng lệnh này cần 
khai báo file tiêu đề <process.h>. 



Để giải phóng bộ nhớ đã cấp phát cho một biến (khi không cần sử dụng nữa) ta sử 
dụng câu lệnh delete. 
delete p ;  // p là con trỏ được sử dụng trong new 
và để giải phóng toàn bộ mảng được cấp pháp thông qua con trỏ p ta dùng câu lệnh: 
delete[] p ;  // p là con trỏ trỏ đến mảng 
Dưới đây là ví dụ sử dụng tổng hợp các phép toán trên con trỏ. 
Ví dụ 1 : Nhập dãy số (không dùng mảng). Sắp xếp và in ra màn hình. 
Trong ví dụ này chương trình xin cấp phát bộ nhớ đủ chứa n số nguyên và được 
trỏ bởi con trỏ head. Khi đó địa chỉ của số nguyên đầu tiên và cuối cùng sẽ là head và 
head+n-1. p và q là 2 con trỏ chạy trên dãy số này, so sánh và đổi nội dung của các số 
này với nhau để sắp thành dãy tăng dần và cuối cùng in kết quả. 
main() 



{ 
 int *head, *p, *q, n, tam;  // head trỏ đến (đánh dấu) đầu dãy 
 cout << "Cho biết số số hạng của dãy: "); cin >> n ; 
 head = new int[n] ;   // cấp phát bộ nhớ chứa n số nguyên 
for (p=head; p<head+n; p++)  // nhập dãy 
{ 
cout << "So thu " << p-head+1 << ": " ; cin >> *p ;   
 } 
 for (p=head; p<head+n-1; p++)      // sắp xếp 
 for (q=p+1; q<head+n; q++)  
  if (*q < *p) { tam = *p; *p = *q; *q = tam; }  // đổi chỗ 
 for (p=head; p<head+n; p++) cout << *p ;   // in kết quả 



} 
2. Con trỏ và mảng, xâu kí tự  
a. Con trỏ và mảng 1 chiều 
Việc cho con trỏ trỏ đến mảng cũng tương tự trỏ đến các biến khác, tức gán địa 
chỉ của mảng (chính là tên mảng) cho con trỏ. Chú ý rằng địa chỉ của mảng cũng là địa 
chỉ của thành phần thứ 0 nên a+i sẽ là địa chỉ thành phần thứ i của mảng. Tương tự, 
nếu p trỏ đến mảng a thì p+i là địa chỉ thành phần thứ i của mảng a và do đó *(p+i) = 
 a[i] = *(a+i). 
Chú ý khi viết *(p+1) = *(a+1) ta thấy vai trò của p và a trong biểu thức này là
như nhau, cùng truy cập đến giá trị của phần tử a[1]. Tuy nhiên khi viết *(p++) thì lại
khác với *(a++), cụ thể viết p++ là hợp lệ còn a++ là không được phép. Lý do là tuy p
và a cùng thể hiện địa chỉ của mảng a nhưng p thực sự là một biến, nó có thể thay đổi
được giá trị còn a là một hằng, giá trị không được phép thay đổi. Ví dụ viết x = 3 và
sau đó có thể tăng x bởi x++ nhưng không thể viết x = 3++. 
Ví dụ 1 : In toàn bộ mảng thông qua con trỏ. 
int a[5] = {1,2,3,4,5}, *p, i; 
1:  p = a; for (i=1; i<=5; i++) cout << *(p+i);   // p không thay đổi 
hoặc:  
2: for (p=a; p<=a+4; p++) cout << *p ;    // thay đổi p 



Trong phương án 1, con trỏ p không thay đổi trong suốt quá trình làm việc của 
lệnh for, để truy nhập đến phần tử thứ i của mảng a ta sử dụng cú pháp *(p+i). 
Đối với phương án 2 con trỏ sẽ dịch chuyển dọc theo mảng a bắt đầu từ địa chỉ a 
(phần tử đầu tiên) đến phần tử cuối cùng. Tại bước thứ i, p sẽ trỏ vào phần tử a[i], do 
đó ta chỉ cần in giá trị *p. Để kiểm tra khi nào p đạt đến phần tử cuối cùng, ta có thể so 
sánh p với địa chỉ cuối mảng chính là địa chỉ đầu mảng cộng thêm số phần tử trong a 
và trừ 1 (tức a+4 trong ví dụ trên).  
b. Con trỏ và xâu kí tự 
Một con trỏ kí tự có thể xem như một biến xâu kí tự, trong đó xâu chính là tất cả 
các kí tự kể từ byte con trỏ trỏ đến cho đến byte '\0' gặp đầu tiên. Vì vậy ta có thể khai 
báo các xâu dưới dạng con trỏ kí tự như sau. 
char *s ;  
char *s = "Hello" ; 



Các hàm trên xâu vẫn được sử dụng như khi ta khai báo nó dưới dạng mảng kí tự. 
Ngoài ra khác với mảng kí tự, ta được phép sử dụng phép gán cho 2 xâu dưới dạng con 
trỏ, ví dụ: 
char *s, *t = "Tin học" ; s = t;  // thay cho hàm strcpy(s, t) ; 
Thực chất phép gán trên chỉ là gán 2 con trỏ với nhau, nó cho phép s bây giờ cũng 
được trỏ đến nơi mà t trỏ (tức dãy kí tự "Tin học" đã bố trí sẵn trong bộ nhớ) 
Khi khai báo xâu dạng con trỏ nó vẫn chưa có bộ nhớ cụ thể, vì vậy thông thường 
kèm theo khai báo ta cần phải xin cấp phát bộ nhớ cho xâu với độ dài cần thiết. Ví dụ: 
char *s = new char[30], *t ; 
  

strcpy(s, "Hello") ;  // trong trường hợp này không cần cấp phát bộ 
t = s ;    // nhớ cho t vì t và s cùng sử dụng chung vùng nhớ  
nhưng: 
char *s = new char[30], *t ; 
strcpy(s, "Hello") ;   
t = new char[30];  // trong trường hợp này phải cấp bộ nhớ cho t vì 
strcpy(t, s) ;   // có chỗ để strcpy sao chép sang nội dung của s.  
c. Con trỏ và mảng hai chiều 
Để dễ hiểu việc sử dụng con trỏ trỏ  đến mảng hai chiều, chúng ta nhắc lại về 
mảng 2 chiều thông qua ví dụ. Giả sử ta có khai báo: 
float a[2][3], *p;  
khi đó a được bố trí trong bộ nhớ như là một dãy 6 phần tử float như sau  




           
a  a+1 
tuy nhiên a không được xem là mảng 1 chiều với 6 phần tử mà được quan niệm 
như mảng một chiều gồm 2 phần tử, mỗi phần tử là 1 bộ 3 số thực. Do đó địa chỉ của 
mảng a chính là địa chỉ của phần tử đầu tiên a[0][0], và a+1 không phải là địa chỉ của 
phần tử tiếp theo a[0][1] mà là địa chỉ của phần tử a[1][0]. Nói cách khác a+1 cũng là 
tăng địa chỉ của a lên một thành phần, nhưng 1 thành phần ở đây được hiểu là toàn bộ 
một dòng của mảng.  
Mặt khác, việc lấy địa chỉ của từng phần tử (float) trong a thường là không chính 
xác. Ví dụ: viết &a[i][j] (địa chỉ của phần tử dòng i cột j) là được đối với mảng nguyên 
nhưng lại không đúng đối với mảng thực.  
Từ các thảo luận trên, phép gán p = a là dễ gây nhầm lẫn vì p là con trỏ float còn 

a là địa chỉ mảng (1 chiều). Do vậy trước khi gán ta cần ép kiểu của a về kiểu float. 
Tóm lại cách gán địa chỉ của a cho con trỏ p được thực hiện như sau:  
Cách sai: 
p = a ;   // sai vì khác kiểu 
Các cách đúng: 
p = (float*)a;   // ép kiểu của a về con trỏ float (cũng là kiểu của p) 
p = a[0];    // gán với địa chỉ của mảng a[0]  
p = &a[0][0];   // gán với địa chỉ số thực đầu tiên trong a  



trong đó cách dùng p = (float*)a; là trực quan và đúng trong mọi trường hợp nên 
được dùng thông dụng hơn cả. 
Sau khi gán a cho p (p là con trỏ thực), việc tăng giảm p chính là dịch chuyển con 
trỏ trên từng phần tử (thực) của a. Tức: 
p trỏ tới a[0][0] 
p+1 trỏ tới a[0][1] 
p+2 trỏ tới a[0][2] 
p+3 trỏ tới a[1][0] 
p+4 trỏ tới a[1][1] 
p+5 trỏ tới a[1][2] 
Tổng quát, đối với mảng m x n phần tử: 
p + i*n + j trỏ tới a[i][j]  hoặc  a[i][j] = *(p + i*n + j) 
Từ đó để truy nhập đến phần tử a[i][j] thông qua con trỏ p ta nên sử dụng cách 



viết sau: 
p = (float*)a; 
cin >> *(p+i*n+j) ;  // nhập cho a[i][j] 
cout << *(p+i*n+j);  // in a[i][j] 
Ví dụ sau đây cho phép nhập và in một mảng 2 chiều m*n (m dòng, n cột) thông 
qua con trỏ p. Nhập liên tiếp m*n số vào mảng và in thành ma trận m dòng, n cột. 
main()  
{  
clrscr();  
float a[m][n], *p;  
int i, j;  
p = (float*) a;  



for (i=0; i<m*n; i++) cin >> *(p+i);   // nhập như dãy mxn phần tử  
 *(p+2*n+3) = 100; *(p+4*n) = 100;  // gán a[2,3] = a[4][0] = 100 
for (i=0; i<m; i++)      // in lại dưới dạng ma trận 
{  
for (j=0; j<n; j++) cout << *(p+i*n+j);  
cout << endl;  
  

}  
getch();  
} 
Chú ý: việc lấy địa chỉ phần tử a[i][j] của mảng thực a là không chính xác. Tức: viết p 
= &a[i][j] có thể dẫn đến kết quả sai. 



3. Mảng con trỏ  
a. Khái niệm chung 
Thực chất một con trỏ cũng là một biến thông thường có tên gọi (ví dụ p, q, …), 
do đó cũng giống như biến, nhiều biến cùng kiểu có thể tổ chức thành một mảng với 
tên gọi chung, ở đây cũng vậy nhiều con trỏ cùng kiểu cũng được tổ chức thành mảng. 
Như vậy mỗi phần tử của mảng con trỏ là một con trỏ trỏ đến một mảng nào đó. Nói 
cách khác một mảng con trỏ cho phép quản lý nhiều mảng dữ liệu cùng kiểu. Cách 
khai báo: 
<kiểu> *a[size]; 
Ví dụ:  
int *a[10]; 
khai báo một mảng chứa 10 con trỏ. Mỗi con trỏ a[i] chứa địa chỉ của một mảng 
nguyên nào đó.  



b. Mảng xâu kí tự 
Là trường hợp riêng của mảng con trỏ nói chung, trong đó kiểu cụ thể là char. 
Mỗi thành phần mảng là một con trỏ trỏ đến một xâu kí tự, có nghĩa các thao tác tiến 
hành trên *a[i] như đối với một xâu kí tự.  
Ví dụ 1 : Nhập vào và in ra một bài thơ.  
main()  
{  
clrscr();  
char *dong[100];    // khai báo 100 con trỏ kí tự (100 dòng) 
int i, n;  
cout << "so dong = "; cin >> n ;  // nhập số dòng thực sự 

cin.ignore();     // loại dấu ↵ trong lệnh cin ở trên 
for (i=0; i<n; i++)  
 {  
dong[i] = new char[80]; // cấp bộ nhớ cho dòng i 
cin.getline(dong[i],80);  // nhập dòng i 
}  
for (i=0; i<n; i++) cout << dong[i] << endl; // in kết quả 
getch(); 
}