MainframeMaster

COBOL Tutorial

COBOL POINTER

The POINTER data type in COBOL represents sophisticated memory address management and comprehensive dynamic data handling capabilities within enterprise programming environments, providing advanced memory allocation mechanisms for flexible data structures, enhanced pointer operations for dynamic programming, and intelligent address management features that enable precise memory control, optimal dynamic allocation workflows, and systematic pointer-based data access while maintaining memory safety, ensuring efficient resource utilization, and enabling scalable memory architectures across business applications requiring dynamic data management, variable-length processing, and advanced memory operations.

Basic POINTER Operations

Fundamental POINTER Usage
cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
*> Basic POINTER definitions and operations
WORKING-STORAGE SECTION.
01 WS-POINTER-VARIABLES.
   05 WS-DATA-POINTER       POINTER.
   05 WS-RECORD-POINTER     POINTER.
   05 WS-BUFFER-POINTER     POINTER.
   05 WS-NULL-POINTER       POINTER VALUE NULL.
 
*> BASED data items using pointers
01 WS-DYNAMIC-RECORD BASED(WS-DATA-POINTER).
   05 WS-RECORD-TYPE        PIC X(4).
   05 WS-RECORD-LENGTH      PIC 9(4) COMP.
   05 WS-RECORD-DATA        PIC X(100).
 
01 WS-VARIABLE-BUFFER BASED(WS-BUFFER-POINTER).
   05 WS-BUFFER-SIZE        PIC 9(6) COMP.
   05 WS-BUFFER-DATA        PIC X(1000).
 
PROCEDURE DIVISION.
DEMONSTRATE-BASIC-POINTERS.
    DISPLAY "=== BASIC POINTER OPERATIONS ==="
    
    *> Allocate memory for dynamic record
    ALLOCATE WS-DYNAMIC-RECORD
    IF RETURN-CODE = 0
        DISPLAY "✅ Memory allocated successfully"
        SET WS-DATA-POINTER TO ADDRESS OF WS-DYNAMIC-RECORD
    ELSE
        DISPLAY "❌ Memory allocation failed"
    END-IF
    
    *> Initialize dynamic record
    MOVE "CUST" TO WS-RECORD-TYPE
    MOVE 100 TO WS-RECORD-LENGTH
    MOVE "CUSTOMER DATA RECORD" TO WS-RECORD-DATA
    
    DISPLAY "Record Type: " WS-RECORD-TYPE
    DISPLAY "Record Length: " WS-RECORD-LENGTH
    DISPLAY "Record Data: " WS-RECORD-DATA
    
    *> Free allocated memory
    FREE WS-DYNAMIC-RECORD
    SET WS-DATA-POINTER TO NULL
 
*> Pointer validation and safety
VALIDATE-POINTER-OPERATIONS.
    *> Check for NULL pointer
    IF WS-DATA-POINTER = NULL
        DISPLAY "Pointer is NULL - safe to allocate"
        ALLOCATE WS-DYNAMIC-RECORD
    ELSE
        DISPLAY "Pointer already allocated"
    END-IF
    
    *> Safe pointer operations
    IF WS-DATA-POINTER NOT = NULL
        MOVE "PROD" TO WS-RECORD-TYPE
        DISPLAY "Updated record type: " WS-RECORD-TYPE
        FREE WS-DYNAMIC-RECORD
        SET WS-DATA-POINTER TO NULL
    END-IF
Memory Management
Dynamic Allocation
Address Handling

Advanced POINTER Applications

Dynamic Data Structures
cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
*> Advanced pointer applications
01 WS-LINKED-LIST-SYSTEM.
   05 WS-NODE-POINTER       POINTER.
   05 WS-HEAD-POINTER       POINTER VALUE NULL.
   05 WS-CURRENT-POINTER    POINTER.
   05 WS-TEMP-POINTER       POINTER.
 
01 WS-LIST-NODE BASED(WS-NODE-POINTER).
   05 WS-NODE-DATA          PIC X(50).
   05 WS-NODE-VALUE         PIC 9(8)V99.
   05 WS-NEXT-POINTER       POINTER.
 
01 WS-DYNAMIC-ARRAY-SYSTEM.
   05 WS-ARRAY-POINTER      POINTER.
   05 WS-ARRAY-SIZE         PIC 9(6) COMP VALUE 100.
   05 WS-ELEMENT-COUNT      PIC 9(6) COMP VALUE 0.
 
01 WS-ARRAY-ELEMENT BASED(WS-ARRAY-POINTER).
   05 WS-ELEMENTS OCCURS 1 TO 1000 TIMES 
      DEPENDING ON WS-ELEMENT-COUNT.
      10 WS-ELEMENT-ID      PIC 9(6).
      10 WS-ELEMENT-VALUE   PIC 9(8)V99.
      10 WS-ELEMENT-STATUS  PIC X.
 
PROCEDURE DIVISION.
IMPLEMENT-DYNAMIC-STRUCTURES.
    DISPLAY "=== DYNAMIC DATA STRUCTURES ==="
    
    PERFORM CREATE-LINKED-LIST
    PERFORM CREATE-DYNAMIC-ARRAY
    PERFORM PROCESS-DYNAMIC-DATA
    PERFORM CLEANUP-MEMORY
 
