Lecture 4 Pointers

Memory

• Each piece of data stored in memory has an address.
• Java does not have a direct notion of memory manipulation, unlike C which uses pointers.
• Memory can be visualized as an array of bytes, where each byte has a unique address.
• In the example, the string "Hello, World!\n\0" is stored in memory, with each character occupying a byte.

References and Instances in Java

• Java has two main types of variables: primitive and reference.
• Primitive types store the actual value, and reference types store the location of an object or array.
• Primitive types include; long, int, short, char, boolean, double, and float.
• Reference types include; classes and arrays

Java Value Assignment

• In Java, if you pass a primitive variable to a function and modify it within the function, the original variable outside the function remains unchanged.
• If an integer is initialized to 0 and passed to function foo(), which changes it to 42, still maintains the value of 0 outside of the said function.
• When an array is passed to a function, bar(), which changes the first element to 42; this will affect the original array.

Choices in Java

• Java gives no choice of whether a variable is a reference or an instance; this is determined by its type.
• Variables of primitive type are always instance variables.
• Variables of class or array type are always reference variables.

References vs Pointers

• C uses pointers, while a reference refers to an object or an array.
• A reference is implementation-dependent and is not directly manipulated by the program.
• Pointers are variables that store a memory address.
• Pointers are hardware-dependent and are manipulated by the program.
• Pointers can hold a memory address, even if it's invalid or null.
• Pointers can also be used as references.

Java References

• A valid object reference or null can be stored.
• It's impossible to print or change the value of a reference in Java.
• You cannot store an specific value in a reference.

C pointers

• Pointers in C can be printed out and the value of the pointer variable can be manipulated.
• A pointer is simply an integer that is looked at as a memory address.
• A valid memory address, an invalid memory address, or NULL can be stored.
• With C pointers, arbitrary values, and addition, subtraction, and multiplication becomes possible.

Types in C

• Instance and pointer types are the two kinds of types in C.
• Instance types allow the variable to store the value itself.
• Pointer types are when the variable stores the address of the value.
• A pointer can point to a variable of any type.
• Placing the * after the type indicates it is a pointer to variables of that type.
• When accessing struct fields via pointer, the -> operator should be used; instead of the . operator.

Structs

• Structs are like classes, except there are no methods, and all fields are public and instance variables.
• Struct variables are accessed using the . operator.
• struct_node is a type

Pointer values

• int * val; points to an int.
• double *temp; points to a double.
• struct queue *q; points to a struct queue.
• char * word; points to a char or string.
• int ** vp; points to an integer poster.
• void * data; points to any kind of value.
• void ***ouch; points to a pointer to a pointer to any kind of value.

Pointers

• To point a pointer, the address of the data must be determined, and stored in the pointer.
• To get the data at a pointer, it must be dereferrenced..

Address of operator

• C provides the "address of" operator (&) to get the address of a variable.
• If V is of type T, then &V is of type T*.
• Every variable in a program is located in memory, hence it has an address.
• The & operator acts as a bitwise AND when used as a binary operator.

Dereference Operator

• Dereferencing a value obtains its value; C uses a dereference operator (*).
• Use the dereference operator before the pointer to obtain the value being pointed to.

int val = 42; // integer val contains 42
int *ptr = &val; // pointer points to val
printf(“%d”, *ptr); // print the value pointed to by ptr

• If a pointer P is of type T*, then *P is of type T.

Arrays

• Array variables are defined by specifying the array size after the name.
• int values[100]; // define an array of 100 integers
• int n = 50;
• char string[n]; // define an array of n chars
• Arrays can be defined as local, static, or global variables.
• Strings are stored using arrays in C.

C References

• In C, an array name is a constant reference to the array's starting address. - int values[100]; - int * ptr = values; // values refers to 0th element
• References are addresses that cannot be modified
• Assigning ptr to values values = ptr; would generate a compiler error

Strings in C

• Strings in C are stored in character (char) arrays, which means they can be viewed as an array of chars
• Strings are null-terminated, which means that the last character should be a nul (\0).
• The value of the string literal is the address of the first character in memory.

C Rules

• It's bad practice to include function or variable "definitions" in header files.
• Doing so will cause multiple code files which results in "multiple definitions error"
• Code files should have a corresponding header file.
• All functions and variables that are used outside of a code file should be declared (not defined) in the corresponding header file.
• Initialize all variables, especially pointers.
• Not initalizing local and global variables will return Garbage!

Program Statement

• The program rmdup reads in zero or more lines and outputs the lines, removing all duplicates.
• Input all input is from the console (stdin).
• Zero or more lines, where each line is terminated by a new-line/ And each contain less than 255 characters and a maximum of 100 lines.
• Output produces the console all the repeated lines removed.

Types of memory locations.

• When you define a variable, memory is assigned and when you initialize it, the value is written in.

Use of pointers

• Pointers are variables that store memory addresses, often of other variables.
• Pointers are needed to dynamically allocate memory, modify variables, and pass large amounts of data efficiently.

int x;
int * y;
y = &x;

• y is the pointer variable and contains the memory address of the integer variable x.
• The pointer’s type is not int, but rather the variable that the pointer points to is an int.

Dereference Operators

• Dereference operators get the content of the memory address pointed to by the pointer, by using '*'.
• The '*' operator can be read "value pointed to by"

int x = 10;                 //variable x = 10
int * y = &x;               //pointer variable y = Address of x
int z = *y;                 //z = “value pointed to by y” = x, i.e. z = x;

Pointer to Array conversion

• Arrays can be implicitly converted to the pointer of the proper - int arr20; - int * ptr; - ptr = arr; - arr=ptr would be invalid
• Arrays can be used like a pointer to its first element and can be used by same sets of operations.
• Pointers can be assigned for new addresses, while arrays cannot.

Pointer Arithmetic

• Addition and subtraction are the functions that can be performed for pointers.
• *p++ takes the value pointed to by p, then increments the pointer; *(++p) //increment pointer, then value pointed to by p increments the pointer, the value pointed to by p
• ++(*p) increments the value pointed to by p
• (*p)++ takes the value pointed to by p, then increments value
• *p++ take the value pointed to by p, then increments value

Function Arguements

• A pointer can be used as a function argument in C.
• Any dereferrencing on the pointer will affect the original value.

void chg_ptr(int* ptr)
{
- ptr = 200; //change value pointed to by ptr
}
int main()
{
int n = 1;
int *p = &n;
std::cout << *p << "\n"; //outputs 1
chg_ptr(p);
//change value pointed to by p
std::cout << *p << "\n";
//outputs 200
return 0;
}

Explanation of memory management in Java, covering memory addresses, primitive vs. reference types, and value assignments. Focuses on how Java handles memory differently from languages like C, and behavior of variables inside and outside functions.