![Usage and deceleration
Pointer Declarationint *ptr; // Declares a
pointer to an integer
char *ptr; // Declares a pointer to a
character
• Pointer Initializationint x = 10;
• int *ptr = &x; // ptr now holds the
address of x
• Dereferencing a PointerDereferencing a
pointer means accessing the value stored
at the memory address the pointer is
pointing to.int x = 10;
• int *ptr = &x;
• printf(“%d”, *ptr); // Outputs 10
Pointer ArithmeticPointer arithmetic
involves operations like addition and
subtraction on pointers, typically used for
iterating through arrays.int arr[] = {10, 20,
30, 40, 50};
int *ptr = arr;
printf(“%d”, *(ptr + 2)); // Outputs 30](https://image.slidesharecdn.com/programmingpresentationgroup7ppt-240612150909-2d813534/85/programming-presentation-group-7-ppt-pdf-7-320.jpg)
![Reference types of programming language
Java:In Java, all non-primitive types (objects,
arrays) are reference types.String str = “Hello”;
int[] numbers = {1, 2, 3};
• C#:C# uses reference types for classes,
arrays, delegates, and more.Person person
= new Person();
• int[] numbers = {1, 2, 3};
C++:C++ supports both references and
pointers, but references are generally safer and
used for parameter passing and return
values.int x = 10;
int &ref = x; // ref is a reference to x](https://image.slidesharecdn.com/programmingpresentationgroup7ppt-240612150909-2d813534/85/programming-presentation-group-7-ppt-pdf-11-320.jpg)
![Example of reference usage
Example of Reference UsageJava Examplepublic class ReferenceExample {
public static void main(String[] args) {
Person person1 = new Person(“Alice”);
Person person2 = person1; // person2 is a reference to the same Person object as person1
person2.setName(“Bob”);
System.out.println(person1.getName()); // Outputs “Bob”
}
}
class Person {
private String name;
public Person(String name) {](https://image.slidesharecdn.com/programmingpresentationgroup7ppt-240612150909-2d813534/85/programming-presentation-group-7-ppt-pdf-12-320.jpg)
programming presentation group 7 ppt..pdf
- 1. Presentation. Programming Submitted by Saad Lodhi Nabiha Rana Dua Safdar Muqaddas Hanif Submitted to Mam Faiza
- 2. Pointer A pointer is a variable in programming languages, particularly C and C++, that stores the memory address of another variable. Pointers are a powerful feature of these languages because they provide direct access to memory and allow for efficient manipulation of data structures and dynamic memory allocation.
- 3. Functions of pointer 1. Direct Memory Access: Pointers enable direct manipulation of memory, which can improve performance for certain operations by eliminating the need to copy data 1. Dynamic Memory Allocation: Pointers are essential for allocating memory dynamically using functions like malloc and free in C, and new and delete in C++.
- 4. Functions of pointer Data Structures: Pointers are used to implement complex data structures such as linked lists, trees, and graphs. 3Function Arguments: Pointers can be used to pass large amounts of data to functions efficiently by passing the address of the data rather than the data itself. 3
- 5. Functions of pointer Array Management: Pointers provide efficient ways to iterate through arrays and manipulate array elements. Pointer Arithmetic: Allows for navigation through memory blocks, which is useful for various algorithms and operations.
- 6. Types of pointer Null Pointer: A pointer that is initialized to NULL or 0. It does not point to any valid memory location.int *ptr = NULL; Void Pointer (Generic Pointer): A special type of pointer that can point to any data type. It is often used for generic functions.void *ptr; Dangling Pointer: A pointer that points to a memory location that has been freed or deallocated. Using a dangling pointer can lead to undefined behavior.int *ptr = (int *)malloc(sizeof(int)); free(ptr); // ptr is now a dangling pointer Wild Pointer: An uninitialized pointer that can contain any arbitrary address. Using wild pointers can result in unpredictable behavior.int *ptr; // ptr is a wild pointer 1 2 3 4
- 7. Usage and deceleration Pointer Declarationint *ptr; // Declares a pointer to an integer char *ptr; // Declares a pointer to a character • Pointer Initializationint x = 10; • int *ptr = &x; // ptr now holds the address of x • Dereferencing a PointerDereferencing a pointer means accessing the value stored at the memory address the pointer is pointing to.int x = 10; • int *ptr = &x; • printf(“%d”, *ptr); // Outputs 10 Pointer ArithmeticPointer arithmetic involves operations like addition and subtraction on pointers, typically used for iterating through arrays.int arr[] = {10, 20, 30, 40, 50}; int *ptr = arr; printf(“%d”, *(ptr + 2)); // Outputs 30
- 8. Conclusion Pointers are a fundamental aspect of C and C++ programming, providing powerful capabilities for memory management, data structure manipulation, and efficient function calling. However, they require careful handling due to the potential for errors and undefined behavior. Understanding pointers and their various types and functions is essential for mastering low-level programming and system design.
- 9. Reference Reference is a value that enables a program to indirectly access a particular piece of data stored in memory. Rather than containing the actual data itself, a reference contains information about the location of the data, which can be an object, variable, array, or function. Characteristics of reference • Indirect Access: References allow access to data indirectly by storing the memory address where the data is located.
- 10. Characteristics of reference • Abstraction: References abstract away the direct manipulation of memory addresses, making code safer and easier to read. • Immutable Binding: In many languages, once a reference is set to point to a particular data object, it cannot be changed to point to a different object.
- 11. Reference types of programming language Java:In Java, all non-primitive types (objects, arrays) are reference types.String str = “Hello”; int[] numbers = {1, 2, 3}; • C#:C# uses reference types for classes, arrays, delegates, and more.Person person = new Person(); • int[] numbers = {1, 2, 3}; C++:C++ supports both references and pointers, but references are generally safer and used for parameter passing and return values.int x = 10; int &ref = x; // ref is a reference to x
- 12. Example of reference usage Example of Reference UsageJava Examplepublic class ReferenceExample { public static void main(String[] args) { Person person1 = new Person(“Alice”); Person person2 = person1; // person2 is a reference to the same Person object as person1 person2.setName(“Bob”); System.out.println(person1.getName()); // Outputs “Bob” } } class Person { private String name; public Person(String name) {
- 13. Continue….. .. This.name = name; } public void setName(String name) { this.name = name; } public String getName() { return name; } } In this example:person1 and person2 both reference the same Person object.Changing the name via person2 also reflects when accessing the name via person1, demonstrating shared access to the object.
- 14. Conclusion ConclusionReferences are a fundamental concept in programming that enable efficient, indirect access to data. They are widely used in object- oriented programming, parameter passing, and the implementation of dynamic data structures. Understanding how references work and how to use them effectively is crucial for developing robust and efficient software.
- 15. Memory allocation Definition Memory allocation in programming refers to the process of reserving a portion of computer memory for the storage of data during the execution of a program. Types of memory allocation 1 SMA 2DMA
- 16. Static memory allocation Definition • Static memory allocation is a method of allocating memory at compile time before the associated program is executed. The memory allocated using static memory allocation is fixed and cannot be changed during the runtime of the program. This type of allocation is typically used for global variables, static variables, and constants.
- 17. Advantages of static memory allocation • Predictability:Since memory is allocated at compile time, the program’s memory requirements are known beforehand, making it easier to manage resources. • No Fragmentation:Static memory allocation does not suffer from fragmentation issues, which are common in dynamic memory allocation. • Runtime Efficiency:There is no need for runtime memory allocation and deallocation, reducing the overhead and potential runtime errors. • Simplicity:Static allocation is simpler to implement and understand, reducing the complexity of memory management.
- 18. Characteristics of static memory Compile-Time Allocation:Memory is allocated during the compilation of the program.The size and type of memory allocation are known beforehand, making it predictable. • Fixed Size:The size of the allocated memory block is fixed and cannot be altered at runtime.This means the programmer must know the required memory size in advance. • Efficiency:Because the memory is allocated at compile time, there is no runtime overhead for memory allocation and deallocation.This can lead to more efficient memory usage for certain types of applications.
- 19. Example • Example of Static Memory AllocationGlobal VariablesIn C and C++, global variables are allocated statically.#include <stdio.h> • • int globalVar = 10; // Statically allocated global variable • • void display() { • printf(“Global Variable: %dn”, globalVar); • } • • int main() { • display(); • return 0; • }
- 20. Conclusion • ConclusionStatic memory allocation is a fundamental concept in programming where memory is allocated at compile time. It offers predictability, efficiency, and simplicity, making it suitable for scenarios where memory requirements are well-defined and constant. However, its lack of flexibility and potential for memory waste limit its applicability in dynamic and complex applications. Understanding static memory allocation is crucial for efficient resource management and optimal program performance in various programming contexts.
- 21. Dynamic memory allocation Definition Dynamic memory allocation is a type of memory allocation which provides memory during the time of allocation Dynamic memory allocation refers to the process of allocating memory at runtime as opposed to compile time. This allows programs to request memory as needed and release it when it is no longer required, enabling efficient use of memory for varying data sizes and structures. Dynamic memory allocation is crucial for implementing flexible data structures like linked lists, trees, and more.
- 22. Types of dynamic memory allocation There are four types of dynamic memory allocation
- 23. Malloc Function Header file for DMA (Stdlib. h) Definition: Melloc function create a single block of give size . During the time of allocation . Syntax: Pre= {data type} malloc (size of) Example: Ptr= (intr*) malloc (n*size of(intr)}
- 24. Calloc…. … Definition • Create bunch of blocks of given size during the time of allocation Syntax: • Ptr= (data type*)collac(sizeof) Example: Ptr= (intr*) calloc (n, sizeof{intr})
- 25. Realloc… … Definition: • Realloc function recreates already created blocks of given size. Syntax: • Ptr: (data type) realloc (old ptr new sizeof) Example: Ptr(data type*) realloc (ptr,n*sizeof(intr)}
- 26. Free()… … Definition Free () function deletes the allocated memory . • During the time of allocation. Syntax Free (pointer) Example: Free(ptr)
- 27. The End …. …