Solution

#include<stdio.h>

void xy (int x, int y) { // value of x=0, y=2

int *ptr;

x = 0; // value of x=0, y=2

ptr = &x; // ptr is pointing to x, i.e. value pointed by ptr is 0

y = *ptr; // value pointed by ptr is assigned to y, hence y = 0 now, x=0

*ptr = 2; // value pointed by ptr is replaced by 2. Hence x=2, y=0

printf("%d,%d",x,y); // 2,0

}

Solution

typedef int (*fun)(int);

This is a definition of a function type. It makes (*fun)(int) an alias for the type that can be described as "function returning int with an argument of type int".

While assigning any function to function pointer, & is optional. Same way, while calling a function via function pointer, * is optional.

Solution

For arrays, we can convert array subscript operator [] to pointer deference operator * with proper offset.

It means that arr[x] is equal to *(arr+x).

Basically, these two are interchangeable.

The same concept can be applied in multi-dimensional arrays as well.

All the printf are equivalent to each other and points the same arr[2][2][2]

Solution

Some facts about Function pointer:

Unlike normal pointers, a function pointer points to code, not data. Typically a function pointer stores the start of executable code.

Unlike normal pointers, we do not allocate de-allocate memory using function pointers.

Solution

int *(*func())();

Let’s check using precedence

*(*func())(); // because of parenthesis, this will be solved first.

*func() // () have higher precedence over * hence func() is a function. And func is a function which returns a pointer.

*(X)() …….. Here, lets assume X = *func()

// Again () has higher precedence than * and hence “func is function returning pointer to function returning pointer to”

Finally the data type is int hence “func is function returning pointer to function returning pointer to int"

Solution

void (*p[2])(int*, int);

This statement could be decoded as, innermost bracket first - p is an array of two pointers, then the outer - pointing to functions with input arguments as int * and int, and finally return type - returns void or nothing.

Let’s check with precedence:

(*p[2])(int*, int) // according to brackets this has highest priority

(*p[2])(int*, int) // These brackets means function taking parameters

void (*p[2])(int*, int); // Function type is void

*p[2] // [] has higher precedence over *, hence p is an array of pointer. 2 pointer because array size was 2.

Solution

In C, though there are three members of structure,only one is initialized , Then remaining two members are initialized with Zero

Solution

/*Output:

prog.c: In function 'main':

prog.c:10:7: error:

invalid operands to binary + (have 'struct number' and 'struct number')

n3=n1+n2;

*/

The C structure does not allow the struct data type to be treated like built-in data types:

We cannot use operators like +,- etc. on Structure variables.

Solution

/* below line changes value of c to 5. Note that x remains unaffected by

this change as x is a copy of c and address of x is different from c*/

**ppz += 1

/* z is changed to 5*/

z = **ppz;

/* changes c to 7, x is not changed */

*py += 2;

/* y is changed to 7*/

y = *py;

/* x is incremented by 3 */

x += 3;

/* return 7 + 7 + 5*/

return x + y + z;

Solution

char *first[]

Here, s is an array of pointers (as precedence of [] is higher) to char, and so it can accept an array of addresses to characters (char arrays) as initializer list. Here, the size of this array is 4. Let me now explain using the given code snippet.

char *first[]={"Gokulan","raudra","girish","anand"};

first[0] = W;

//where W is the address where "Gokulan" is stored

similarly,

first[1] = X, first[2] = Y, first[3] = Z;

char **second[]={(first+3),(first+2),(first+1),(first+0)};

second[0] = first[3], second[1] = &Y, second[2] = &X, second[3] = &W

char ***third=second; //starting address

//where &Z,&Y,&X and &W are stored sequentially

printf("%s",**++third);

Here ++ and * has same precedence but because of right to left associativity ++ happens first

//++third = third + sizeof(& char ***)

//= third + sizeof(char **)

//= address where &Y is stored

//In other words: third => second [0], After this; //++third => second[1] => first[2] => &y

