Con trỏ l&agrave; c&ocirc;ng cụ cực kỳ mạnh mẽ trong c&aacute;c ng&ocirc;n ngữ lập tr&igrave;nh cấp thấp.&nbsp;
Python được coi l&agrave; ng&ocirc;n ngữ lập tr&igrave;nh cấp cao, nhưng n&oacute; c&oacute; thể được mở rộng hoặc l&agrave; cầu nối với c&aacute;c ng&ocirc;n ngữ cấp thấp, cụ thể l&agrave; C v&agrave; C++.
Một package mới cập nhật gần đ&acirc;y đ&atilde; cho ph&eacute;p ch&uacute;ng ta sử dụng con trỏ trực tiếp trong code Python.
<h2 style="text-align: justify;">Con trỏ l&agrave; g&igrave;?</h2>
Con trỏ được định nghĩa l&agrave; <code>data-types</code> c&oacute; gi&aacute; trị l&agrave; địa chỉ vật l&yacute; trong bộ nhớ m&aacute;y t&iacute;nh.
V&iacute; dụ, h&atilde;y xem đoạn code C sau:
<pre class="language-python"><code>#include &lt;stdio.h&gt;
int main()
{
 int i = 1;
 int *i_ptr = &amp;i;

 printf("i=%d\n", i);
 printf("i_ptr=%p\n", i_ptr);
 printf("*i_ptr=%d\n", *i_ptr);
 return 0;
}</code></pre>
Trong v&iacute; dụ đơn giản n&agrave;y, ch&uacute;ng ta khai b&aacute;o số nguy&ecirc;n <code>i</code> v&agrave; g&aacute;n cho n&oacute; gi&aacute; trị <code>1</code>, sau đ&oacute; khai b&aacute;o một con trỏ tới số nguy&ecirc;n <code>i_ptr</code> v&agrave; g&aacute;n cho n&oacute; địa chỉ vật l&yacute; của số nguy&ecirc;n <code>i</code>.
Sau đ&oacute;, ta in ra gi&aacute; trị của <code>i</code>, gi&aacute; trị của <code>i_ptr</code> (địa chỉ nơi <code>i</code> được lưu trữ) v&agrave; sau đ&oacute; l&agrave; gi&aacute; trị được lưu trữ trong địa chỉ m&agrave; <code>i_ptr</code> trỏ đến.
Nếu chạy code, kết quả c&oacute; thể l&agrave;:
<pre class="language-python"><code>i=1
i_ptr=0061FEC8
*i_ptr=1</code></pre>
<h2 style="text-align: justify;">Tại sao cần sử dụng Pointer?</h2>
Bằng c&aacute;ch sử dụng con trỏ, ch&uacute;ng ta c&oacute; thể sử dụng địa chỉ của gi&aacute; trị thay v&igrave; bản th&acirc;n gi&aacute; trị.
Điều n&agrave;y rất hữu &iacute;ch trong nhiều t&igrave;nh huống.
V&iacute; dụ, khi <code>sorting</code> mảng, ch&uacute;ng ta thường ho&aacute;n đổi c&aacute;c mục.
Việc ho&aacute;n đổi gi&aacute; trị c&oacute; thể g&acirc;y tốn k&eacute;m bộ nhớ, v&igrave; ch&uacute;ng ta cần chuyển to&agrave;n bộ cấu tr&uacute;c dữ liệu từ địa chỉ n&agrave;y sang địa chỉ kh&aacute;c.
Mặt kh&aacute;c, ho&aacute;n đổi con trỏ gi&uacute;p tiết kiệm t&agrave;i nguy&ecirc;n.
Con trỏ cũng cho ph&eacute;p al__cpLocation động bộ nhớ.
Trong C, ta sử dụng với h&agrave;m <code>malloc</code>:
<pre class="language-python"><code>#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
const int SIZE = 10;
int main()
{
 int *ptr = (int *)malloc(SIZE * sizeof(int));
 for (int i = 0; i &lt; SIZE; i++)
 {
 *(ptr + i) = (i + 1);
 }
 for (int i = 0; i &lt; SIZE; i++)
 {
 printf("ptr=%p\n", ptr);
 printf("*ptr=%d\n", *ptr);
 ptr++;
 }
 return 0;
}</code></pre>
Trong v&iacute; dụ tr&ecirc;n, ch&uacute;ng ta cấp ph&aacute;t động kh&ocirc;ng gian cho 10 số nguy&ecirc;n.
Mỗi số nguy&ecirc;n d&agrave;i 4 byte, do đ&oacute; tổng cộng kh&ocirc;ng gian bộ nhớ l&agrave; 40 byte.
Ch&uacute;ng ta điền v&agrave;o mỗi vị tr&iacute; một số từ 1 đến 10, sau đ&oacute; in ra địa chỉ v&agrave; gi&aacute; trị của mỗi vị tr&iacute; v&agrave;o thời điểm đ&oacute;.
Kết quả đầu ra:
<pre class="language-python"><code>ptr=001E2C18
*ptr=1
ptr=001E2C1C
*ptr=2
ptr=001E2C20
*ptr=3
ptr=001E2C24
*ptr=4
ptr=001E2C28
*ptr=5
ptr=001E2C2C
*ptr=6
ptr=001E2C30
*ptr=7
ptr=001E2C34
*ptr=8
ptr=001E2C38
*ptr=9
ptr=001E2C3C
*ptr=10</code></pre>
<h2 style="text-align: justify;">Giới thiệu pointers.py</h2>
<a href="https://pypi.org/project/pointers.py/">pointers.py</a> cung cấp sự trừu tượng để sử dụng con trỏ trong code Python m&agrave; kh&ocirc;ng cần sử dụng <code>c-type</code> hoặc c extensions trực tiếp.
Đầu ti&ecirc;n, h&atilde;y c&agrave;i đặt <code>pointers.py</code> từ pip bằng lệnh:
<pre class="language-python"><code>pip install pointers.py</code></pre>
Viết một chương tr&igrave;nh đơn giản:
<pre class="language-python"><code>from pointers import to_ptr

