1 / 29

CHAPTER 4

CHAPTER 4. POINTER. Pointers. Basic concept of pointers Pointer declaration Pointer operator (& and *) Parameter passing by reference Dynamic variables. Basic Concept of Pointers.

damia
Download Presentation

CHAPTER 4

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CHAPTER 4 POINTER Prepared by MMD, Edited by MSY

  2. Pointers • Basic concept of pointers • Pointer declaration • Pointer operator (& and *) • Parameter passing by reference • Dynamic variables Prepared by MMD, Edited by MSY

  3. Basic Concept of Pointers • In previous chapter, you have learnt about how a function could return a single value under its name (passed by value). • But, for a function that must return multiple values we use parameter passing by pointers. (It is so called as passed by reference). • A pointer is a variable which directly points to a memory address. • It will allow the programmer to directly manipulate the data in memory. • So far, we have seen that a variable is used to store a value. A pointer variable, however, does not store a value but instead store the address of the memory space which contain the value. Prepared by MMD, Edited by MSY

  4. Basic Concept of Pointers • Why would we want to use pointers? • To call a function by reference so that the data passed to the function can be changed inside the function. • To create a dynamic data structure which can grow larger or smaller as necessary. Prepared by MMD, Edited by MSY

  5. number number directly references a variable whose value is 20 20 Basic Concept of Pointers cont… • A variable declaration such as, • int number = 20; causes the compiler to allocate a memory location for the variable number and store in it the integer value 20. • This absolute address of the memory location is readily available to our program during the run time. • The computer uses this address to access its content. Prepared by MMD, Edited by MSY

  6. numberptr number numberptr indirectly references a variable whose value is 20 20 Basic Concept of Pointers Cont… • A pointer declaration such as, • int *numberptr, number = 20; declares numberptr as a variable that points to an integer variable. Its content is not integer value 20 but, it is a memory address. • The * indicates that the variable being defined is a pointer. • In this sense, a variable named directly references a value, however a pointer indirectly references a value. Prepared by MMD, Edited by MSY

  7. Memory address Memory content 0x0000 27 A variable of type int is stored here. The address of this location is 0x0002. 0x0001 10 0x0002 76 0x0003 99 … ... ... ... 0xFFFC 0x0002 This location contains the value 0x0002. Therefore this location stores a pointer variable which points to the address 0x0002. 0xFFFD 787 0xFFFE 878 0xFFFF 999 Graphical Representation of MM Prepared by MMD, Edited by MSY

  8. Pointer Declaration • General format: data_type *ptr_name; • Example: • Pointer to an int: int *intptr; • Pointer to a char: char *charptr; • The asterisk (*) character in front of the variable name tells that the variable is a pointer and not a variable to store value. Prepared by MMD, Edited by MSY

  9. Pointer Operator (& and *) • To prevent the pointer from pointing to a random memory address, it is advisable that the pointer is initialized to 0 or NULL before being used. • When a pointer is created, it is not pointing to any valid memory address. Therefore, we need to assign it to a variable’s address by using the & operator. This operator is called a reference operator. • After a pointer is assigned to a particular address, the value in the pointed address can be accessed using the * operator. This operator is called a dereference operator. Prepared by MMD, Edited by MSY

  10. Pointer Operator (& and *) • Look at this example: int num = 9; int *num_ptr; num_ptr = # printf(“num = %d”, *num_ptr); • Output: num = 9 Prepared by MMD, Edited by MSY

  11. num 9 numPtr Graphical representation of a pointer pointing to an integer variable in memory numPtr num 500000 600000 600000 9 Representation of num and numPtr in memory Pointer Operator (& and *) Cont… Prepared by MMD, Edited by MSY

  12. Example #include <stdio.h> void main(void) { int var = 10; int *ptrvar = &var; printf(“The address of the variable var is: %x\n”, &var); printf(“The value of the pointer ptrvar is: %x\n”, ptrvar); printf(“Both values are the same\n”); printf(“The value of the variable var is: %d\n”, var); printf(“The value of *ptrvar is: %d\n”, *ptrvar); printf(“Both values are the same\n”); printf(“The address of the value pointed by ptrvar is: %d\n”, &*ptrvar); printf(“The value inside the address of ptrvar is: %d\n”, *&ptrvar); printf(“Both values are the same\n”); } Prepared by MMD, Edited by MSY

  13. Output /*Sample Output The address of the variable var is: 1245052 The value of the pointer ptrvar is: 1245052 Both values are the same The value of the variable var is: 10 The value of *ptrvar is: 10 Both values are the same The address of the value pointed by ptrvar is: 1245052 The value inside the address of ptrvar is: 1245052 Both values are the same Press any key to continue */ Prepared by MMD, Edited by MSY

  14. Parameter Passing by Reference • A function call by reference can be done by passing a pointer to the function argument (the same way as passing a normal variable to the argument). • When the value referenced by the pointer is changed inside the function, the value in the actual variable will also change. • Therefore, we can pass the result of the function through the function argument without having to use the return statement. In fact, by passing pointers to the function argument, we can return more than one value. Prepared by MMD, Edited by MSY

  15. Parameter Passing by Reference Cont… • When a pointer is passed to a function, we are actually passing the address of a variable to the function. • Since we have the address, we can directly manipulate the data in the address. • In the case where a non-pointer variable is passed, the function will create another space in memory to hold the value locally while the program is inside the function. Therefore, any change to the variable inside the function will not change the actual value of the variable. Prepared by MMD, Edited by MSY

  16. Parameter Passing by Reference Cont… • To pass the value of variable by pointers between two functions, we must do the following: • Declare the variable that is meant to return a value to the calling function as a pointer variable in the formal parameter list of the function. void called_function(int *result); • When to call the function, use a variable together with address operator (&) called_function(&value_returned); Prepared by MMD, Edited by MSY

  17. Parameter Passing by Reference Cont… • Note : the effect of the above two actions is the same as the effect of the declarations • int value_returned; • int *result=&value_returned; 3. Declare the function with pointer parameter appropriately in a function prototype by using symbol * as a prefix for pointer parameters. void called_function(int *x); Prepared by MMD, Edited by MSY

  18. Example #include <stdio.h> void Func1(int, int); void Func2(int *, int *); void main(void) { int a = 8, b = 9; printf(“Before Func1 is called, a = %d, b = %d\n”, a, b); Func1(a, b); printf(“After Func1 is called, a = %d, b = %d\n”, a, b); printf(“\nBefore Func2 is called, a = %d, b = %d\n”, a, b); Func2(&a, &b); printf(“After Func2 is called, a = %d, b = %\nd”, a, b); } void Func1(int a, int b) { a = 0; b = 0; printf(“Inside Func1, a = %d, b = %d\n”, a, b); } Prepared by MMD, Edited by MSY

  19. Example Cont… void Func2(int *pa, int *pb) { *pa = 0; *pb = 0; printf(“Inside Func2, *pa = %d, *pb = %d\n”, *pa, *pb); } Output: Before Func1 is called, a = 8, b = 9 Inside Func1, a = 0, b = 0 After Func1 is called, a = 8, b = 9 Before Func2 is called, a = 8, b = 9 Inside Func2, *pa = 0, *pb = 0 After Func2 is called, a = 0, b = 0 Prepared by MMD, Edited by MSY

  20. Dynamic Variables • Variables that can be created and destroyed during program execution. • To use dynamic variables: • Decide the type of data to be stored in such variable • Declare a pointer variable of that data type • Assign to the pointer the address created by the standard library function malloc. (malloc is declared in the standard header file stdlib.h) Prepared by MMD, Edited by MSY

  21. Dynamic Variables (con’t) • The function malloc is used to allocate a certain amount of memory during the execution of a program. • The malloc function will request a block of memory from the heap. If the request is granted, the operating system will reserve the requested amount of memory. • When the amount of memory is not needed anymore, we must return it to the operating system by calling the function free. Prepared by MMD, Edited by MSY

  22. Dynamic Variables (con’t) Example: To create a dynamic variable of type int: • Declare a pointer variable of type int int *ptr; • Use the function malloc to create the dynamic variable ptr =malloc(sizeof(int)); • The argument of malloc function is the number of bytes to be allocated for the dynamic variable it creates. Prepared by MMD, Edited by MSY

  23. Dynamic Variables Cont… • Normally we use the sizeof operator on a data type to specify the number of bytes as the argument of malloc. • malloc will allocate from the free memory location that can store a value in the indicated number of bytes. • In this example, malloc instructs the OS to allocate a memory location of sizeof(int) bytes. • If there is enough space in the free store, the OS gives it to the program and makes its address available to malloc i.e malloc returns the address of the dynamically allocated memory location to the pointer variable ptr. • If there is no available space, malloc returns NULL. Prepared by MMD, Edited by MSY

  24. Dynamic Variables Cont… • We may destroy the dynamic variable by using free function. • free(ptr) causes the OS to release the memory location pointed by the pointer variable ptr. • However, the memory location for the variable ptr is not deallocated and its content is not changed (it still contains an address but can no longer be used to access the memory legally) • It is advisable to assign the value NULL to ptr immediately after the application of the free function. Prepared by MMD, Edited by MSY

  25. Dynamic Variables Cont… int *ptr; ptr = malloc(sizeof(int)); *ptr = 5; free(ptr); ptr=NULL; ptr ? ptr  ? ptr  5 ptr Invalid address ptr NULL Prepared by MMD, Edited by MSY

  26. Sizeof(): Example /* * $Id: sizeof.c,v 1.1 2009/07/05 10:37:54 sms Exp $ * www.pccl.demon.co.uk * * Program to display data sizes. */ #include <stdio.h> #define printsize(x) printf ("sizeof (" #x ") = %d\n", sizeof (x)) main () { printf ("\nNormalprintf\n"); printsize (char); printsize (double); printsize (float); printsize (int); printsize (long); printsize (long long); printsize (long double); printsize (short); printsize (void *); printsize (int *); } Prepared by MMD, Edited by MSY

  27. Sizeof(): Example - Output Normal printf sizeof (char) = 1 sizeof (double) = 8 sizeof (float) = 4 sizeof (int) = 4 sizeof (long) = 4 sizeof (long long) = 8 sizeof (long double) = 8 sizeof (short) = 2 sizeof (void *) = 4 sizeof (int *) = 4 Prepared by MMD, Edited by MSY

  28. Functions used in Memory Management Prepared by MMD, Edited by MSY

  29. SUMMARY • This chapter has exposed you about: • Pointer variables and parameter passing by reference/ pointers • The usage of symbol * and address operator (&) • Passing by pointers allows us to return multiple values from functions • How to use dynamic variables Prepared by MMD, Edited by MSY

More Related