In C, the data you use in your programs will usually fall into one of the three basic categories: int, char and float. Data in C has no existence without an associated memory location labeled by an identifier, usually referred to as a variable (the term variable is a bit misleading, since it essentially means that it must always vary, but you can have constant variables - i.e. variables whose values do not vary). Considering this and C’s requirement for static typing, a variable declaration statement is required before data can be stored in a variable. This declaration statement usually takes the form of data-type var-name [= value], where the =value part may or may not be present. For example, the statement int a=1; declares a variable a which will store integer data and stores 1 in it. What this statment basically tells the C compiler is that it should allocate a block of memory large enough to store an integer and it will referred to as a. It is possible to obtain the address of this memory location using the & operator.
Listing: address.c
#include <stdio.h>
int main(int argc, char **argv)
{
int a=1;
printf("Address of a:: %p, Data in a:: %d\n", &a, a);
return 0;
}
When you compile and run the above program, you should see an output similar to the following:
Address of a:: 0x7fff0cadd1ac, Data in a:: 1
You should note that the exact value of this address is immaterial for us and it will definitely be different for you. Once you have this address, it is possibly to refer to this memory location without using the variable, a, by making use of the dereferencing operator, *.
Listing dereferencing.c
#include <stdio.h>
int main(int argc, char **argv)
{
int a=1;
int *ptr;
printf("Address of a:: %p, Data in a:: %d\n", &a, a);
ptr = &a;
*ptr = 2;
printf("Address of a:: %p, Data in a:: %d\n", ptr, a);
return 0;
}
When you compile and execute the above program, you will see an output similar to the following:
Address of a:: 0x7fff85a7f134, Data in a:: 1
Address of a:: 0x7fff85a7f134, Data in a:: 2
In the above program, we store the address of the variable a in the variable ptr (declared as an integer pointer variable) in the statement ptr=&a. Next, we use the dereferencing operator to change the integer stored at memory location to 2. Now, when we retrieve the data stored at a, we get back the new integer.
Pointers are variables themselves and hence you could use the & and * operators on them as well. For the purpose of this article, we will just be needing pointers to non-pointer variables.
The declaration statement int a=1 also includes an optional assignment operation. It is not mandatory to assign a value while declaring a variable. Thus, the above statement can be broken down to two statements:
int a;
a=1;
The second statement is an assignment statement and the = is known as the assignment operator. In C’s terminology, the term on the left hand side is called the lvalue and the term on the right hand-side is called the rvalue. The lvalue must itself be a memory location or an identifier identifying a valid memory location and must be capable of storing new data. Thus, a variable initially declared as a const cannot be used as a lvalue. The rvalue should itself be data of the same type as the lvalue or an expression which evaluates to it. (I hope to discuss lvalue and rvalue will be discussed in a later article.)
The main point to note here is that assignment is simply the copying of data on the right hand side into the memory location pointed to by the left hand side (either using a variable name or using the direct memory location by using the dereferencing operator). You can use the assignment operator on variables which store numbers and single characters. For arrays, except during declaration, you have to use specialized functions (in case of strings) or assign each a value to each element individually.
The next code listing illustrates assignment operation and presents a few other related ideas.
Listing: mut_data.c
/* Variables are by default mutable.
Two variables occupy different locations in memory even if
they may be storing the same data.
*/
# include <stdio.h>
int a = 1;
int main(int argc, char **argv)
{
int b;
/*Copy the value stored in a to b*/
b = a;
/* A no-op operation*/
2;
/* The & operator expects an 'lvalue' as an operand, and hence
the following statement will result in a compilation error.
*/
/*printf("Address of 2 %p\n", &2);*/
printf("Address of a: %p, Address of b: %p\n", &a, &b);
printf("a = %d b = %d \n",a,b);
/* Change value stored in the memory location identified as a.
*/
a = 2;
printf("Address of a: %p, Address of b: %p\n", &a, &b);
printf("a = %d b = %d \n",a,b);
return 0;
}
In the above program, we declare a as an integer variable and store the integer 1 in it. Next, we declare another integer variable b and assign it to a in a separate statement. As mentioned earlier, what this operation does is simply copy the contents of a into b. The data stored in a and b is now 1. The next statement in our program is 2; - is a valid primary expression, but since the result of this evaluation is not being stored, there is no way you are going to be able to refer to this particular 2 anywhere else in this program. Hence an attemp to retrieve the address of this particular 2 will result in compilation errors, because only lvalues have addresses. Next, we print the addresses of the variables a and b. As expected, each has a different address in memory, even though they have the same memory contents. Sample output:
Address of a: 0x601034, Address of b: 0x7fffb3a8565c
a = 1 b = 1
Next, we change the value stored in a to 2 which is visible in the next part of the output:
Address of a: 0x601034, Address of b: 0x7fffb3a8565c
a = 2 b = 1
The above output establishes that even though, b was originally a copy of a (storing the same data), in case of any changes to the “original” variable, any of its copies do not see the changes. Each of these variables are completely isolated from each other. With this idea, we proceed to discuss the semantics of call by value and call by reference while passing data as function parameters. However, before we can discuss this, we will learn about the base address of an array.
An array (say, declared as int a[10]) is an instruction to the compiler that a block of memory for storing 10 integers should be allocated and identified by a, with individual items being addressed as a[0], a[1]...a[9] (and 0,1,.. known as the indices). The operation, &a[0] returns the address of the first element of this array.
Now, what does the compiler understand when we simply ask it do something like this printf("%d", *a)? In case of an array variable, when we use only the variable name (without an index), it refers to the address of the the element, a[0]. That is, &a[0]. Thus printf("%d", *a) is actually printf("%d", *(&a[0])). We will refer to the address of the first element of an array as its base address to aid the rest of the discussion.
Consider the next listing: nomod_parameter.c:
# include <string.h>
# include <stdio.h>
void func(int a, char string1[], char string2[])
{
char string3[15];
/* Create a copy of string2 in string3*/
strcpy(string3, string2);
printf("Before modification in func()\n");
printf("Address of a: %p \n", &a);
printf("Address of string1: %p \n", &string1[0]);
printf("Address of string2: %p \n", &string2[0]);
printf("Address of string3: %p \n", &string3[0]);
printf("a = %d \nstring1 = %s \nstring2 = %s\n",a, string1,
string3);
/* Make modifications */
a = a+1;
string1[0] = string1[0] + 5;
string3[0] = string3[0] + 5;
printf("After modification in func()\n");
printf("Address of a: %p \n", &a);
printf("Address of string1: %p \n", &string1[0]);
printf("Address of string2: %p \n", &string2[0]);
printf("Address of string3: %p \n", &string3[0]);
printf("a = %d \nstring1 = %s \nstring2 = %s\n",a, string1,
string3);
return;
}
int main(int argc, char **argv)
{
int a = 5;
char string1[] = "A String";
char string2[] = "B String";
printf("Before call to func()\n");
printf("Address of a: %p \n", &a);
printf("Address of string1: %p \n", &string1[0]);
printf("Address of string2: %p \n", &string2[0]);
printf("a = %d \nstring1 = %s \nstring2 = %s\n",a, string1,
string2);
func(a, string1, string2);
printf("After call to func()\n");
printf("Address of a: %p \n", &a);
printf("Address of string1: %p \n", &string1[0]);
printf("Address of string2: %p \n", &string2[0]);
printf("a = %d \nstring1 = %s \nstring2 = %s\n",a, string1,
string2);
return 0;
}
In the main() function, we declare an integer variable, a and two character arrays (strings), string1 and string2. When you compile and run this program, you will see four “sets” of output: Before call to func(), Before modification in func(), After modification in func() and After call to func(). First, I will discuss the first two sets:
Before call to func()
Address of a: 0x7fff6549ad7c
Address of string1: 0x7fff6549ad70
Address of string2: 0x7fff6549ad60
a = 5
string1 = A String
string2 = B String
Before modification in func()
Address of a: 0x7fff6549ad2c
Address of string1: 0x7fff6549ad70
Address of string2: 0x7fff6549ad60
Address of string3: 0x7fff6549ad30
a = 5
string1 = A String
string2 = B String
The key thing to note in the above output is the addresses of the three variables. (We discuss string3 a little later on, so ignore it for now).
You can see that the address of a is different in main() and in func() functions. This is because, the function func() is creating a new variable a to store the value being passed to it from the main() function (it is immaterial that we are using the same variable name in both the same functions - each of these variables are local variables, having no existence beyond the functions themselves). This is what is referred to as call by value - a copy of the value in a variable is passed from the calling function to the called function.
The addresses of the two character array variables are however the same in both the functions. This automatically follows from the discussion on base address of an array. When the function func() is called from main(), passing the array variables, string1 and string2 mean that we are passing the base address of each these arrays to the function, func(). Hence, the two variables string1 and string2 in func(), actually refer to the same memory location as string1 and string2 in main() (Once again, the same variable names is irrelevant).
Now, we consider the next set of output:
After modification in func()
Address of a: 0x7fff6549ad2c
Address of string1: 0x7fff6549ad70
Address of string2: 0x7fff6549ad60
Address of string3: 0x7fff6549ad30
a = 6
string1 = F String
string2 = G String
We make some changes to the data stored in each of the three variables and this is reflected in their changed values.
Finally, consider the last set of output:
After call to func()
Address of a: 0x7fff6549ad7c
Address of string1: 0x7fff6549ad70
Address of string2: 0x7fff6549ad60
a = 5
string1 = F String
string2 = B String
In the main() function, the data stored in a is the same as it was before the call to func(), the data stored in string1 is same as after the modification in func() and that of string2, the same as it was before calling func().
From the first set of output, we know that the variable a in func() was a separate variable from the a in main() and thus any changes made to the data stored in former will not be reflected in the latter. From the same set of output, we also know that string1 in func() pointed to the same string1 in main() and hence any changes made to it is reflected in the latter. So, what’s happening with string2()? The reasoning about string1 should also apply to string2, and it does. However, the difference in the output is due to the statement: strcpy(string3, string2) in func(). In this statement, we are creating a copy of the data in string2 and storing it in a new variable string3. Since string3 is a new variable (as demonstrated by the different address) as seen in the above sets of output, any changes to the value of string3 is not reflected in string2. In fact, you may call this as cheating when I printed the data in string3 and as that in string2. I did this to demonstrate a use case where you may need to change the value of an array parameter without changing the original array.
This form of calling a function where the addresses (or references) to the parameters are sent from the calling function to the called function is referred to as call by reference. Thus, we can conclude that when arrays are passed, it is by default a call by reference, where as for data types such as int, char and value, it is call by value.
As we have seen, we get call by reference for free in the case of arrays. How do accomplish this for int, for example? The key is to pass the address of the variable from the calling function to the called function. The next code listing demonstrates this.
# include <string.h>
# include <stdio.h>
void func(int *a, char *string)
{
printf("In func()\n");
printf("Address of a: %p \n", a);
printf("Address of string: %p \n", &string[0]);
printf("a = %d string = %s\n\n",*a, string);
/* Make modifications */
*a = *a+1;
string[0] = string[0] + 5;
printf("After modification in func()\n");
printf("a = %d string = %s\n\n",*a, string);
return;
}
int main(int argc, char **argv)
{
int a = 5;
char string[] = "A String";
printf("In main() before func()\n");
printf("Address of a: %p \n", &a);
printf("Address of string: %p \n", &string[0]);
printf("a = %d string = %s\n\n",a, string);
func(&a, string);
printf("In main() after func()\n");
printf("a = %d string = %s\n\n",a, string);
return 0;
}
When you compile and execute the above program, you will see an output similar to the following :
In main() before func()
Address of a: 0x7fff22e7c25c
Address of string: 0x7fff22e7c250
a = 5 string = A String
In func()
Address of a: 0x7fff22e7c25c
Address of string: 0x7fff22e7c250
a = 5 string = A String
After modification in func()
a = 6 string = F String
In main() after func()
a = 6 string = F String
As the output shows, the pointer variable a in fun() stores the location of the variable a in main(). Hence, any changes to the data stored at that location in func() is reflected back in the main() function.
We have now understood that arrays are by default call by reference. In the earlier program, we created an explicit copy of the string to prevent modifications to the original copy of the string. This strategy can also be followed for non-char arrays, such as an integer array where you can create a new array with the contents of the array being passed from another function.
However, a well-known generic strategy to accomplish this from the calling function itself is to make the array variable a member of a structure and then passing this structure member to the called function. The following code listing shows this.
Listing: call_value_array.c
# include <string.h>
# include <stdio.h>
struct string_wrapper{
char string[10];
};
void func(char string[])
{
/* Make modifications */
string[0] = string[0] + 5;
printf("String: %s\n", string);
return;
}
int main(int argc, char **argv)
{
struct string_wrapper string;
char astring[] = "A String";
strcpy(string.string, astring);
printf("String: %s\n", astring);
func(string.string);
printf("String: %s\n", astring);
return 0;
}
In the above code listing, we first define a structure string_wrapper with a character array as a member. This is because we plan to use this structure to wrap a string. If we wanted to use this for wrapping an integer array, we would have an integer array as the structure member. In the main() function, we copy the data in string variable astring to the structure member, string using strcpy(). Next, we call func() using this structure member instead of the string variable. This allows us to pass the data in astring, instead of the variable itself.
When you compile and execute the above program, you should see the following output:
String: A String
String: F String
String: A String
If you want to enforce the restriction that the data stored in one or more of your variables shouldn’t be changed from what was assigned during declaration of the variable, use the const keyword during declaring the variable. For example, const int a=1 declares an integer variable a and stores 1 in it. If you attempt to make any changes to it in the rest of the main() function, your compiler will not compile your program, telling you that this is not allowed. It is important to note that you have to store the data during declaration itself. The next code listing demonstrates this.
Listing: immut_data.c
# include <stdio.h>
int main(int argc, char **argv)
{
int a = 1;
const int b = a;
/* This is not allowed as well
const c;
c=1;
*/
/* Even though this is the same value as already stored in a,
this is not known to the compiler at compile time. Hence, the
following statement will result in a compile time error*/
/*b = a;*/
printf("Address of a: %p, Address of b: %p\n", &a, &b);
printf("a = %d b = %d \n",a,b);
return 0;
}
In this article, we have taken a look at the basics of how data in C has no identity if not stored in memory locations identified by identifiers. We also learnt about call by value and call by reference and how different data types behave differently when passed as function parameters.
If you are familiar with Python, you may be interested in my article on data in CPython. In my next article, I will summarize these two articles highlighting the differences between the two.