xxxxxxxxxx
#include<stdio.h>
/*
'*' is the dereference operator; it will grab the value at a memory address.
it is also used to declare a pointer variable.
'&' is the address-of operator; it will grab the memory address of a variable.
*/
int main(int argc, char *argv[]) {
int x = 45; // Declare integer x to be 45.
int *int_ptr = &x; // int_ptr now points to the value of x. Any changes made to the value at int_ptr will also modify x.
x = 5; // Now, the value of x is 5. This means that the value at int_ptr is now 5.
*int_ptr = 2; // Now, the value at int_ptr is 2. This means that x is now 0.
int_ptr = NULL; // int_ptr now no longer points to anything. Make sure you never leave a dangling pointer!
return 0;
}
xxxxxxxxxx
#include <stdio.h>
int main()
{
int j;
int i;
int *p; // declare pointer
i = 7;
p = &i; // The pointer now holds the address of i
j = *p;
printf("i = %d \n", i); // value of i
printf("j = %d \n", j); // value of j
printf("*p = %d \n", p); // the address held by the pointer
*p = 32; // asigns value to i via the pointer
printf("i = %d \n", i); // value of i
printf("j = %d \n", j); // value of j
printf("*p = %d \n", p); // the address held by the pointer
printf("&i = %d \n", &i); // address of i
return 0;
}
xxxxxxxxxx
datatype *var;
variable var actually holds the address of the data(memory where it is stored)
*var lets you access the data stored at that address
xxxxxxxxxx
#include <stdio.h>
#include <stdlib.h>
int main()
{
int *ptr, i , n1, n2;
printf("Enter size: ");
scanf("%d", &n1);
ptr = (int*) malloc(n1 * sizeof(int));
printf("Addresses of previously allocated memory: ");
for(i = 0; i < n1; ++i)
printf("%u\n",ptr + i);
printf("\nEnter the new size: ");
scanf("%d", &n2);
// rellocating the memory
ptr = realloc(ptr, n2 * sizeof(int));
printf("Addresses of newly allocated memory: ");
for(i = 0; i < n2; ++i)
printf("%u\n", ptr + i);
free(ptr);
return 0;
}
xxxxxxxxxx
#include<stdio.h>
#include<stdlib.h>
main()
{
int *p;
p=(int*)calloc(3*sizeof(int));
printf("Enter first number\n");
scanf("%d",p);
printf("Enter second number\n");
scanf("%d",p+2);
printf("%d%d",*p,*(p+2));
free(p);
}
xxxxxxxxxx
#include <stdio.h>
int main()
{
int* pc, c;
c = 22;
printf("Address of c: %p\n", &c);
printf("Value of c: %d\n\n", c); // 22
pc = &c;
printf("Address of pointer pc: %p\n", pc);
printf("Content of pointer pc: %d\n\n", *pc); // 22
c = 11;
printf("Address of pointer pc: %p\n", pc);
printf("Content of pointer pc: %d\n\n", *pc); // 11
*pc = 2;
printf("Address of c: %p\n", &c);
printf("Value of c: %d\n\n", c); // 2
return 0;
}
xxxxxxxxxx
#include <stdio.h>
int main()
{
int *p;
int var = 10;
p= &var;
printf("Value of variable var is: %d", var);
printf("\nValue of variable var is: %d", *p);
printf("\nAddress of variable var is: %p", &var);
printf("\nAddress of variable var is: %p", p);
printf("\nAddress of pointer p is: %p", &p);
return 0;
}
#output
#Value of variable var is: 10
#Value of variable var is: 10
#Address of variable var is: 0x7fff5ed98c4c
#Address of variable var is: 0x7fff5ed98c4c
#Address of pointer p is: 0x7fff5ed98c50
xxxxxxxxxx
#include <stdio.h>
int main () {
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
ip = &var; /* store address of var in pointer variable*/
printf("Address of var variable: %x\n", &var );
/* address stored in pointer variable */
printf("Address stored in ip variable: %x\n", ip );
/* access the value using the pointer */
printf("Value of *ip variable: %d\n", *ip );
return 0;
}
xxxxxxxxxx
// Variable declaration
type var;
// Get the address (a pointer to) a variable
// &var -> type*
// Pointer declaration(s)
type* ptr_a;
type* ptr_b;
// Change what pointer is pointing to
ptr_a = &var;
ptr_b = ptr_a;
// Can declare and assign in 1 line
type* ptr_c = &var;
type* ptr_d = ptr_c;
// "Pointers" are also variables
// &ptr_d -> type**
type** ptr_e = &ptr_d;
// Getting values from pointers
// *ptr_d -> type
// *ptr_e -> type*
type value = *ptr_d;
*(arr + 2)
xxxxxxxxxx
We declare the following variable
int arr[5];
What is the equivalent of typing arr[2]?