ptr = to_ptr("hello world")
print(ptr)
print(*ptr)</code></pre>
Ta c&oacute; chuỗi "hello world" v&agrave; tạo một con trỏ c&oacute; t&ecirc;n <code>ptr</code> để lưu địa chỉ của chuỗi.
Sau đ&oacute;, ta in ra con trỏ v&agrave; gi&aacute; trị m&agrave; n&oacute; trỏ đến.
Kết quả chạy code:
<pre class="language-python"><code>0x26638d28430
hello world</code></pre>
V&igrave; vậy, ch&uacute;ng ta c&oacute; quyền truy cập trực tiếp v&agrave;o địa chỉ nơi lưu trữ &lsquo;hello world&rsquo;.
Thay v&agrave;o đ&oacute;, ta c&oacute; thể sử dụng c&uacute; ph&aacute;p sau để tr&iacute;ch xuất con trỏ từ gi&aacute; trị:
<pre class="language-python"><code>from pointers import _

ptr = _&amp;"hello world"
print(ptr)
print(*ptr)</code></pre>
B&acirc;y giờ ta c&oacute; thể trực tiếp thay đổi gi&aacute; trị của chuỗi n&agrave;y.
Nhớ rằng chuỗi trong Python l&agrave; bất biến, nghĩa l&agrave; ta kh&ocirc;ng thể thay đổi gi&aacute; trị của chuỗi m&agrave; chỉ c&oacute; thể tạo chuỗi mới.
Với con trỏ, ch&uacute;ng ta c&oacute; thể vượt qua hạn chế n&agrave;y:
<pre class="language-python"><code>from pointers import _

ptr = _&amp;"hello world"
print(ptr)
print(*ptr)

ptr &lt;&lt;= "hi world"
print(ptr)
print(*ptr)</code></pre>
Kết quả chạy code:
<pre class="language-python"><code>0x1ee67fabe30
hello world 
0x1ee67f38430
hi world</code></pre>
Cập nhật ERRATA (20/08/2022):
Xem đoạn code sau:
<pre class="language-python"><code>from pointers import _
def print_ptr(some_ptr):
 print(some_ptr)
 print(*some_ptr)

