UploadLanguage (EN)Support
BusinessMobileSocial MediaMarketingTechnologyArt & PhotosCareerDesignEducationPresentations & Public SpeakingGovernment & NonprofitHealthcareInternetLawLeadership & ManagementAutomotiveEngineeringSoftwareRecruiting & HRRetailSalesServicesScienceSmall Business & EntrepreneurshipFoodEnvironmentEconomy & FinanceData & AnalyticsInvestor RelationsSportsSpiritualNews & PoliticsTravelSelf ImprovementReal EstateEntertainment & HumorHealth & MedicineDevices & HardwareLifestyle
Upload
Sign in
Osmania University, profile picture
Uploaded byOsmania University
PPT, PDF118 views

pointers (1).ppt

Pointer Basics - Variables are stored in memory locations with addresses. A pointer variable stores the address of another variable. - Pointer variables are declared with a type followed by an asterisk (e.g. int *ptr). They can be initialized by using the address of operator (&) on a variable of the correct type. - The indirection operator (*) is used to access the value stored at the address a pointer points to. Pointer arithmetic and pointer comparisons are also allowed. Arrays and strings can be accessed and manipulated using pointers. Null pointers indicate a pointer does not point to a valid memory location.

Engineering◦
Download to read offline
1 / 57
2 / 57
Most read
3 / 57
4 / 57
5 / 57
Most read
6 / 57
7 / 57
8 / 57
9 / 57
10 / 57
11 / 57
12 / 57
13 / 57
14 / 57
Most read
15 / 57
16 / 57
17 / 57
18 / 57
19 / 57
20 / 57
Pointer Basics Variables are allocated at addresses in computer memory (address depends on computer/operating system) Name of the variable is a reference to that memory address A pointer variable contains a representation of an address of another variable (P is a pointer variable in the following): 101 V P Name Abstract Representation Concrete Representation Address 4 bytes for int value 101 4 bytes for mem address v v (some value) p (some value) int V = 101; int *P = &V;
Pointer Variable Definition Basic syntax: Type *Name Examples: int *P; /* P is var that can point to an int var */ float *Q; /* Q is a float pointer */ char *R; /* R is a char pointer */ Complex example: int *AP[5]; /* AP is an array of 5 pointers to ints */ – more on how to read complex declarations later
Address (&) Operator The address (&) operator can be used in front of any variable object in C -- the result of the operation is the location in memory of the variable Syntax: &VariableReference Examples: int V; int *P; int A[5]; &V - memory location of integer variable V &(A[2]) - memory location of array element 2 in array A &P - memory location of pointer variable P
Pointer Variable Initialization/Assignment NULL - pointer lit constant to non-existent address – used to indicate pointer points to nothing Can initialize/assign pointer vars to NULL or use the address (&) op to get address of a variable – variable in the address operator must be of the right type for the pointer (an integer pointer points only at integer variables) Examples: int V; int *P = &V; int A[5]; P = &(A[2]);
Indirection (*) Operator A pointer variable contains a memory address To refer to the contents of the variable that the pointer points to, we use indirection operator Syntax: *PointerVariable Example: int V = 101; int *P = &V; /* Then *P would refer to the contents of the variable V (in this case, the integer 101) */ printf(“%d”,*P); /* Prints 101 */
Working with Pointers In order to work with pointers, do the following: • Declare a pointer variable • Initialize it. • Access the original value through a pointer or perform any other operation on it.
Pointer Declaration • In C, every variable must be declared for its type. • Since pointer variables contain addresses that belong to a separate data type, they must be declared as pointers before we use them. • The general format of format declaration is – datatype *pt_name; • This tells the compiler three things about the variable pt_name 1. The asterisk (*) tells that the variable pt_name is a pointer variable. 2. pt_name needs a memory location. 3. pt_name points to variable of type data type. Example: int *ptr; This declaration tells that the variable points to an integer data type.
INITIALIZING POINTERS: • Once a pointer variable has been declared, it can be made to point a variable using an assignment statement such as – int i=10,*ptr; ptr=&i; – or int *ptr=&i; • Which causes ptr to point to i. That is, ptr now contains the address of i. • Note: A pointer declared of one data type cannot point to variable of another data type.
ACCESSING A VARIABLE THROUGH ITS POINTER • Once a pointer has been assigned the address of a variable, we can access the value of the variable using this pointer. • This is done by using another unary operator *(asterisk), known as the indirection operator.
Example
Example
Pointer Arithmetic Valid operations on pointers are:  Assignment of pointers  Adding or subtracting a pointer and integer  Subtracting two pointers  Comparing two pointers  Incrementing or decrementing the pointers  Assigning the value 0 to the pointer. Invalid operations on pointers are:  Addition, Multiplication, Division of two pointers  Multiplication, Division of pointer with a number
Example: Assignment & Comparision of Pointers
Example: Adding or subtracting a pointer and integer
Example: Subtracting two pointers
Example: Subtracting two pointers
Example: Incrementing or decrementing the pointers
Invalid operations on pointers • There are various operations which can not be performed on pointers. Since, pointer stores address hence we must ignore the operations which may lead to an illegal address, for example, addition, and multiplication. A list of such operations is given below. • Address + Address = illegal • Address * Address = illegal • Address % Address = illegal • Address / Address = illegal • Address & Address = illegal • Address ^ Address = illegal • Address | Address = illegal • ~Address = illegal
Pointer to Pointer(Double pointer) • In C, we can also define a pointer to store the address of another pointer. Such pointer is known as a double pointer (pointer to pointer). • The first pointer is used to store the address of a variable whereas the second pointer is used to store the address of the first pointer.
Example
Array of Pointers • The way there can be an array of ints or an array of floats, similarly there can be an array of pointers. • Since a pointer variable always contains an address, an array of pointers would be nothing but a collection of addresses. • The general format of declaring array of pointers is as follows • datatype *arr_name[sz]; • Example: int *arr[5]; • This indicates arr is the array which consists of pointers point to integer data type.
Example
Example
Pointers & Arrays • You can also use pointers to access arrays.
How Are Pointers Related to Arrays In C, the name of an array, is actually a pointer to the first element of the array. This basically means that we can work with arrays through pointers! How? Since myNumbers is a pointer to the first element in myNumbers, you can use the * operator to access it:
• To access the rest of the elements in myNumbers, you can increment the pointer/array (+1, +2, etc): • Or loop through it.
• It is also possible to change the value of array elements with pointers:
Example
Pointers and Strings #include<stdio.h> int main() { char arr[10]=“Hyderabad"; char *s=&arr; printf("%sn",arr); printf("%sn",s); printf("%pn",arr); printf("%pn",s); return 0; } Hyderabad Hyderabad 000000000062FE00 000000000062FE00
Null Pointer • A Null Pointer is a pointer that does not point to any memory location. It stores the base address of the segment. The null pointer basically stores the Null value while void is the type of the pointer. • A null pointer is a special reserved value which is defined in a stddef header file. Here, Null means that the pointer is referring to the 0th memory location. • If we do not have any address which is to be assigned to the pointer, then it is known as a null pointer. • When a NULL value is assigned to the pointer, then it is considered as a Null pointer.
Applications of Null Pointer • It is used to initialize o pointer variable when the pointer does not point to a valid memory address. • It is used to perform error handling with pointers before dereferencing the pointers. • It is passed as a function argument and to return from a function when we do not want to pass the actual memory address.
Generic Pointer • The void pointer in C is a pointer which is not associated with any data types. It points to some data location in the storage means points to the address of variables. • It is also called general purpose pointer. In C, malloc() and calloc() functions return void * or generic pointers. It has some limitations − • 1) Pointer arithmetic is not possible with void pointer due to its concrete size. • 2) It can’t be used as dereferenced.
Example
Passing Pointer to Function Call by Reference • In call by reference, the address of the variable is passed into the function call as the actual parameter. • The value of the actual parameters can be modified by changing the formal parameters since the address of the actual parameters is passed. • In call by reference, the memory allocation is similar for both formal parameters and actual parameters. All the operations in the function are performed on the value stored at the address of the actual parameters, and the modified value gets stored at the same address.
Example
Example
Example: Call by Value
Difference between Call by Value and Call by Reference
Accessing Structure using Pointer • Pointer pointing to a structure variable is called a structure pointer, and structures and pointers in C together can be used to access and change the values of members of the structure they are pointing. • Declaring a structure pointer is similar to the declaration of a structure variable. To declare a structure pointer struct keyword is used followed by the structure name and pointer name with an asterisk * symbol. • Members of a structure can be accessed from pointers using two ways that are. – Using dot and asterisk operator on a pointer. – Using arrow operator (->) on a pointer.
Example
Self referential structures • Same structure name is referred inside the structure or a structure refer itself is known as self-referential structure. • A self-referential structure is one which contains a pointer to its own type. • Ex. struct student { int rno; char name[50]; struct student *p; }s1;
Example
Memory allocation for variable is two types. – Static memory allocation. – Dynamic memory allocation. Static memory allocation (SMA) :- The process of allocating memory to variables at compile time is called SMA (or) compile time allocation. • Ex: – int a[10]= {10,20,30}; – float b[5]={0.5,1.1};
Advantages of Static memory allocation – Simplicity of usage. – Efficient execution time. – Need not worry about memory allocation/re- allocation/freeing of memory – Variables remain permanently allocated. Disadvantages of Static memory allocation – Main disadvantage is wastage of memory. – Memory can't be freed when it is no longer needed.
Dynamic memory allocation (DMA) :- the process of allocating memory to variables at the runtime is called DMA (or) runtime allocation. The concept of dynamic memory allocation in c language enables the C programmer to allocate memory at runtime. Dynamic memory allocation in c language is possible by 4 functions of stdlib.h header file. – malloc() – calloc() – realloc() – free() malloc() allocates single block of requested memory. calloc() allocates multiple block of requested memory. realloc() reallocates the memory occupied by malloc() or calloc() functions. free() frees the dynamically allocated memory.
Dynamic memory allocation (DMA) :- the process of allocating memory to variables at the runtime is called DMA (or) runtime allocation. The concept of dynamic memory allocation in c language enables the C programmer to allocate memory at runtime. Dynamic memory allocation in c language is possible by 4 functions of stdlib.h header file. – malloc() – calloc() – realloc() – free() malloc() allocates single block of requested memory. calloc() allocates multiple block of requested memory. realloc() reallocates the memory occupied by malloc() or calloc() functions. free() frees the dynamically allocated memory.
static memory allocation & dynamic memory allocation static memory allocation dynamic memory allocation memory is allocated at compile time. memory is allocated at run time. memory can't be increased while executing program. memory can be increased while executing program. used in array. used in linked list.
• The malloc() function reserves a block of memory of the specified number of bytes. And, it returns a pointer of void which can be casted into pointers of any form. Syntax of malloc() – ptr = (castType*) malloc(size); Example – ptr = (float*) malloc(100 * sizeof(float)); • The above statement allocates 400 bytes of memory. It's because the size of float is 4 bytes. And, the pointer ptr holds the address of the first byte in the allocated memory. • The expression results in a NULL pointer if the memory cannot be allocated.
The name "calloc" stands for contiguous allocation. The malloc() function allocates memory and leaves the memory uninitialized, whereas the calloc() function allocates memory and initializes all bits to zero. Syntax of calloc() – ptr = (castType*)calloc(n, size); Example: – ptr = (float*) calloc(25, sizeof(float)); • The above statement allocates contiguous space in memory for 25 elements of type float.
free() • Dynamically allocated memory created with either calloc() or malloc() doesn't get freed on their own. You must explicitly use free() to release the space. Syntax of free() – free(ptr); • This statement frees the space allocated in the memory pointed by ptr.
realloc() • If the dynamically allocated memory is insufficient or more than required, you can change the size of previously allocated memory using the realloc() function. Syntax of realloc() – ptr = realloc(ptr, x); • Here, ptr is reallocated with a new size x.
Example using malloc() and free()
Example using calloc() and free()
Example using realloc()