int x, y, *z;
x = 1;
y = x * 2;
z = &x;
x = y * 2;
x is
y is
*z is
int mystery(int y) {
y = 6;
return y*y;
}
int main(void) {
int x, ret, *ptr;
ptr = &x;
x = 34;
ret = mystery(x);
return 0;
}
mystery?x in the main function remains unchanged.ret not x!int mystery2(int *p) {
*p = 13;
return (*p + 6);
}
int main(void) {
int x, ret, *ptr;
ptr = &x;
x = 34;
ret = mystery2(ptr);
return 0;
}
mystery2?p is a pointer to x, it modifies the value of x in main’s stack frame.#include <stdio.h>
int change_string(char *a, char *b);
int main(void) {
char alpha, beta;
alpha = 'a';
beta = 'b';
change_string(&alpha, &beta);
printf("alpha: %c beta: %c\n", alpha, beta);
return 0;
}
int change_string(char *a, char *b) {
b = a;
// draw the stack here
return 0;
}
change_string returns (at the // draw the stack here point). Answer appears in the "Answer" box below.a and b in the change_string function contain the addresses of alpha and beta respectively. When the statement b = a executes in the change_string function, b is updated to contain the address of of alpha. However, this pointer reassignment does not actually update either the values of alpha or beta. Therefore, the values in the main function remain unchanged.
calculate in main.calculate(a, b, &sum, &product);swap below that attempts to swap the values of two character variables. If either parameter to swap is NULL, the function should return 1. Otherwise, the values pointed to by a and b should be swapped and the function should return 0.alpha: b beta: aThe retun value is: 0alpha and beta, we must dereference a and b inside of swap.diveintosystems.org/book/C2-C_depth/_attachments/ex_passbypointer.c#include <stdio.h>
int arg_modifier(int x, int *y);
int main(void) {
int val1, val2, ret;
printf("Enter a value: ");
scanf("%d", &val1);
printf("Enter another value: ");
scanf("%d", &val2);
// pass val1 by value and val2 by pointer:
printf("before call: val1 = %d val2 = %d\n", val1, val2);
ret = arg_modifier(val1, &val2);
printf("after call: val1 = %d val2 = %d ret = %d\n", val1, val2, ret);
/*
* uncomment to test passing val2 by value and val1 by pointer
*/
//printf("before 2nd call: val1 = %d val2 = %d\n", val1, val2);
//ret = arg_modifier(val2, &val1);
//printf("after 2nd call: val1 = %d val2 = %d\n", val1, val2);
return 0;
}
/*
* This function illustrates C-style pass by pointer semantics, the
* argument pointed to by the second parameter, y, will be modified
* after the call, the value of the first argument, x, will not.
*/
int arg_modifier(int x, int *y) {
printf(" in arg_modifier: x = %d *y = %d\n", x, *y);
/* the location y points to gets (value of what y points to + x) */
*y = *y + x;
x = x + 5;
printf(" leaving arg_modifier: x = %d *y = %d\n", x, *y);
return x;
}
ex_passbypointer.c), compile and run it a few times to understand its behavior and the semantics of pass-by-pointer. You can uncomment the second call in main that passes the local variables in different order as arguments to the function.Enter a value: 100
Enter another value: 200
before call: val1 = 100 val2 = 200
in arg_modifier: x = 100 *y = 200
leaving arg_modifier: x = 105 *y = 300
after call: val1 = 100 val2 = 300 ret = 105
arg_modifier function, entering the values 5 and 2. Draw the stack at the point in the execution right before the return from the arg_modifier function, and consider the following questions:val1 and val2 located on the stack?arg_modifier returns. Parameter y receives the value of the address of val2 (y points to val2). By dereferencing y, it accesses the value stored in val2 -- the statement *y = *y + x; changes the value pointed to by y from 2 to 7.
val1 and val2 are located in main’s stack framey gets the value of the second argument (the address of val2), x gets the value of the first argument (the int value stored in val1)