CREATE-LINKED-LIST.
    DISPLAY "Creating linked list structure..."
    
    *> Create first node
    ALLOCATE WS-LIST-NODE
    SET WS-HEAD-POINTER TO WS-NODE-POINTER
    MOVE "FIRST NODE DATA" TO WS-NODE-DATA
    MOVE 100.50 TO WS-NODE-VALUE
    SET WS-NEXT-POINTER TO NULL
    
    *> Create second node
    SET WS-CURRENT-POINTER TO WS-HEAD-POINTER
    ALLOCATE WS-LIST-NODE
    SET WS-NEXT-POINTER OF WS-CURRENT-POINTER TO WS-NODE-POINTER
    MOVE "SECOND NODE DATA" TO WS-NODE-DATA
    MOVE 200.75 TO WS-NODE-VALUE
    SET WS-NEXT-POINTER TO NULL
    
    DISPLAY "✅ Linked list created"
 
CREATE-DYNAMIC-ARRAY.
    DISPLAY "Creating dynamic array..."
    
    MOVE 5 TO WS-ELEMENT-COUNT
    ALLOCATE WS-ARRAY-ELEMENT
    
    *> Populate array elements
    PERFORM VARYING ELEMENT-INDEX FROM 1 BY 1 
        UNTIL ELEMENT-INDEX > WS-ELEMENT-COUNT
        MOVE ELEMENT-INDEX TO WS-ELEMENT-ID(ELEMENT-INDEX)
        COMPUTE WS-ELEMENT-VALUE(ELEMENT-INDEX) = ELEMENT-INDEX * 100
        MOVE 'A' TO WS-ELEMENT-STATUS(ELEMENT-INDEX)
    END-PERFORM
    
    DISPLAY "✅ Dynamic array created with " WS-ELEMENT-COUNT " elements"

Complete POINTER System

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
IDENTIFICATION DIVISION.
PROGRAM-ID. POINTER-DEMO.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MEMORY-MANAGEMENT.
   05 WS-ALLOCATED-COUNT    PIC 9(4) COMP VALUE 0.
   05 WS-FREED-COUNT        PIC 9(4) COMP VALUE 0.
   05 WS-MEMORY-ERRORS      PIC 9(3) COMP VALUE 0.
 
01 WS-CUSTOMER-SYSTEM.
   05 WS-CUSTOMER-POINTER   POINTER.
   05 WS-CUSTOMER-COUNT     PIC 9(4) COMP VALUE 0.
 
01 WS-CUSTOMER-RECORD BASED(WS-CUSTOMER-POINTER).
   05 WS-CUST-ID            PIC X(8).
   05 WS-CUST-NAME          PIC X(30).
   05 WS-CUST-BALANCE       PIC 9(8)V99 COMP-3.
   05 WS-CUST-STATUS        PIC X.
 
PROCEDURE DIVISION.
MAIN-POINTER-DEMO.
    DISPLAY "=== COMPREHENSIVE POINTER DEMO ==="
    
    PERFORM ALLOCATE-CUSTOMER-DATA
    PERFORM PROCESS-CUSTOMER-RECORDS
    PERFORM VALIDATE-MEMORY-OPERATIONS
    PERFORM CLEANUP-ALL-MEMORY
    PERFORM DISPLAY-MEMORY-STATISTICS
    
    DISPLAY "=== POINTER DEMO COMPLETE ==="
    STOP RUN.
 
ALLOCATE-CUSTOMER-DATA.
    DISPLAY "Allocating customer data..."
    
    ALLOCATE WS-CUSTOMER-RECORD
    IF RETURN-CODE = 0
        ADD 1 TO WS-ALLOCATED-COUNT
        MOVE "CUST0001" TO WS-CUST-ID
        MOVE "JOHN SMITH" TO WS-CUST-NAME
        MOVE 1500.75 TO WS-CUST-BALANCE
        MOVE "A" TO WS-CUST-STATUS
        ADD 1 TO WS-CUSTOMER-COUNT
        DISPLAY "✅ Customer record allocated"
    ELSE
        ADD 1 TO WS-MEMORY-ERRORS
        DISPLAY "❌ Allocation failed"
    END-IF
 
PROCESS-CUSTOMER-RECORDS.
    IF WS-CUSTOMER-POINTER NOT = NULL
        DISPLAY "Processing customer: " WS-CUST-ID
        DISPLAY "Name: " WS-CUST-NAME
        DISPLAY "Balance: $" WS-CUST-BALANCE
        DISPLAY "Status: " WS-CUST-STATUS
    END-IF
 
CLEANUP-ALL-MEMORY.
    IF WS-CUSTOMER-POINTER NOT = NULL
        FREE WS-CUSTOMER-RECORD
        SET WS-CUSTOMER-POINTER TO NULL
        ADD 1 TO WS-FREED-COUNT
        DISPLAY "✅ Memory freed"
    END-IF
 
DISPLAY-MEMORY-STATISTICS.
    DISPLAY "📊 Memory Management Statistics:"
    DISPLAY "  Allocations: " WS-ALLOCATED-COUNT
    DISPLAY "  Freed: " WS-FREED-COUNT
    DISPLAY "  Errors: " WS-MEMORY-ERRORS

POINTER Features and Capabilities

Memory Operations
  • • Dynamic memory allocation
  • • Memory deallocation (FREE)
  • • Address assignment (SET)
  • • NULL pointer handling
Data Structures
  • • BASED data item support
  • • Dynamic arrays
  • • Linked list implementation
  • • Variable-length records

Best Practices

Related Concepts

Dynamic Memory

Memory allocation and management

BASED Data

Based data item definitions

Memory Management

Advanced memory operations

Related Pages