Using Pointers in Python using ctypes

In this article, we are going to learn about using pointers in Python using ctypes module.

We will see how we can use Pointers in Python programming language using the ctypes module. Some basic operations like storing addresses, pointing to a different variable using pointers, etc. will be demonstrated here. Developers who have used C or C++ might be familiar with the Pointers concept and knows that even though it sometimes becomes hard to grasp but it is very useful. 

What is a Pointer?

A pointer is a special type of variable which stores the memory address of another variable. They can't store normal values like integers or float or Strings, they can only store Addresses and we can use that address location to print the value which has been stored in that address. Pointers don't store any value, it only stores address.

Also, if we want to store the address of an Integer variable then our pointer should also be of type integer, for float the pointer must be of type float. We can't store the address of a String into an Integer pointer.

In languages like C/C++ pointers are heavily used, to get the value to which the pointer is pointing we Dereference that pointer variable i.e while printing it we put the certain format specifier and then use an asterisk (*) with that variable to get the value it was pointing. To get the address we simply print that using the unsigned specifier (%u) as addresses must be unsigned (positive values).

Creating a variable to store a value using the ctypes module

In this we are going to create a pointer value_1 using ctypes module and then printing its type and value.

import ctypes as ct
# value_1 variable stores an integer
# of type Ctypes (not a regular integer)
value_1 = ct.c_int(10)

# printing the type of value_1
print(value_1)

# printing the value which value_1 stores
print(value_1.value) 

Output: In the above code when we are printing "value_1" it is printing c_long(10) instead of c_int(10) it is so because the size of c_long() and c_int() are same so whenever we are try to print c_int() type it prints c_long(). After that we are printing its value.

c_long(10)
10

Using float and double type:

# Importing ctypes module
import ctypes as ct

# creating a ctypes float variable
float_value = ct.c_float(15.25)

# creating a ctypes double variable
double_value = ct.c_double(85.69845)

# printing what float_value and double_value variable holds
print(float_value,double_value)

# printing the values stored inside float_value and double_value variable
print(float_value.value,double_value.value)

Output:

c_float(15.25) c_double(85.69845)
15.25 85.69845

Pointing to a different variable

Now it is time to do what pointers are used to do i.e pointing to an address/memory location. Also, we will verify that the pointer variable ptr which refers to pointer value_1 printing the same address or not.

import ctypes as ct

# storing a ctypes long value
value_1 = ct.c_long(10)

# using pointer() method we are pointing to the 
# value_1 variable and storing it in ptr
ptr = ct.pointer(value_1)

print("Contents of value_1 : " ,
      value_1)
print("Real value stored in value_1 : ",
      value_1.value)
print("Address of value_1 : ",
      id(value_1.value))

# If we want to print the contents of a pointer
# type variable then need to use .contents
# otherwise only writing the variable is enough like above
print("Contents of ptr variable : ",
      ptr.contents)

# To print the value stored in the address 
# pointed by that pointer variable
# we need to use .value after .contents
print("The value at which ptr points at : ",
      ptr.contents.value)

# Printing the address of the value to 
# which the ptr variable points at
print("Address of that value which is \
pointed and stored in ptr : ",id(ptr.contents.value))

Explanation: After importing and storing a value in value_1 variable we are using a variable named ptr (resembles pointer) and using the pointer method of the ctypes module to point to that value_1. Now to print what the ptr variable holds we have to use another method named contents which will print the content of the variable that ptr points at (similar to using & in C/C++), not the value of ptr. To print the value of ptr we have to use another method called values after contents this will print the value to which the ptr variable points (similar to using * in C/C++).

Output:

Contents of value_1 :  c_long(10)
Real value stored in value_1 :  10
Address of value_1 :  139741265425760
Contents of ptr variable :  c_long(10)
The value at which ptr points at :  10
Address of that value which is pointed and stored in ptr :  139741265425760

In the output, we can see that the id of the last print statement and the third print statement are the same, which means that ptr is pointing the to same memory location.

Changing the value of the variable which the pointer points at using the Pointer

In this, we are first creating a variable value_1 which stores the value 10 which is of ctype long, then using the ptr variable we are pointing to that variable. Now we are printing the value stored in value_1 variable, then we are changing the value of value_1 variable using the ptr variable. Then if we print the value of value_1 variable again, we will see the value stored inside it has changed.

import ctypes as ct

value_1 = ct.c_long(10)

# Creating a pointer which points at a 
# variable which stores c_long type value
ptr = ct.pointer(value_1)

# Printing to see what the void pointer currently holds
print("Value before Changing : " ,
      value_1.value)

# storing a value in ptr variable
ptr.contents.value = 25

# If we print the value_1 variable it will 
# now store the updated value
print("Value after Changing : ",
      value_1.value)

