Near, Far and Huge Pointers in C

Situatie

In older times, the intel processors had 16-bit registers but the address bus was 20-bits wide. Due to this, the registers were not able to hold the entire address at once. As a solution, the memory was divided into segments of 64 kB size, and the near pointers, far pointers, and huge pointers were used in C to store the addresses.

There are old concepts used in 16-bit intel architectures, not of much use anymore.

Solutie

Pasi de urmat

The Near Pointer is used to store the 16-bit addresses. It means that they can only reach the memory addresses within the current segment on a 16-bit machine. That is why we can only access the first 64 kb of data using near-pointers.

The size of the near pointer is 2 bytes.

// C Program to demonstrate the use of near pointer

#include <stdio.h>

int main()

{

// declaring a near pointer

int near* ptr;

// size of the near pointer

printf(“Size of Near Pointer: %d bytes”, sizeof(ptr));

return 0;

}

A far pointer stores the address in two 16-bit registers that allow it to access the memory outside of the current segment. The compiler allocates a segment register to store the segment address, then another register to store offset within the current segment. The offset is then added to the shifted segment address to get the actual address.

In the far pointer, the segment part cannot be modified as incrementing/decrementing only changes the offset but not the segment address.
The size of the far pointer is 4 bytes.
The problem with the far pointers is that the pointer has different values but points to the same address. So, the pointer comparison is useless on the far pointers.

// C Program to find the size of far pointer

#include <stdio.h>

int main()

{

// declaring far pointer

int far* ptr;

// Size of far pointer

printf(“Size of Far Pointer: %d bytes”, sizeof(ptr));

return 0;

}

The huge pointer also stores the addresses in two separate registers similar to the far pointer. It has the following characteristics:

In the Huge pointer, both offset and segment address is changed. That is why we can jump from one segment to other using a Huge Pointer.
The Huge Pointers always compare the absolute addresses, so the relational operation can be performed on it.
The size of the huge pointer is 4 bytes.

Syntax of Huge Pointer in C

pointer_type huge * pointer_name;

// C Program to find the size of the huge pointer

#include <stdio.h>

int main()

{

// declaring the huge pointer

int huge* ptr;

// size of huge pointer

printf(“Size of the Huge Pointer: %d bytes”,

sizeof(ptr));

return 0;

}

Tip solutie

Permanent

Follow Us