Trying to understand functions with pointers in C - c

Question

#include <stdio.h>
void set_flag(int* flag_holder, int flag_position){
*flag_holder |= (1 << flag_position);
}
void set_flag(int* flag_holder, int flag_position);
int main(int argc, char* argv[])
{
int flag_holder = 0;
int i;
set_flag(&flag_holder, 3);
set_flag(&flag_holder, 16);
set_flag(&flag_holder, 31);
I am confused one what the following does? I think its calling for the pointer that is within void set_flag(), what I am not sure if it is then setting that value to 3,then 16 then 31?
set_flag(&flag_holder, 3);
set_flag(&flag_holder, 16);
set_flag(&flag_holder, 31);

Answer 1

Let's get rid of the bitwise stuff and just focus on the pointers.
void set_flag(int* flag_holder, int flag_position) {
*flag_holder = flag_position;
}
The purpose of this function is to change a caller's variable. You call it like so:
int *flag;
set_flag(&flag, 5); // flag is now 5
& makes a pointer, * turns a pointer back into what it's pointing at.
flag_holder is a pointer to an integer, it's the integer's location in memory, some 32 or 64 bit number. flag_position is a regular integer.
If set_flag tried flag_holder = flag_position that says say "please point flag_holder at memory location 5" and most likely the computer would say "no, you can't do that, that's not your memory" and crash the program.
Instead it has to say "change the number that you're pointing at to equal 5" which is *flag_holder = flag_position.

Answer 2

The caller is passing the address of an integer. The callee is dereferencing the address passed in to assign a new value to that integer. The reason the address is passed instead of the value directly is so the subroutine can modify the integer.
The new value happens to be based on the old value plus flipping individual bits on, depending on what is passed. But this is really a separate question from the subject line of your post.

Answer 3

The set_flag() function is using bitwise operators to manipulate the value of flag_holder at bit-level.
The bitwise OR | operator can be used to set an individual bit. A similar technique used to set flags is:
#define flag1 0x01
#define flag2 0x02
#define flag3 0x04
#define flag4 0x08
#define flag5 0x10
... you get the idea.
We can then use the OR operator to set an individual bit:
char flags = 0;
flags |= flag1
If you think of the values of the flags in terms of binary - imagine:
flag1 = 00000001
flag2 = 00000010
flag3 = 00000100
flag4 = 00001000
You get the idea! The OR operator will copy any bits that are set in the rvalue over to the lvalue, effectively setting a bit or flag.
So doing flags |= (flag1 | flag3) would result in our flags:
flags 00000101
We can use something like this to specify whether a particular option was specified.
Your example uses a different technique, it always applies the bit-shifted value of 1...think of this like in the example above where 0x01 == 00000001
If we shift 00000001 << 1 time we get 00000010.
Your set_flag() function is accepting a pointer to an int meaning it can change the value of flag_holder and the second parameter is specifying how many places to shift 1 to the left and isolate a particular bit.
you should read about bitwise operators they're bags of fun.

Answer 4

The & gets the address of the variable it is applied to, and * gets the value at the address provided by the pointer.
In the function declaration int * declares the argument to be a pointer, the address of an integer. Then within the function the value is obtained modified and written back to the given address.
When you pass the address of flag_holder in main, it is the value at this address that is modified inside set_flag(...).

Answer 5

The function set_flag takes 2 arguments:
int* - a pointer to an int
an integer value
Then it does some bitwise OR operations on the data.
So in your example you have flag_holder = 0 as the first value, and 3, 16 and 31 as second values. This results in (assuming 32bit int):
flag_holder = 00000000 00000000 00000000 00000000 = 0 in binary
(1 << 3) = 00000000 00000000 00000000 00001000 = 1 left shifted by 3
OR result = 00000000 00000000 00000000 00001000 = result of | binary operation
Another example if you would have another value for flag_holder:
flag_holder = 00000000 00010000 00001000 10000001
(1 << 3) = 00000000 00000000 00000000 00001000
OR result = 00000000 00010000 00001000 10001001