ptr = _&amp;"hello world"
ptr2 = _&amp;"hello world"
print_ptr(ptr)
print_ptr(ptr2)

print("===============")
ptr &lt;&lt;= "hi world"
print_ptr(ptr)
print_ptr(ptr2)</code></pre>
Trong v&iacute; dụ n&agrave;y, <code>ptr</code> v&agrave; <code>ptr2</code> đang tham chiếu đến c&ugrave;ng một đối tượng chứa chuỗi &ldquo;hello world&rdquo;.
Nếu kh&ocirc;ng c&oacute; con trỏ, khi gi&aacute; trị của một chuỗi thay đổi, n&oacute; sẽ được g&aacute;n cho cấu tr&uacute;c bộ nhớ python mới v&agrave; chuỗi c&ograve;n lại kh&ocirc;ng thay đổi.
Tuy nhi&ecirc;n, sau khi thay đổi gi&aacute; trị trong <code>ptr</code>, gi&aacute; trị cũng được thay đổi cho <code>ptr2</code>:
<pre class="language-python"><code>0x1c4bbd58530
hello world 
0x1c4bbd58530 
hello world 
===============
0x1c4bbe17870 
hi world 
0x1c4bbd58530 
hi world</code></pre>
Vậy l&agrave; ta đ&atilde; vượt qua được t&iacute;nh bất biến của chuỗi.
***
Đ&acirc;y l&agrave; c&aacute;ch ch&uacute;ng ta cấp ph&aacute;t động v&agrave; giải ph&oacute;ng bộ nhớ với <code>pointers.py</code>:
<pre class="language-python"><code>from pointers import malloc, free
import sys

ptr = malloc(sys.getsizeof(1))
ptr &lt;&lt;= 1
print(ptr)
print(*ptr)
free(ptr)</code></pre>
Trong đoạn code tr&ecirc;n, ch&uacute;ng ta cấp ph&aacute;t bộ nhớ c&oacute; k&iacute;ch thước bằng 1 số nguy&ecirc;n (28 byte) v&agrave; đẩy số 1 v&agrave;o bộ nhớ n&agrave;y.
Sau đ&oacute;, ta in ra địa chỉ v&agrave; gi&aacute; trị, sau đ&oacute; giải ph&oacute;ng bộ nhớ.
Kết quả đầu ra:
<pre class="language-python"><code>0x1c21a612470
1</code></pre>
H&atilde;y thử l&agrave;m một điều kh&aacute;c thường:
<pre class="language-python"><code>from pointers import _

ptr = _&amp;1
ptr &lt;&lt;= 2

assert 1 == 2</code></pre>
Bạn nghĩ sẽ c&oacute; lỗi x&aacute;c nhận code, phải kh&ocirc;ng? Thực tế l&agrave; kh&ocirc;ng!
Code kh&ocirc;ng đưa ra bất kỳ ngoại lệ n&agrave;o.
Do ta đ&atilde; ch&egrave;n v&agrave;o địa chỉ của 1 gi&aacute; trị 2, khiến mọi thứ rối tung l&ecirc;n.
V&igrave; vậy, h&atilde;y nhớ rằng con trỏ l&agrave; c&ocirc;ng cụ mạnh mẽ, nhưng n&oacute; phải đi k&egrave;m với sự cẩn thận v&agrave; tỉ mỉ!
Lời kết
C&oacute; thể n&oacute;i con trỏ l&agrave; một lựa chọn tuyệt vời cho bộ c&ocirc;ng cụ Python.
Con trỏ gi&uacute;p dễ d&agrave;ng kết nối giữa Python v&agrave; m&ocirc;i trường C v&agrave; hỗ trợ c&aacute;c t&aacute;c vụ phức tạp y&ecirc;u cầu truy cập bộ nhớ trực tiếp.

dev1_account1

Có thể sử dụng con trỏ trong Python không?

Cùng tác giả

dev1_account1

Có liên quan