C++ Functions and Pointers

Functions and Pointers

• Functions are blocks of code performing a specific task.
• C++ allows programmers to define their own functions.
• Functions group code to perform a specific task and have a name.
• When invoked, a function executes the codes in its body.

Introduction to Pointers

• A pointer is a variable that stores the address of another variable.
• Pointer variable declaration: type *variableName; (e.g., int *a;)
• C++ uses pointers for dynamic data structures (e.g., linked lists).
• Pointers allow fast access to and manipulation of data in arrays.
• Pointers enhance low-level hardware interaction.
• Pointers avoid redundant data replication.

Why use Pointers?

• Pointers store addresses (64 bits, x86-64).
• Data types (e.g., int = 32 bits) limit int variable storage of addresses.
• Incrementing a pointer shifts it to the next data item.
• Incrementing an int variable changes its numeric value.
• Pointer truncation occurs when an int value tries to store a pointer.

Common Pointer Declarations

• int *p1; //Pointer to an integer variable

• double *p2; //Pointer to a double variable

• char *p3; //Pointer to a character variable

• float *p4; // Pointer to a float variable

• char *ptr[100]; // Array of 100 pointers to char

• Variables should be initialized (mandatory).

  • Example: int a = 10;

C Pointers – Operators

• & (ampersand): Returns the memory address of a variable.
• %p (format specifier): Displays addresses in hexadecimal format.
• Pointers are used to store and manipulate memory addresses.

Value at Address Operator

• * (asterisk): Returns the value at the memory address stored in a pointer.
• The asterisk is also known as the value-at-address operator.
• Used to access the data at the memory location pointed to by the pointer.
• Example: int *p1; p1 = &a; int val = *p1;

Types of Pointers

• Null Pointer: A pointer that doesn't point to valid memory.
  • Initialized with nullptr (modern C++) or NULL (older).
• Void Pointer: A generic pointer that can hold the pointer to any data type.
  • Needs a cast to access the actual data.
• Wild Pointer: An uninitialized pointer to arbitrary memory location.
  • Undefined behavior, not safe to access.

Pointer Arithmetic

• Pointers can be incremented or decremented.
• Arithmetic on an address is relative to the size of the contained value.
• Incrementing/Decrementing a pointer: pointer += sizeof(data_type).
• Addition/Subtraction by a constant (e.g., ptr= ptr + 3):
  • pointer += i * sizeof(data_type).
• Subtraction between two pointers:
  • (address in pointer1)-(address in pointer2))/sizeof(data_type).
  • Calculates the number of elements between the pointers

Dereferencing

• Dereferencing is retrieving the value stored at the memory location a pointer points to.
• Use the asterisk (*) operator: *pointer .
• Example: int *ptr = &x; cout << *ptr << endl; (outputs the value of x)

Calling a Function

• In C++, you call a function by writing its name followed by parenthesis, as seen in a simple example, hello().

Function Definition and Declaration

• A function's declaration tells the compiler about its name, return type and parameters.
  • Example: int max(int num1, int num2);
• A function's definition provides its actual code body with variables.
• Example:

int max(int num1, int num2) {
   if (num1 > num2) return num1;
   else return num2
}

Advantages of Functions

• Facilitates program maintenance and enhancement.
• Programs become easily understandable.
• Code duplication and errors are minimized.
• Debugging is significantly easier.
• Functions can be used in multiple programs.

Function Types

• No Arguments, No Return Value: void function_name().
• No Arguments, Return Value: dataType function_name().
• Arguments, No Return Value:void function_name(arguments)
• Arguments & Return Value: dataType function_name(arguments)
• Function declarations are placed above the main function, or can be placed above the main function. Function definitions are usually placed after the main function body.

Passing Arrays to Functions

• To pass an array to a function, pass the array name (without indexes).
• In a function, the formal parameter should be of the array type.
• Function prototype should show that the argument is an array.

Passing Structures to Functions

• To pass a structure to a function, pass the structure variable's name.

Function with no arguments and no return values

• Function receives no data at all.
• No data transfer between the calling and the called functions.

Functions with arguments and no return values

• Called function receives data from the calling function.

Function with arguments and return values

• Called function receives data from the calling function.
• When a function returns a value, the calling function receives the data.
• There is a two-way data transfer between the calling function and the called function. This is commonly used to use the return values from a function in other calculations, conditional blocks, or other steps in a program.