Cấp phát động, toán tử cấp phát, thu hồi new, delete

Cấp phát động, toán tử cấp phát, thu hồi new, delete

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.

Ví dụ:

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 ;

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 đề

Để 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.

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:

Dưới đây là ví dụ sử dụng tổng hợp các phép toán trên con trỏ.

: 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

head = new int[n] ; // cấp phát bộ nhớ chứa n số nguyên

for (p=head; p

{

cout << "So thu " << p-head+1 << ": " ; cin >> *p ;

for (p=head; p

for (q=p+1; q

if (*q < *p) { tam = *p; *p = *q; *q = tam; } // đổi chỗ

for (p=head; p

}

Con trỏ và mảng, xâu kí tự

Con trỏ và mảng 1 chiều

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++.

: 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:

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).

Con trỏ và xâu kí tự

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 ;

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.

Con trỏ và mảng hai chiều

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

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();

int i, j;

p = (float*) a;

for (i=0; i> *(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

{

for (j=0; j

cout << endl;

}

getch();