C/C++ Pointers vs Java References

Pointers and references are important concepts that help us understand how memory allocation works and how to access the memory address of a variable. In this article, we will learn C/C++ pointers and Java references in detail about their functionality, usage, and differences with examples.

• C/C++ Pointers: A pointer in C/C++ is a variable that is used to store the memory address of another variable. Pointers allow direct manipulation of memory, providing flexibility and more control over the system. However, they also carry risks like memory leaks and segmentation faults.
• Java References: In Java, a reference is used to refer to the memory address (not the direct location), just an abstraction to take indirect memory access. Java does not expose pointers to the programmer but provides higher-level concepts like objects and garbage collection to manage memory safely.

Difference Between C/C++ Pointers and Java References

The table below demonstrates the difference between C/C++ pointers and Java references.

Key Points of C/C++ Pointers and Java References

Let's now discuss some important key features of C/C++ pointers and Java references, which are listed below:

1. Memory Management in C/C++:

In C/C++, the programmer uses pointers to directly control memory. We can allocate the memory dynamically and release it when we don't need it for the further tasks. Pointers provide more control over memory, which makes it efficient and easy to manipulate addresses dynamically, but they also carry the risk of improper management, sometimes leading to memory leaks.

Example: Memory Management in C++ using pointers.

// Memory Management in C++ using Pointers.

#include <iostream>
using namespace std;

#include <iostream>
using namespace std;

int main() {
    
  // Dynamically allocated memory
    int* ptr = new int;
    
    // Assigning value to the pointer
    *ptr = 357;  
    
    // Output: 10
    cout << *ptr << endl;  
   
    // Deallocating memory
    delete ptr; 
    return 0;
}

357

Now, let's see how memory management is done is Java

Memory Management in Java:

In Java, memory management is handled automatically by the garbage collector. We don't need to allocate or free the memory manually. It simplifies the process of memory management, but also removes some level of flexibility, but it can be ignored.

Example: Java memory management using the reference.

// Java program to demonstrate the 
// memory management using reference
class Geek 
{
    int age;
    Geek(int age) {
        this.age = age;
    }
}

public class Geeks 
{
    public static void main(String[] args) 
    { 
        // Creating the object Geek 
        Geek g1 = new Geek(22);
        
        // Printing the value of age
       System.out.println(g1.age);
    }
}

22

2. Deferencing in C/C++:

In C/C++ we can dereference to access the value which are stored in the memory address a pointer holds the dereferencing a pointer using the * operator unlike in Java we can only interpret the object at the other end of the reference as something that it already is (i.e. we can cast a Object reference to String reference only if the object pointed to is a String).

Example: Demonstrate the dereferencing in C++.

#include <iostream>
using namespace std;

int main()
{

    int num = 357;
    
    // Pointer to num
    int *ptr = &num;
    cout << *ptr << endl;

    return 0;
}

357

Dereferencing in Java:

In Java, references do not require explicit dereferencing and can be used directly to access objects. When we use a reference to access an object the fields and method the Java automatically handle the dereferencing.

Example: A Java program demonstrates the reference and dereference.

// Java program to demonstrate the dereferencing of an object
class Geek {
    
    int age;
    Geek(int age) {
        this.age = age;
    }
}

public class Geeks 
{
    public static void main(String[] args) 
    { 
        // Creating the object Geek 
        // Reference variable g1
        Geek g1 = new Geek(22);
        
        // Pringting the value of age
       System.out.println(g1.age);
    }
}

22

3. Handling Null References in C/C++:

In C/C++, a pointer can NULL, indicating it does not point to any kind of valid memory address. Deferencing a NULL pointer leads to undefined behaviour.

int* ptr = NULL

Handling Null References in Java:

In Java, the reference can also be defined as null. And when we try to deference a null value, then it will leads to the NullPointerExcception.

Person p = null;

4. Pointer Arithmetic in C/C++:

Programming languages like C/C++ support the arithmetic operations. This allows us to perform the increment and decrement operation for example if we have the address of variable storing a bank details of employee 1 so we can also get the employee detail by increament to the previous variable Memory access via pointer arithmetic is fundamentally unsafe and for safe guarding, Java has a robust security model and disallows pointer arithmetic for this reason. Users cannot manipulate pointers, no matter what may ever be the case.

Example: C++ program demonstrates the pointer arithmetic.

// C++ program demonstrates the use of
// pointer arithmetic
#include <iostream>
using namespace std;

int main()
{

    int arr[] = {3, 5, 7};
    
    // Pointer to the first element
    int *ptr = arr;  
    
    // Increament pointer by 1
    ptr++;   
    
    // Display the value
    cout << *ptr << endl; 

    return 0;
}

5

Note: Java does not allow pointer arithmetic to keep the program safe and secure.

Code Comparison C/C++ Pointers and Java References

Let's now see the code comparsion between C/C++ pointers and Java references for better understanding.

Example: A C++ program demonstrates the use of Pointers.

// A simple CPP program to illustrate  
// the concept of pointers and  
// their manipulations in C/C++ 
#include <iostream> 
using namespace std; 
   
int main() 
{ 
   int number = 88;     
   int * pNumber;   
     
   // assign the address of the variable number  
   // to pointer pNumber 
   pNumber = &number;   
   
   // Print content of pNumber  
   cout << pNumber << endl;   
     
   // Print address of number 
   cout << &number << endl;   
     
   // Print value pointed to by pNumber 
   cout << *pNumber << endl;  
     
   // Print value of number 
   cout << number << endl;    
   
   // Re-assign value pointed to by pNumber 
   *pNumber = 99; 
   
   cout << pNumber << endl;   
   cout << &number << endl;   
   cout << *pNumber << endl;  
   cout << number << endl;   
                               
   cout << &pNumber << endl;  
} 

0x7ffe0c683454
0x7ffe0c683454
88
88
0x7ffe0c683454
0x7ffe0c683454
99
99
0x7ffe0c683458

Example: A Java program illustrates the references.

// A simple Java program  
// to illustrate the concept of  
// references  
class Rectangle  
{ 
  double length; 
  double breadth; 
} 
  
public class Geeks
{ 
    public static void main(String args[]) 
    { 
      
    // r1 is reference variable which contain  
    // the address of Actual Rectangle Object. 
    Rectangle r1 = new Rectangle(); 
        
    // r2 is another reference variable 
    // r2 is initialized with r1 means: 
    // r1 and r2 both are referring same object  
    // thus it does not create duplicate object  
    // nor does it allocate extra memory. 
    Rectangle r2 = r1; 
      
    r1.length = 10; 
    r2.length = 20; 
      
    System.out.println("Value of R1's Length : " + r1.length); 
    System.out.println("Value of R2's Length : " + r2.length); 
  
    } 
}

Value of R1's Length : 20.0
Value of R2's Length : 20.0

Important Points:

• Java does not have pointers like C/C++, because it doesn’t need them for regular programming.
• In C, we can add or subtract address using pointer, but Java only uses references that point to objects. We can change what a reference points to, but we can not do pointer arithmetic
• C/C++ gives more control over memory, which is useful for things like games and low-level software. Java helps avoid many security issues by managing memory automatically.