learning c having trouble understanding pointers - c

Question

void
bar (char *arg, char *targ, int len)
{
int i;
for (i = 0; i < len; i++)
{
*targ++ = *arg++;
}
}
learning c right now, a friend sent me this snippet and I can't understand what it does. An explanation of the pointer portion would be helpful. From my understanding, it seems to be copying the value of arg into targ for i chars?

Answer 1

A pointer is a variable that stores an address. This address can be the address
of another variable:
int a = 18;
int *pa = &a;
or it can be the start of a dynamically allocated memory block:
int *p = malloc(sizeof *p);
The important thing is that pointers allow you access the values behind an
address. You do that by dereferencing the pointer using the *-operator:
int a = 18;
int *pa = &a;
*pa = 10;
printf("a=%d\n", a); // will print 10
For these kind of examples, this might not seem like a big deal, but it is,
because you can pass pointers to functions and those function can then interact
with the memory pointed to by the pointer, depending on the memory block, even
modifiy it.
Pointers can also point to the start of sequence of objects, for example to the
start of an array:
int arr[] = { 1, 3, 5 };
int *p = arr;
Note p[0] is 1, p[1] is 3 and p[2] is 5. It is also possible to change the
values by doing p[1] = -14;. This is also dereferencing, but you also can use the
*-operator:
p[1] = 12;
// is equivalent to
*(p + 1) = 12;
And that's what your snippet is using. Forget for a second the loop. Take a look
at this line:
*targ++ = *arg++;
This can be rewritten as:
targ[0] = arg[0];
targ = targ + 1; // or targ = &(targ[1])
arg = arg + 1; // or arg = &(arg[1])
Now it's more clear what it is doing. It copies the value of first character
pointed to by arg to the position where targ is pointing to. After that both
arg and targ are incremented to advance to the next element in the
sequence.1
So what the loop is doing is copying len objects pointed to by arg to
targ. This could be used to copy a string into another char array. But it is
not safe, as it is not clear whether the '\0'-terminating byte is is copied
and it is not clear whether the buffers are large enough (meaning larger than
len). If they are not strings but sequences of bytes, then this function would
be OK.
In C a string is just a sequence of characters that ends with the '\0'-terminating byte.
For that reason they are stored using char arrays and are passed to functions
as pointers of char, that point to the start of the string. We could rewrite
this function in a more safer way like this:
int safe_copy_string(char *dest, char *source, size_t dest_size)
{
if(dest == NULL || source == NULL)
return 0;
if(dest_size == 0)
return 1; // no space to copy anything
// copying one element less than dest_size
// that last element if dest should be \0
for(size_t i = 0; i < dest_size - 1; ++i)
{
*dest++ = *source++;
if(*(source - 1) == '\0')
break; // copied sources's 0-terminating byte
}
dest[dest_size - 1] = 0; // making sure it is 0-terminated
return 1;
}
Footenotes
1It's worth mentioning the ++-operator here. This is the post-increment
operator which is used to add 1 to the operand (for integers), in case of a pointer
to advance the pointer by 1 thus making it point to the next object.
When you do:
int a = 6;
int b = a++;
// a == 7, b == 6
a is initialized with 6. When initializing b, the compiler will use the
current value of a for the initialization, however the post-increment
operator has the side effect that it will increment the value of a by 1. When
this exactly happens is define by the rules of sequence points. What
matters is that in the initialization of b, the current value of a is used
and after the assignment a will have a the new value.

Answer 2

A pointer points to a data, and usually contains the memory address of the data. The pointer is a normal 'c' variable.
operator '*' applied at the time, when the pointer is used, tells the compiler to access data, at the location denoted by the pointer.
Operator '++', applied to the pointer, increments its value so, that it points to the next data element, adjacent to the previous one. So, for 'char*' pointers, it increments the address by '1' to point to the next char in the string.
In your case *targ++ means: access data referenced by the pointer 'targ' and then increment the value of the pointer.
*targ++ = *arg++;
In the above expression the program takes char pointed by 'arg' and assigns it to the char location referenced by 'targ'. Then it increments values of the pointers 'arg' and 'targ'.

Answer 3

Here is the function you provided, exploded with a line-by-line explanation of the function. At the end are revisions to make the function slightly safer.
This line declares the return type of the function. The type 'void' indicates that this function returns nothing (a procedure as opposed to a function).
void
This line declares the name of the function, 'bar', and then presents a list of three arguments, 'arg', 'targ', and 'len'. The types of these arguments are 'arg' is a pointer to a character, and is how you pass a string in C; 'targ' is also a pointer to a character, and again is how you pass a string in C; and 'len' is an int(eger).
bar (char *arg, char *targ, int len)
This symbol '{' indicates that the body of the function definition follows.
{
This line declares that 'i' is a variable of type 'int'(eger), and this variable has space reserved on the stack for the duration of the function.
int i;
This line declares a repetition loop using the 'for' keyword. Between the parenthesis appears three sub-parts: the first part contains initialization prior to loop start, and the variable 'i' is set to the value 0; The second part contains an expression that is evaluated to determine whether to continue the loop, in this case the expression 'i < len' is checked every pass through the loop, so the loop terminates when the value of i becomes greater than or equal to the value of 'len'; the third part contains an expression that is performed at the end of each loop pass.
for (i = 0; i < len; i++)
This line '{' opens a statement body for the for loop,
{
This line is where the interesting work of the function is performed. As explained above, the for loop will be executed once for each value of 'i' in the list (0,1,2,3, ... ,len-1), seriatim. Note that the loop ends when 'i' has the value 'len'. Refer to the function declaration line above, how the variables 'arg' and 'targ' are pointers to character? These lines de-reference these variables to access the pointer location(s).
Suppose the line were '*targ = *arg', then the R-value *arg would be the contents at the current location pointed at by 'arg', and the L-value '*targ' would be the current location pointed at by 'targ'. Where the character 'x' stored at '*arg', then 'x' would be copied to '*targ', overwriting the previous contents.
*targ++ = *arg++;
The '++' symbols after the pointers do not affect the characters pointed at by the pointers, but increment the pointers (due to precedence of the '*' and '++' operators). That one line could be rewritten as,
*targ = *arg;
arg++;
targ++;
This line '}' closes the statement body for the for loop,
}
This symbol '}' matches and closes the body of the function definition.
}
You should always check for valid arguments to functions. And you should check that values do not overrun their buffers. I have added a few statement to the function to make it more robust. As presented, the function behaves like 'memcpy', and does not care about terminated 'strings'; I have added 'endc' to detect string end.
char* //return the destination, for further processing, e.g. strlen()
bar (char *arg, char *targ, int len)
{
int ndx; //try searching for 'i' in a big source file sometime...
char endc; //temporary to detect null character, more like 'strncpy'
if( (!arg) || (!targ) || (len<1) ) return targ;
for (ndx = 0; ndx < len; ndx++)
{
endc = *targ++ = *arg++;
if( !endc ) break; //comment this out for 'memcpy' behavior
}
}
Some would say checking the length is not needed. That is true for simple functions, but complex functions may reveal that this habit is rewarding.