Con trỏ NULL trong C++

Giống như các biến thông thường, con trỏ cũng không được khởi tạo khi chúng được thể hiện/khai báo (instantiated). Trừ khi có một giá trị được gán, nếu không thì con trỏ sẽ trỏ đến một số địa chỉ rác theo mặc định.

Ngoài địa chỉ bộ nhớ ra, còn có một giá trị khác mà con trỏ có thể giữ: đó là giá trị null. Giá trị null là một giá trị đặc biệt, có ý nghĩa là con trỏ đang không trỏ đến bất cứ thứ gì. Một con trỏ chứa giá trị null được gọi là con trỏ null.

Trong C++, chúng ta có thể gán giá trị null cho một con trỏ bằng cách khởi tạo hoặc gán cho nó giá trị bằng 0.

float *ptr { 0 };  // ptr is now a null pointer
 
float *ptr2; // ptr2 is uninitialized
ptr2 = 0; // ptr2 is now a null pointer

Con trỏ sẽ chuyển thành boolean false nếu chúng null, và boolean true nếu chúng không null. Do đó, chúng ta có thể sử dụng một câu lệnh kiểm tra điều kiện để kiểm tra liệu rằng một con trỏ có null hay không:

double *ptr { 0 };
 
// pointers convert to boolean false if they are null, and boolean true if they are non-null
if (ptr)
    std::cout << "ptr is pointing to a double value.";
else
    std::cout << "ptr is a null pointer.";

Trong bài trước, chúng ta đã biết rằng việc dereferencing một con trỏ rác sẽ dẫn đến các kết quả không xác định. Việc dereferencing một con trỏ null cũng sẽ dẫn đến lỗi hành vi không xác định (undefined behavior). Trong hầu hết các trường hợp, nó sẽ làm ứng dụng của bạn bị crash.

Về mặt khái niệm, điều này thật sự có ý nghĩa. Việc dereferencing một con trỏ có nghĩa là “đi đến địa chỉ mà con trỏ đang trỏ tới và truy cập vào giá trị ở đó”. Và một con trỏ null thì giữ địa chỉ nào bên trong nó. Vì thế, hãy thử nghĩ xem, khi bạn cố gắng truy cập giá trị tại địa chỉ đó, con trỏ nên làm thế nào đây? ☺\

Giải thích macro là gì: Một macro là một đoạn code đã được đặt tên. Bất cứ khi nào tên này được sử dụng, nó sẽ được thay thế bằng nội dụng của macro. Có hai loại macro. Chúng khác nhau chủ yếu ở về hình thức khi chúng được sử dụng. Các macro giống như đối tượng (Object-like macros) thì giống với các đối tượng dữ liệu khi được sử dụng, các macro giống hàm (Function-like macro) thì giống với các lời gọi hàm.

Quay trở lại với con trỏ, lưu ý rằng giá trị 0 không phải là một kiểu dữ liệu con trỏ, do đó việc gán 0 (hoặc NULL, trước C++ 11) cho một con trỏ để biểu thị rằng nó là con trỏ null dường như gây ra sự không nhất quán. Trong một số trường hợp hiếm, khi được sử dụng làm đối số theo nghĩa đen, nó thậm chí có thể gây ra sự cố vì trình biên dịch không thể hiểu được chúng ta đangmuốn nói đến một con trỏ null hay số nguyên 0.

#include <cstddef> // for NULL
 
double *ptr { NULL }; // ptr is a null pointer

Trong trường hợp có khả năng NULL được định nghĩa là giá trị 0, khi thực hiện print(NULL) thực chất sẽ là gọi print(int), chứ không phải print(int*) như bạn vẫn mong đợi đối với một con trỏ null đúng nghĩa.

Để giải quyết vấn đề ở bên trên, C++ 11 đã giới thiệu 1 từ khóa mới gọi là nullptr. nullptr vừa là một từ khóa, và vừa là một giá trị hằng rvalue, giống như các từ khóa boolean là true và false.

Bắt đầu từ C++ 11, nullptr sẽ được ưu tiên hơn thay cho 0 khi chúng ta muốn có một con trỏ null:

#include <iostream>
#include <cstddef> // for NULL
 
void print(int x)
{
	std::cout << "print(int): " << x << '\n';
}
 
void print(int *x)
{
	if (!x)
		std::cout << "print(int*): null\n";
	else
		std::cout << "print(int*): " << *x << '\n';
}
 
int main()
{
	int *x { NULL };
	print(x); // calls print(int*) because x has type int*
	print(0); // calls print(int) because 0 is an integer literal
	print(NULL); // likely calls print(int), although we probably wanted print(int*)
 
	return 0;
}

C++ sẽ ngầm định chuyển đổi nullptr thành bất kỳ kiểu dữ liệu con trỏ nào. Vì vậy, trong ví dụ trên, nullptr đã được chuyển đổi ngầm định thành một con trỏ kiểu nguyên, và sau đó giá trị của nullptr được gán cho ptr. Điều này có tác dụng làm cho con trỏ kiểu nguyên ptr trở thành một con trỏ null.

Chúng ta cũng có thể gọi một hàm với từ khóa nullptr làm tham số, nó sẽ khớp với bất kỳ đối số truyền vào nào của hàm mà nhận vào một giá trị con trỏ:

int *ptr { nullptr }; // note: ptr is still an integer pointer, just set to a null value

C++ 11 cũng giới thiệu một kiểu dữ liệu mới gọi là std::nullptr_t (trong header <cstddef>). std::nullptr_t chỉ có thể giữ một giá trị: đó là nullptr! Mặc dù điều này có vẻ hơi ngớ ngẩn, nhưng nó lại hữu dụng trong một số tình huống. Nếu chúng ta muốn viết một hàm mà chỉ nhận vào đối số nullptr, vậy chúng ta sẽ thiết đặt kiểu dữ liệu nào cho đối số của hàm? Câu trả lời chính là std::nullptr_t.

#include <iostream>
 
void print(int x)
{
	std::cout << "print(int): " << x << '\n';
}
 
void print(int *x)
{
	if (!x)
		std::cout << "print(int*): null\n";
	else
		std::cout << "print(int*): " << *x << '\n';
}
 
int main()
{
	int *x { nullptr };
	print(x); // calls print(int*)
 
	print(nullptr); // calls print(int*) as desired
 
	return 0;
}

Trên đây là bài viết của eLib.VN giới thiệu về con trỏ NULL trong C++. Có lẽ bạn sẽ không bao giờ cần phải sử dụng tới nó, nhưng việc biết thêm về một kiến thức mới chưa bao giờ là không tốt! Chúc các bạn thành công!