References might be implemented by storing the address.Usually Java references will be implemented as pointers, but that's not required by the specification. They may be using an additional layer of indirection to enable easier garbage collection. But in the end it will (almost always) boil down to (C-style) pointers being involved in the implementation of (Java-style) references.
You can't do pointer arithmetic with references. The most important difference between a pointer in C and a reference in Java is that you can't actually get to (and manipulate) the underlying value of a reference in Java. In other words: you can't do pointer arithmetic.
In C you can add something to a pointer (i.e. the address) or substract something to point to things that are "nearby" or point to places that are at any place.
In Java, a reference points to one thing and that thing only. You can make a variable hold a different reference, but you can't just ask it to point to "the thing after the original thing".
References are strongly typed. Another difference is that the type of a reference is much more strictly controlled in Java than the type of a pointer is in C. In C you can have an and cast it to a and just re-interpret the memory at that location. That re-interpretation doesn't work in Java: you can only interpret the object at the other end of the reference as something that it already is (i.e. you can cast a reference to reference only if the object pointed to is actually a ).
Those differences make C pointers more powerful, but also more dangerous. Both of those possibilities (pointer arithmetic and re-interpreting the values being pointed to) add flexibility to C and are the source of some of the power of the language. But they are also big sources of problems, because if used incorrectly they can easily break assumptions that your code is built around. And it's pretty easy to use them incorrectly.
The latest version of this topic can be found at Pointers (C++).
Pointers are declared using the following sequence.
where any valid pointer declarator may be used for . The syntax for a simple pointer declarator is as follows:
- The declaration specifiers:
An optional storage class specifier. For more information, see Specifiers.
An optional or keyword applying to the type of the object to be pointed to.
The type specifier: the name of a type representing the type of the object to be pointed to.
- The declarator:
An optional Microsoft specific modifier. For more information, see Microsoft-Specific Modifiers.
An optional or keyword applying to the pointer itself.
An optional initializer.
The declarator for a pointer to function looks like this:
- For an array of pointers, the syntax looks like this:
However, pointer declarators can be more complex. For more information,see Declarators.
Multiple declarators and their initializers may appear together in a single declaration in a comma separated list following the declaration specifier.
A simple example of a pointer declaration is:
The preceding declaration specifies that points to an object of type .
A more complex example is
The preceding declaration specifies that is a constant pointer to an object of type with static storage duration.
The next example shows how multiple pointers are declared and initialized:
In the preceding example, pointers p and q both point to objects of type and are initialized to the addresses of i and j respectively. The storage class specifier applies to both pointers.
Another example illustrates the use of pointers in data structures; in this case, a linked list.
C++ Abstract Declarators
Addition of Pointer Types
Indirection Operator: *
Address-of Operator: &