//** means accessing first[2]

//**++third will give Y = "girish"

printf("%s",*--*++third+3);

Here ++, -- , * must be evaluated as right to left associativity.

//++third will have address where &X is stored (&second[2])

//*++third will give &X

//--*++third will give &W

//*--*++third will give W = "Gokulan"

//*--*++third+3 = "ulan"

//As the first 2 printf executed third will start pointing to "raudra" now and "anand" anymore.

printf("%s",third[-1][-1]+1);

//third[-1] = *(third-1) = address where &X is stored - 1

// = address where &Y is stored

// third[-1][-1] = *(*(third-1)-1)

// = *(&Y -1) = *&X = X = "raudra"

// third[-1][-1]+1 = X+1 = "audra

So, output will be ,girishulanaudra

Solution

fun1() prints the given Linked List in reverse manner. For Linked List 1->2->3->4->5, fun1() prints 5->4->3->2->1.

Solution

#include<stdio.h>

int main(void)

{

int r=10;

int *q = &r;

int **rq = &q;

printf("facts=========================\n");

printf("Value of r and address of r is : %d %u\n",r,&r);

printf("Value of q and address of q is : %d %u\n",q,&q);

printf("Value of rq and adess of rq is : %d %u\n",rq,&rq);

printf("--------------------------------\n");

printf("value of r => r=%d, *q=%d **rq=%u\n",r,*q,**rq);

printf("addr of r => &r=%u, q=%u *rq=%u\n",&r,q,*rq);

printf("Value of q => q=%u, *rq=%u\n",q,*rq);

printf("addre of q => &q=%u, rq=%u\n", &q,rq);

printf("Value of rq=> rq=%u\n",rq);

printf("Addre of rq=> &rq=%u\n",&rq);

}

Output:

facts=========================

Value of r and address of r is : 10 139666548

Value of q and address of q is : 139666548 139666552

Value of rq and adess of rq is : 139666552 139666560

--------------------------------

value of r => r=10, *q=10 **rq=10

addr of r => &r=139666548, q=139666548 *rq=139666548

Value of q => q=139666548, *rq=139666548

addre of q => &q=139666552, rq=139666552

Value of rq=> rq=139666552

Addre of rq=> &rq=139666560

Solution

An array is the data structure that contains a collection of similar type data elements whereas the Linked list is considered as a non-primitive data structure containing a collection of unordered linked elements known as nodes.

In the array the elements belong to indexes, i.e., if you want to get into the fourth element you have to write the variable name with its index or location within the square bracket.

In a linked list though, you have to start from the head and work your way through until you get to the fourth element.

Accessing an element in an array is fast, while Linked list takes linear time, so it is quite a bit slower.

Solution

Consider the same code with different variable names

/* Given a reference (pointer to pointer) to the head of a list

and an int, inserts a new node on the front of the list. */

void fun(struct Node** head_ref, int new_data)

{

/* 1. allocate node */

struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));

/* 2. put in the data */

new_node->data = new_data;

/* 3. Make next of new node as head */

new_node->next = (*head_ref);

/* 4. move the head to point to the new node */

(*head_ref) = new_node;

}

Hence the fun function is nothing but a push function which inserts a node in the starting of the linked list.

Solution

/* Counts the no. of occurrences of a node

(search_for) in a linked list (head)*/

int getCount(struct Node* head)

{

// Base case

if (head == NULL)

return 0;

// count is 1 + count of remaining list

return 1 + getCount(head->next);

}

Consider a linked list of length 3:

1 -> 2 -> 3 -> NULL

^

head

First call will be in main function getCount(head),

after that getCount(1) => 1 + getCount(2) => 1 + 2 = 3

after that getCount(2) => 1 + getCount(3) => 1 + 1 = 2

after that getCount(3) => 1 + getCount(NULL) => 1+ 0 = 1

after that getCount(NULL) => return 0 => 0