Output:

Value before Changing :  10
Value after Changing :  25

Void Pointers

As the name suggests void pointer is a type of Pointer that has no specific data type associated with it. It can be typecasted into any type and can hold data of any type. Since in Python the concept of pointers is not properly available or used we can't properly create a Void Pointer, as the POINTER function requires one argument i.e the data type. But we can create a Void pointer of a certain data type and then don't point it to any memory address. We are just typecasting it like C/C++ early.

Void Pointers using ctypes

We can also create some void pointers of a specific type that doesn't hold any address while creating. 

import ctypes as ct

# Creating a variable ptr2 which will act as a void pointer
# We will not point it to any other memory location
ptr2 = ct.POINTER(ct.c_int)

# Trying to print a void pointer
print(ptr2)

Output:

<class '__main__.LP_c_int'>

As we can see that if we try to print this void pointer as it doesn't point to any value it just points to the type it can store i.e long (ctypes by default converts int to long). Notice one thing here we have used POINTER() instead of pointer that's because the pointer() function creates a new pointer instance, pointing to an object. In contrast, POINTER() is a factory function that creates and returns a new ctypes pointer type. Pointer types are cached and reused internally, the parameter which we will pass in POINTER() must be of ctypes.

Making the void pointer point to an address

Now we will make the void pointer point to a variable of the same type which has been passed as its argument.

import ctypes as ct

value_1 = ct.c_int(10)

# Creating a void Pointer ptr2
ptr2 = ct.POINTER(ct.c_int)

# Trying to print the contents of the void 
# pointer before pointing it to any variable
print("Contents of Void Pointer : ",
      ptr2.contents)

# Now pointing the ptr2 variable to the value_1
# variable which is a ctype c_int
ptr2.contents = value_1

# Now again printing the contents of the ptr2 variable
print("Contents of void pointer after \
pointing it to a variable : ",ptr2.contents)

# Printing the value stored in the Void Pointer
print("Value stored by Void Pointer : ",
      ptr2.contents.value)

Explanation: Hereafter the creation of Void Pointer, we are pointing that ptr2 variable to a ctype c_int variable value_1. Now if we print the contents of the ptr2 variable we will see that it contains c_long(10). Now if we try to print the value stored in the address to which the ex-void pointer points we will get 10 as output. 

Output:

Contents of Void Pointer :  <attribute 'contents' of '_ctypes._Pointer' objects>
Contents of void pointer after pointing it to a variable :  c_int(10)
Value stored by Void Pointer :  10

If we don't point to a memory location but try to print the value of a void pointer we will get an error like below.

import ctypes as ct

value_1 = ct.c_int(10)

ptr = ct.pointer(value_1)

# Creating a void pointer
ptr2 = ct.POINTER(ct.c_int)

# Trying to print the value of a void pointer
# This returns an error
print(ptr2.contents.value)

Output:

Traceback (most recent call last):
  File "5e9a4694-422e-49db-afcd-212fcd2bfa3e.py", line 12, in <module>
    print(ptr2.contents.value)
AttributeError: 'getset_descriptor' object has no attribute 'value'

Null Pointer

A null pointer is also a type of Pointer that doesn't point to any memory location. The difference between a Null pointer and Void Pointer is that we can't typecast a Null Pointer to any other data type like Void Pointer.

Null Pointer using ctypes module:

We can also create a Null Pointer using the ctypes module if we create a POINTER type variable without any argument it creates a NULL Pointer.

import ctypes as ct

# Creating a Null Pointer of type c_long
null_ptr = ct.POINTER(ct.c_long)()

# Printing the null pointer
print(null_ptr)

Here we are creating a Null Pointer of type c_long by providing a blank () after the POINTER() method which indicates it is a Null Pointer. Now if we try to print it we will get a Hexadecimal Memory address like below.

Output:

<__main__.LP_c_long object at 0x7f5df5740200>

How to check if it is a Null Pointer

We can check the Null Pointer by using the bool() function, the Boolean value of a Null Pointer is always False,

# Importing ctypes module
import ctypes as ct

# Declare a void pointer
void_ptr = ct.POINTER(ct.c_int)

# Printing the boolean value of void pointer
print("Boolean Value of Void Pointer",
      bool(void_ptr))

# Declare a null pointer
null_ptr = ct.POINTER(ct.c_int)()

# Printing the boolean value of null pointer
print("Boolean Value of Null Pointer",
      bool(null_ptr))

Explanation: Here we are checking if really we were able to successfully make a Null Pointer. bool() function of Python can be used for this Purpose, the boolean value of the Null Pointer will always be 0 i.e False, which will indicate that we have created a Null Pointer successfully.

Output:

Boolean Value of Void Pointer True
Boolean Value of Null Pointer False