When learning any programming language, you always start with the "Hello World" program. The way in which your program "speaks" says a lot about the syntax and structure of programming in that language. Below is the "Hello World" program for C++ and C, for comparison.

/*hellowrold.cpp*/
#include <iostream>

using namespace std;

// Hello World in C++
int main(int argc, char * argv[]){
  cout << "Hello World" << endl;
}

/*helloworld.c*/
#include <stdio.h>

// Hello World in C
int main(int argc, char * argv[]){
  printf("Hello World\n");
}

To begin, each of the programs has a #include, which is a compiler directive to include a library with the program. Both of the include statements ask the compiler to include the I/O library. While in C++ this was the iostream library, in C, the standard I/O library is stdio.h. The .h refers to a header file, which is also a C program that library or auxiliary information is generally stored.

The compilation process for C is very similar to that of C++, but we use a C compiler. The standard C compiler on Unix system is gcc, the gnu C compiler. For example, to compile helloworld.c, we do the following.

#> gcc helloworld.c

Which will produce an executable file a.out, which we can run

#> ./a.out
Hello World

If we want to specify the name of the output file, you use the -o option.

#> gcc helloworld.c -o helloworld
#> ./helloworld
Hello World

There are more advanced compilation techniques that we will cover in lab, such as including multiple files, compiling to object files, and using pre-compiler directores.

The process of including libraries in your program looks very similar to that of C++, and uses the include statement. Note, all C libraries end in .h, unlike C++. Here are some common libraries you will probably want to include in your C program:

• stdlib.h : The C standard library, contains many useful utilities, and is generally included in all programs.
• stdio.h : The standard I/O library, contains utilities for reading and writing from files and file streams, and is generally included in all programs.
• unistd.h : The Unix standard library, contains utilities for interacting with the unix system, such as system calls
• sys/types.h : System types library, contains the definitions for the base types and structures of the unix system.
• string.h : String library, contains utilities for handling C strings.
• ctype.h : Character library, contains utilities for handing char conversions
• math.h : Math library, contains basic math utility functions.

When you put a #include <header.h> in your program, the compiler will search for that header in its header search path. The most common location is in /usr/include. However, if you place your filename to include in quotes:

#include "header.h"

The compiler will look in the local directory for the file and not the search path. This will become important when we start to develop larger programs.

The same control flow you find in C++ is present in C. This includes if/else statements.

if( condition1 ){
  //do something if condition1 is true
}else if (condition2){
  //do something if condition1 is false and condition2 is true
}else{
  //do this if both condition1 and condition2 is true
}

While loops:

while( condition ){
  //run this until the condition is not true
}

And, for loops:

//run init at the start
for ( init; condition; iteration){
  //run until condition is false preforming iteration on each loop.
}

One major gotcha for C style programming versus C++, is that there are different scoping issues. This is most present in for loops; you must declare your variables outside the initialization.

int i; //declared before loop
for(i=0; i < 10; i++){
  printf("%d\n",i);
}

C does not have a boolean type, that is, a basic type that explicitly defines true and false. Instead, true and false are defined for each type where 0 or NULL is always false and everything else is true. All basic types can be used as a condition on its own. For example, this is a common form of writing an infinite loop:

while(1){
  //loop forever!
}

The way output is performed in C++ is also quite different than that of C. In C++ you use the << and >> to direct items from cin or towards cout using iostreams. This convention is not possible in C, and instead, format printing and reading is used. Let's look at another example to further the comparison.

/*enternumber.cpp*/
#include <iostream>

using namespace std;

int main(int argc, char * argv[]){
  int num;

  cout << "Enter a number" << endl;
  cin >> num;

  cout << "You entered " << num << endl;
}

/*enternumber.c*/
#include <stdio.h>

int main(int argc, char * argv[]){
  int num;

  printf("Enter a number\n");
  scanf("%d", &num); //use &num to store 
                     //at the address of num

  printf("You entered %d\n", num);
}

The two programs above both ask the user to provide a number, and then print out that number. In C++, this should be fairly familiar. You use iostreams and direct the prompts to cout and direct input from cin to the integer num. C++ is smart enough to understand that if you are directing an integer to output or from input, then clearly, you are expecting a number. C is not capable of making those assumptions.

In C, we use a concept of format printing and format scanning to do basic I/O. The format tells C what kind of input or output to expect. In the above program enternumber.c, the scanf asks for a %d, which is the special format for a number, and similar, the printf has a %d format to indicate that num should be printed as a number.

There are other format options. For example, you can use %f to request a float.

/* getpi.c */

#include <stdio.h>
int main(int argc, char * argv[]){

  float pi;
  printf("Enter pi:\n");
  scanf("%f", &pi);

  printf("Mmmm, pi: %f\n", pi);
}

And you can use the format to change the number of decimals to print. %0.2f says print a float with only 2 trailing decimals. You can also include multiple formats, and the order of the formats match the additional arguments

int a=10,b=12;
float f=3.14;
printf("An int:%d a float:%f and another int:%d", a, f, b);
//              |          |                  |   |  |  |
//              |          |                  `---|--|--'
//              |          `----------------------|--'    
//              `---------------------------------'

There are a number of different formats available, and you can read the manual pages for printf and scanf to get more detail.

man 3 printf
man 3 scanf

You have to use the 3 in the manual command because there exists other forms of these functions, namely for Bash programming, and you need to look in section 3 of the manual for C standard library manuals.

For this class, we will use the following format characters frequently:

• %d : format integer
• %u : format an unsigned integer
• %f : format float/double
• %x : format hexadecimal
• %s : format string
• %c : format a char
• %l : format a long
• %lu: format an unsigned long
• %% : print a % symbol

The last part of the standard C library we haven't explore is reading/writing from files. Although, you've done this already in the form of the standard files, e.g., standard input, output, and error, we have demonstrated how to open, read, write, and close other files that may exist on the file system.

All the file stream functions and types are defined in the header file stdio.h, so you have to include that. In later lessons, we will look into using, the system call API to do all of our I/O.

Open files in the standard C library are referred to as file streams, and have the type:

FILE * stream;

and we open a file using fopen() which has the following prototype:

FILE * fopen(const char *path, const char *mode);

The first argument path is a string storing the file system path of the file to open, and mode describes the settings of the file. For example:

FILE * stream = fopen("gonavy.txt", "w");

will open a file in the current directory called "gonavy.txt" with write mode. We'll discuss the modes more shortly.

File streams, as pointers, are actually dynamically allocated, and they must be deallocated or closed. The function that closes a file stream is fclose()

fclose( stream );

The mode of the file describes how to open and use the file. For example, you can open a file for reading, writing, append mode. You can start reading/writing from the start or end of the file. You can truncate the file when opening removing all the previous data. From the man page, here are the options:

The argument mode points to a string beginning with one of the following sequences  (possibly  followed
by additional characters, as described below):

r      Open text file for reading.  The stream is positioned at the beginning of the file.

r+     Open for reading and writing.  The stream is positioned at the beginning of the file.

w      Truncate  file  to zero length or create text file for writing.  The stream is positioned at the
       beginning of the file.

w+     Open for reading and writing.  The file is created if it does not exist, otherwise it  is  trun‐
       cated.  The stream is positioned at the beginning of the file.

a      Open  for  appending  (writing  at end of file).  The file is created if it does not exist.  The
       stream is positioned at the end of the file.

a+     Open for reading and appending (writing at end of file).  The file is created  if  it  does  not
       exist.   The  initial  file  position for reading is at the beginning of the file, but output is
       always appended to the end of the file.

One key thing to notice from the modes is that any mode string with a "+" is for both reading and writing, but using "r" vs. "w" has different consequences for if the file already exists. With "r" a file will never be truncated if it exists, which means its contents will be deleted, but "w" will always truncate if it exits. However, "r" mode will not create the file if it doesn't exist while "w" will. Finally, append mode with "a" is a special case of "w" that doesn't truncate with all writes occurring at the end of the file.

As you can also see in the man page description, the file stream is described as having a "position" which refers to where within the file we read/write from. When you read a byte, you move the position forward in the file. In later lessons, we will look into how to manipulate the stream more directly. For now

Looking at the man page for the file, we can check for errors when opening files:

RETURN VALUE
       Upon successful completion fopen(), fdopen() and freopen() return a FILE pointer.  Otherwise,  NULL  is
       returned and errno is set to indicate the error.

So we can check for NULL for errors, for example:

if ( (stream = fopen("DOESNOTEXIST.txt", "r")) == NULL){
   fprintf("ERROR ... \n");
}

An error could occur, like above, for the file not existing, but it could also be because you have insufficient permissions. Consider, a file that you do not have read permission on, but you open the file with "r" mode, then that would be an error condition. Similarly, if you try and open a file for writing without having write permission, that will cause an error.

Additionally, you can get errors when you try and read/write from a file that you opened with the wrong mode. This will cause the read/write function (discussed below) to fail. In those cases, you should check the return values of those functions.

While I do not show error checking below, it is important that your code does error checking.

Just as you worked with the standard file streams, stdin, stdout, and stderr, we can do format input and output with file streams that you open with fopen().

By default, printf() prints to stdout, but you can alternative write to any file stream. To do so, you use the fprintf() function, which acts just like printf(), except you explicitly state which file stream you wish to print. Similarly, there is a fscanf() function for format reading from files other than stdin.

printf("Hello World\n"); //prints implicitly to standard out
fprintf(stdout, "Hello World\n"); //print explicitly to standard out
fprintf(stderr, "ERROR: World coming to an endline!\n"); //print to standard error

The standard file descriptors are available in C via their shorthand, and you can refer to their file descriptor numbers where appropriate:

• stdin : 0 : standard input
• stdout : 1 : standard output
• stderr : 2 : standard error

C does not have a built in boolean type, like C++ does. Instead, anything that is equivalent to numeric 0 is false and everything that is not 0 is true. For example, this is an infinite loop. As 1 will always be true.

while(1){
  //loop forever
}

In C many different elements you may not expect can have a zero value. For example, NULL is equivlanet to zero; it's the pointer value that is 0. The character \0 is also 0. Be on the look out for these implicit 0's.

An incredibly useful tool in programming is to be able to create advanced types built upon basic types. Consider managing a pair of integers. In practice, you could declare two integer variables and manage each separately, like so:

int left;
int right;
left = 1;
right = 2;

But that is cumbersome and you always have to remember that the variable left is paired with the variable right, and what happens when you need to have two pairs or three. It just is not manageable.

Instead, what we can do is declare a new type that is a structure containing two integers.

struct pair{    //declaring a new pair type 
  int left;     //that containing two integers
  int right;
};

struct pair p1;       //declare two variables of that type
struct pair p2;

p1.left = 10;    //assign values to the pair types
p1.right = 20;

p2.left = 0;
p2.right = 5;

The first part is to declare the new structure type by using the keyword struct and specify the basic types that are members of the structure. Next, we can declare variables of that type using the type name, struct pair. With those variables, we can then refer to the member values, left and right, using the . operator.

One question to consider: How is the data for the structure laid out in memory? Another way to ask is: How many bytes does it take to store the structure? In this example, the structure contains two integers, so it is 8 bytes in size. In memory, it would be represented by two integers that are adjacent in memory space.

struct pair
.--------------------.       
|.--------..--------.|
||<- 4B ->||<- 4B ->||     
||  left  ||  right ||
|'________''________'|
'--------------------'
 <----- 8 bytes ----->

Using the . and the correct name either refers to the first or second four bytes, or the left or right integer within the pair. When we print its size, that is exactly what we get.

printf("%lu\n", sizeof(struct pair));

While the pair struct is a simple example, throughout the semester we will see many advanced structure types that combine a large amount of information. These structures are used to represent various states of the computer and convey a lot of information in a compact form.

While structure data is ever present in the system, it is often hidden by declare new type names. The way to introduce a new type name or type definition is using the typedef macro. Here is an example for the pair structure type we declared above.

typedef struct{    //declaring a new structure
  int left;        //that containing two integers
  int right;
} pair_t;          //the type name for the structure is pair_t

pair_t p1;       //declare two variables of that type
pair_t p2;

p1.left = 10;    //assign values to the pair types
p1.right = 20;

p2.left = 0;
p2.right = 5;

This time we declare the same type, a pair of two integers, but we gave that structure type a distinct name, a pair_t. When declaring something of this type, we do not need to specify that it is a structure, instead, we call it what it is, a pair_t. The compiler is going to recognize the new type and ensure that it has the properties of the structure.

The suffix _t is typically used to specify that this type is not a basic type and defined. This is a convention of C, not a rule, but it can help guide you through the moray of types you will see in this class.

In C, pointers play a larger role than in C++. Recall that a pointer is a data type whose value is a memory address. A pointer must be declared based on what type it references; for example, int * are pointers to integers and char * are pointers to chars. Here are some basic operations associated with pointers.

• int * p : pointer declaration
• *p : pointer dereference, follow the pointer to the value
• &a : Address of the variable a
• p = &a : pointer assignment, p now references a
• *p = 20 : assignment via a dereference, follow the pointer and assign a the value.

Individually, each of these operations can be difficult to understand. Following a stack diagram, where variables and values are modeled. For the purposes of this class, we will draw stack diagrams like this:

+----------+-------+
| variable | value |
+----------+-------+

If we have a pointer variable, then we'll do this:

+----------+-------+
| pointer  |  .------->
+----------+-------+

This will indicate that the value of the pointer is a memory address that references some other memory.

To codify this concept further, let's follow a running example of the following program:

int a = 10, b;
int *p =  &a;
a = 20; 
b = *p; 
*p = 30;
p = &b;

Let us walk through it step by step:

int a = 10, b;
int *p =  &a; // <-- (1)
a = 20; 
b = *p; 
*p = 30;
p = &b;

+---+----+  
| a | 10 |<-.
+---+----+  |
| b |    |  |   arrow for pointer indicates 
+---+----+  |   a reference
| p |  .----+
+---+----+

int a = 10, b;
int *p =  &a; 
a = 20; // <--  (2)
b = *p; 
*p = 30;
p = &b;

+---+----+  
| a | 20 |<-.
+---+----+  |
| b |    |  |
+---+----+  |
| p |  .----+
+---+----+

int a = 10, b;
int *p =  &a; 
a = 20; 
b = *p; // <-- (3)
*p = 30;
p = &b;

+---+----+  
| a | 20 |<-.
+---+----+  |
| b | 20 |  |   *p means to follow pointer 
+---+----+  |   to get value
| p |  .----+
+---+----+

int a = 10, b;
int *p =  &a; 
a = 20; 
b = *p; 
*p = 30; // <-- (4)
p = &b;

+---+----+  
| a | 30 |<-.
+---+----+  |
| b | 20 |  |   assigning *p follows pointer 
+---+----+  |   to store value
| p |  .----+
+---+----+

int a = 10, b;
int *p =  &a; 
a = 20; 
b = *p; 
*p = 30; 
p = &b; // <-- (5)

+---+----+  
| a | 30 |
+---+----+  
| b | 20 |<-.
+---+----+  | 
| p |  .----+
+---+----+

Just like for other types, we can create pointers to structured memory. Consider for example:

typdef struct{
  int left;
  int right;
} pair_t;

pair_t pair;
pair.left = 1;
pair.right = 2;

pair_t * p = &pair;

This should be familiar to you as we can treat pair_t just like other data types, except we know that it is actually composed of two integers. However, now that p references a pair_t how do we deference it such that we get to member data? Here is one way.

printf("pair: (%d,%d)\n", (*p).left, (*p).right);

Looking closely, you see we first use the * operator to deference the pointer, and then the . operator to refer to a member of the structure. That is a lot of work and because C requires us to frequently access members of structures via a pointer reference. To alleviate that, C has a shortcut operation, the arrow or ->, which dereferences and then does member reference for pointers to structures. Here is how that looks:

printf("pair: (%d,%d)\n", p->left, p->right);

p->right = 2017;
p->left  = 1845;

The last type are array types which provides a way for the program to declare an arbitrary amount of the same type in continuous memory. Here is a simple example with an array of integers:

int array[10]; //declare an array of 10 integers
int i;

//assign to the array  
for(i=0;i<10;i++){
  array[i] = 2*i; //index times 2
 }

//reference the array
for(i=0;i<10;i++){
  printf("%d:%d\n", i,array[i]); 
 }

aviv@saddleback: demo $ ./array-example
0:0
1:2
2:4
3:6
4:8
5:10
6:12
7:14
8:16
9:18

We declare an array using the [ ] following the variable name. We use the term index to refer to an element of an array. Above, the array array is of size 10, which means that we can use indexes 0 through 9 (computer scientist start counting at 0). To index the array, for both retrieval and assignment, we use the [ ] operators as well.

Now, it is time to blow your mind. It turns out that in C arrays and pointers are the same thing. Seriously. Well, not exactly the same, but basically the same.

Let me demonstrate. First consider how and what happens when you assign a pointer to an array.

/*pointer-array.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  int array[10];
  int i;
  int * p = array; //p points to array

  //assign to the array  
  for(i=0;i<10;i++){
    array[i] = 2*i; //index times 2
  }

  //derefernce p and assign 2017
  *p = 2017;

  //print the array
  for(i=0;i<10;i++){
    printf("%d:%d\n", i,array[i]); 
  }

}

aviv@saddleback: demo $ ./pointer-array 
0:2017
1:2
2:4
3:6
4:8
5:10
6:12
7:14
8:16
9:18

Notice that at index 0 the value is now 2017. Also notice that when you assigned the pointer value, we did not take the address of the array. That means p is really referencing the address of the first item in the array and for that matter, so is array!

It gets crazier because we can also use the [ ] operators with pointers. Consider this small change to the program:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  int array[10];
  int i;
  int * p = array; //p points to array

  //assign to the array  
  for(i=0;i<10;i++){
    array[i] = 2*i; //index times 2
  }

  //index p at 5  and assign 2017
  p[5] = 2017;   //<---------------!!

  //print the array
  for(i=0;i<10;i++){
    printf("%d:%d\n", i,array[i]); 
  }

}

aviv@saddleback: demo $ ./pointer-array-index 
0:0
1:2
2:4
3:6
4:8
5:2017 //<---------!!!
6:12
7:14
8:16
9:18

In this case we indexed the pointer at 5 and assigned to it the value 2017, which resulted in that value appearing in the output. What is the implication of this? We know that p is a pointer and we know to assign to the value referenced by a pointer it requires a dereference, so the [ ] must be a dereference operation. And it is. In fact we can translate the [ ] operation like so:

p[5] = *(p+5)

What the [ ] operation does is increments the pointer by the index and then deference. As a stack diagram, we can visualize this like so:

.-------+------.
| array |   .--+--.
|-------+------|  |
|       |    0 |<-'<-.
|-------+------|     |
|       |    2 |     |
|-------+------|     |
|       |    4 |     |
|-------+------|     |
|       |    6 |     |
|-------+------|     |
|       |    8 |     |
|-------+------|     |
|       | 2017 |<----+----- p+5, array+5
|-------+------|     |
|       |   12 |     |
|-------+------|     |
|       |   14 |     |
|-------+------|     |
|       |   16 |     |
|-------+------|     |
|       |   18 |     |
|-------+------|     |
| p     |   .--+-----'
'-------+------'

This is called pointer arithmetic, which is a bit complicated, but we'll return to it later when discussing strings. The important take away is that there is a close relationship between pointers and arrays. And now you also know why arrays are indexed starting at 0 — it is because of pointer arithmetic. The first item in the array is the same as just dereferencing the pointer to the array, thus occurring at index 0.

Before I described that relationship as the same, but they are not exactly the same. Where they differ is that pointers can be reassigned like any variable, but arrays cannot. They are constants. For example, this is not allowed:

int a[10];
int b[10];
int *p;

p = a; // ok

b = p; // not ok!

Array pointers are constant, we cannot reassign to them. The reason is obvious when you think: if we could reassign the array pointer, then how would reclaim that memory? The answer is you could not. It would be lost.

In the next lessons, we will continue to look at arrays and pointers, but in the context of strings, which are simply arrays of characters with the property that they are null terminated.

Recall that an array is a contiguos region of memory that stores a sequence of the same data items We declare arrays statically using the [ ] symbols and a size, and you can also reference and assign to an array using the [ ] symbol.

int array[10]; 
int i; 

for(i=0;i < 10; i++){
 array[i] = i*2; 
}

Additionally, arrays and pointers are closely linked, and, in fact, an array variable is a special type of pointer whose value cannot change. When you declare an array:

int array[10];

You are asking C to do two things. First, this is a request to allocate 10 integers of memory, contiguously, or 40 bytes. The second part is to assign the address of that memory allocation to the variable array and make it constant so that the value that array references cannot change.

Essentially, array is a pointer to the contiguous memory. We can then access the individual integers in that memory region using the [ ] operator. But, we also know that this operation is equivalent to a deference.

          .---.
array --> |   |  array[0] == *(array+0) 
          +---+
          |   |  array[1] == *(array+1) 
          +---+
          |   |  array[2] == *(array+2)
          +---+
          :   :  etc.
          '   '

When you index into an array, you are effectively following the pointer plus the index. That is, the operation of array[i] says to following the pointer referenced by the variable array, move i steps further, and then return the value found at that memory location. The concept of pairing arrays and pointers in this style is called pointer arithmetic and is an incredibly powerful tool of C programming and used a lot with C strings.

While the declaration looks acquired at first without the array size, this actually means that the size will be determined automatically by the assignment. All arrays can be declared in this static way; here is an example for an integer array:

int array[] = {1, 2, 3};

In that example, the array values are denoted using the { } and comma separated within. The length of the array is clearly 3, but the compiler can determine that by inspecting the static declaration, so it is often omitted. However, that does not mean you cannot provide a size, for example

int array[10] = {1, 2, 3};

is also perfectly fine but has a different semantic meaning. The first declaration (without a size) says allocate only enough memory to store the statically declared array. The second declaration (with the size) says to allocate enough memory to store size items of the data type and initialize as many possible to this array.

You can see this actually happening in this simple program:

/*array_deceleration.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]){

  int a[] = {1,2,3};
  int b[10] = {1,2,3};
  int i;

  printf("sizeof(a):%d sizeof(b):%d\n", 
         (int) sizeof(a),
         (int) sizeof(b)
         );

  printf("\n");
  for(i=0;i<3;i++){
    printf("a[%d]: %d\n", i,a[i]);
  }    

  printf("\n");
  for(i=0;i<10;i++){
    printf("b[%d]: %d\n", i,b[i]);
  }    
}

aviv@saddleback: demo $ ./array_decleration
sizeof(a):12 sizeof(b):40
a[0]: 1
a[1]: 2
a[2]: 3

b[0]: 1
b[1]: 2
b[2]: 3
b[3]: 0
b[4]: 0
b[5]: 0
b[6]: 0
b[7]: 0
b[8]: 0
b[9]: 0

As you can see, both decelerations work, but the allocation sizes are different. Array b is allocated to store 10 integers with a size of 40 bytes, while array a only allocated enough to store the static declaration. Also note that the allocation implicitly filled in 0 for non statically declared array elements in b, which is behavior you'd expect.

Now that you have a broader sense of how arrays are declared, let's adapt this to strings. The first thing we can try and declare is a string, that is an array of char's, using the declaration like we had above.

char a[]   = {'G','o',' ','N','a','v','y','!'};
char b[10] = {'G','o',' ','N','a','v','y','!'};

Just as before we are declaring an array of the given type which is char. We also use the static declaration for arrays. At this point we should feel pretty good — we have a string, but not really. Let's look at an example using this declaration:

/*string_declerations.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]){

  char a[]   = {'G','o',' ','N','a','v','y','!'};
  char b[10] = {'G','o',' ','N','a','v','y','!'};
  int i;

  printf("sizeof(a):%d sizeof(b):%d\n", 
         (int) sizeof(a),
         (int) sizeof(b)
         );


  printf("\n");
  for(i=0;i<8;i++){
    //print char and ASCII value
    printf("a[%d]: %c (%d)\n", i,a[i],a[i]);
  }    


  printf("\n");
  for(i=0;i<10;i++){
    //print char and ASCII value
    printf("b[%d]: %c (%d) \n", i,b[i],b[i]);
  }    

  printf("\n");
  printf("a: %s\n",a); //format print the string
  printf("b: %s\n",b); //format print the string

}

aviv@saddleback: demo $ ./string_declerations 
sizeof(a):8 sizeof(b):10

a[0]: G (71)
a[1]: o (111)
a[2]:   (32)
a[3]: N (78)
a[4]: a (97)
a[5]: v (118)
a[6]: y (121)
a[7]: ! (33)

b[0]: G (71) 
b[1]: o (111) 
b[2]:   (32) 
b[3]: N (78) 
b[4]: a (97) 
b[5]: v (118) 
b[6]: y (121) 
b[7]: ! (33) 
b[8]:  (0) 
b[9]:  (0) 

a: Go Navy!?@
b: Go Navy!

First observations is the sizeof the arrays match our expectations. A char is 1 byte in size and the arrays are allocated to match either the implicit size (7) or the explicit size (10). We can also print the arrays iteratively, and the ASCII values are inset to provide a reference. However, when we try and format print the string using the %s format, something strange happens for a that does not happen for b.

The problem is that a is not NULL terminated, that is, the last char numeric value in the string is not 0. NULL termination is very important for determining the length of the string. Without this special marker, the printf() function is unable to determine when the string ends, so it prints extra characters that are not really part of the string.

We can change the declaration of a to explicitly NULL terminate like so:

char a[]   = {'G','o',' ','N','a','v','y','!', '\0'};

The escape sequence '\0' is equivalent to NULL, and now we have a legal string. But, I think we can all agree this is a really annoying way to do string declarations using array formats because all strings should be NULL terminated anyway. Thus, the double quoted string shorthand is used.

char a[]   = "Go Navy!";

The quoted string is the same as statically declaring an array with an implicit NULL termination, and it is ever so much more convenient to use. You can also more explicitly declare the size, as in the below example, which declares the array of the size, but also will NULL terminate.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]){

  char a[]   = "Go Navy!";
  char b[10] = "Go Navy!";
  int i;

  printf("sizeof(a):%d sizeof(b):%d\n", 
         (int) sizeof(a),
         (int) sizeof(b)
         );


  printf("\n");
  for(i=0;i<9;i++){
    //print char and ASCII value
    printf("a[%d]: %c (%d)\n", i,a[i],a[i]);
  }    


  printf("\n");
  for(i=0;i<10;i++){
    //print char and ASCII value
    printf("b[%d]: %c (%d) \n", i,b[i],b[i]);
  }    

  printf("\n");
  printf("a: %s\n",a); //format print the string
  printf("b: %s\n",b); //format print the string

}

aviv@saddleback: demo $ ./string_quoted 
sizeof(a):9 sizeof(b):10

a[0]: G (71)
a[1]: o (111)
a[2]:   (32)
a[3]: N (78)
a[4]: a (97)
a[5]: v (118)
a[6]: y (121)
a[7]: ! (33)
a[8]:  (0)

b[0]: G (71) 
b[1]: o (111) 
b[2]:   (32) 
b[3]: N (78) 
b[4]: a (97) 
b[5]: v (118) 
b[6]: y (121) 
b[7]: ! (33) 
b[8]:  (0) 
b[9]:  (0) 

a: Go Navy!
b: Go Navy!

You may now be wondering what happens if you do something silly like this,

char a[3] = "Go Navy!";

where you declare the string to be of size 3 but assign a string requiring much more memory? Well … why don't you try writing a small program to finding out what happen, which you will do in homework.

While strings are not basic types, like numbers, they do have a special place in a lot of operations because we use them so commonly. One such place is in formats.

You already saw above that %s is the format character to process a string, and it is also the format character used to scan a string. We can see how this all works using this simple example:

/*format_string*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  char name[20];

  printf("What is your name?\n");
  scanf("%s",name);

  printf("\n");
  printf("Hello %s!\n",name); 

}

There are two formats. The first will ask the user for their name, and read the response using a scanf(). Looking more closely, when you provide name as the second argument to scanf(), you are saying: "Read in a string and write it to the memory referenced by name." Later, we can then print name using a %s in a printf(). Here is a sample execution:

aviv@saddleback: demo $ ./format_string 
What is your name?
Adam

Hello Adam!

That works great. Let's try some other input:

aviv@saddleback: demo $ ./format_string 
What is your name?
Adam Aviv

Hello Adam!

Hmm. That didn't work like expected. Instead of reading in the whole input "Adam Aviv" it only read a single word, "Adam". This has to do with the functionality of scanf() that "%s" does not refer to an entire line but just an individual whitespace separated string.

The other thing to notice is that the string name is of a fixed size, 20 bytes. What happens if I provide input that is longer … much longer.

aviv@saddleback: demo $ ./format_string 
What is your name?
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdam

Hello AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdam!
 *** stack smashing detected ***: ./format_string terminated
Aborted (core dumped)

That was interesting. The execution identified that you overflowed the string, that is tried to write more than 20 bytes. This caused a check to go off, and the program to crash. Generally, a segmentation fault occurs when you try to read or write invalid memory, i.e., outside the allowable memory segments.

We can go even further with this example and come up with a name sooooooo long that the program crashes in a different way:

What is your name?
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Hello AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA!
Segmentation fault (core dumped)

In this case, we got a segmentation fault. The scanf() wrote so far out of bounds of the length of the array that it wrote memory it was not allowed to do so. This caused the segmentation fault.

Another way you can get a segmentation fault is by dereferencing NULL, that is, you have a pointer value that equals NULL and you try to follow the pointer to memory that does not exist.

/*null_print.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char*argv[]){

  printf("This is a bad idea ...\n");
  printf("%s\n",(char *) NULL);
}

aviv@saddleback: demo $ ./null_print
This is a bad idea ...
Segmentation fault (core dumped)

This example is relatively silly as I purposely dereference NULL by trying to treat it as a string. While you might not do it so blatantly, you will do something like this at some point. It is a mistake we all make as programmers, and it is a particularly annoying mistake that is inevitable when you program with pointers and strings. It can be frustrating, but we will also go over many ways to debug such errors throughout the semester.

To see all the goodness in the string library, start by typing man string in your linux terminal. Up will come the manual page for all the functions in the string library:

STRING(3)                              Linux Programmer's Manual                             STRING(3)

NAME
       stpcpy,  strcasecmp,  strcat, strchr, strcmp, strcoll, strcpy, strcspn, strdup, strfry, strlen,
       strncat, strncmp, strncpy, strncasecmp,  strpbrk,  strrchr,  strsep,  strspn,  strstr,  strtok,
       strxfrm, index, rindex - string operations

SYNOPSIS
       #include <strings.h>

       int strcasecmp(const char *s1, const char *s2);

       int strncasecmp(const char *s1, const char *s2, size_t n);

       char *index(const char *s, int c);

       char *rindex(const char *s, int c);

       #include <string.h>

       char *stpcpy(char *dest, const char *src);

       char *strcat(char *dest, const char *src);

       char *strchr(const char *s, int c);

       int strcmp(const char *s1, const char *s2);

       int strcoll(const char *s1, const char *s2);

       char *strcpy(char *dest, const char *src);

       size_t strcspn(const char *s, const char *reject);

       char *strdup(const char *s);

       char *strfry(char *string);

       size_t strlen(const char *s);

       ...

To use the string library, the only thing you need to do is include string.h in the header declarations. You can further explore different functions string library within their own manual pages. The two most relevant to our discussion will be strcmp() and strlen(). However, I encourage you to explore some of the others, for example strfry() will randomize the string to create an anagram – how useful!

To solve our string comparison delimina, we will use the strcmp() function from the string library. Here is the revelant man page:

STRCMP(3)                              Linux Programmer's Manual                             STRCMP(3)

NAME
       strcmp, strncmp - compare two strings

SYNOPSIS
       #include <string.h>

       int strcmp(const char *s1, const char *s2);

       int strncmp(const char *s1, const char *s2, size_t n);

DESCRIPTION
       The  strcmp()  function  compares  the two strings s1 and s2.  It returns an integer less than,
       equal to, or greater than zero if s1 is found, respectively, to be less than, to match,  or  be
       greater than s2.

       The  strncmp()  function  is similar, except it compares the only first (at most) n bytes of s1
       and s2.

RETURN VALUE
       The strcmp() and strncmp() functions return an integer less than, equal  to,  or  greater  than
       zero if s1 (or the first n bytes thereof) is found, respectively, to be less than, to match, or
       be greater than s2.

It comes in two varieties. One with a maximum length specified and one that relies on null termination. Both return the same values. If the two strings are equal, then the value is 0, if the first string string is greater (larger alphabetically) than it returns 1, and if the first string is less than (smaller alphabetically) then it returns -1.

Plugging in strcmp() into our secrete message program, we get the desired results.

/*string_strncp.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char *argv[]){

  char str[20];

  printf("Enter 'Navy' for a secret message:\n");

  scanf("%s",str);

  if( strcmp(str,"Navy") == 0 ) {
    printf("Go Navy! Beat Army!\n");
  }else{
    printf("No secret for you.\n");
  }

}

aviv@saddleback: demo $ ./string_strcmp 
Enter 'Navy' for a secret message:
Navy
Go Navy! Beat Army!

Another really important string library function is strlen() which returns the length of the string. It is important to differentiate the length of the string from the size of the string.

• string length: how many characters, not including the null character, are in the string
• sizeof : how many bytes required to store the string.

One of the most common mistakes when working with C strings is to consider the sizeof the string and not the length of the string, which are clearly two different values. Here is a small program that can demonstrate how this can go wrong quickly:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){

  char str[]="Hello!";
  char * s = str;

  printf("strlen(str):%d sizeof(str):%d sizeof(s):%d\n",
         (int) strlen(str),  //the length of the str
         (int) sizeof(str),  //the memory size of the str
         (int) sizeof(s)    //the memory size of a pointer
         );
}

aviv@saddleback: demo $ ./string_length 
strlen(str):6 sizeof(str):7 sizeof(s):8

Note that when using strlen() we get the length of the string "Hello!" which has 6 letters. The size of the string str is how much memory is used to store it, which is 7, if you include the null terminated. However, things get bad when you have a pointer to that string s. Calling sizeof() on s returns how much memory needed to store s which is a pointer and thus is 8-bytes in size. That has nothing to do with the length of the string or the size of the string. This is why when working with strings always make sure to use the right length not the size.

Something that you might have noticed is that we have been using pointer arithmetic for different types in the same way. That is, consider the two arrays below, one an array of integers and one a string:

int a[]  = {0,1,2,3,4,5,6,7};
char str = "Hello!";

Both arrays are the same length, 7, but they are different sizes. Integers are 4-bytes, so to store 7 integers requires 4*7=24 bytes. But characters are 1 byte in size, so to store 7 characters requires just 7 bytes. In memory the two arrays may look something like this:

       <------------------------ 24 bytes ---------------------------->
       .---------------.----------------.--- - - - ---.----------------.
a   -> |             0 |              1 |             |              7 |
       '---------------'----------------'--- - - - ---'----------------'

       .---.---.---.---.---.---.
str -> | H | e | l | l | o | \0|
       '---'---'---'---'---'---'
       <-------  7 bytes ------> 

Now consider what happens when we use pointer arithmetic on these arrays to dereference the third index:

/*pointer_math.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  int a[] = {0,1,2,3,4,5,6,7};
  char str[] = "Hello!";

  printf("a[3]:%d str[3]:%c\n", *(a+3),*(str+3));

}

aviv@saddleback: demo $ ./pointer_math 
a[3]:3 str[3]:l

Knowing what you know, the output is not consistent. When you add 3 to the array of integers a, you adjust the pointer by 12 bytes so that you now reference the value 3. However, when you add 3 to the string pointer, you adjust the pointer by 3 bytes to reference the value 'l'.

The reason for this has to do with pointer arithmetic consideration of typing. When you declare a pointer to reference a particular type, C is aware that adding to the pointer value should consider the type of data being referenced. So when you add 1 to an integer pointer, you are moving the reference forward 4 bytes since that is the size of the integer. If we were to print the pointer values (in hex) and do numerical arithmetic we would see this to be true:

printf("a=%p a+3=%p (a+3-a)=%d\n",a,a+3, ((long) (a+3)) - (long) a);

printf("str=%p str+3=%p (str+3-str)=%d\n",str,str+3, ((long) (str+3)) - (long) str);

aviv@saddleback: demo $ ./pointer_math 
a[3]:3 str[3]:l

a=0x7fffa5c4d260 a+3=0x7fffa5c4d26c (a+3-a)=12

str=0x7fffa5c4d280 str+3=0x7fffa5c4d283 (str+3-str)=3

In the first part a+3 changed the pointer value by 0xc in hex which is 12, while str+3 only changes the character value by 0x3 or 3 bytes. More starkly you can see that if we treat the pointer values as longs and do numerical arithmetic after doing pointer arithmetic you see this more clearly.

Now you may be wondering, how do I access the individual bytes of larger data types? The answer to this is the final peculiarity of character arrays in C.

Consider that a char data type is 1 byte in size, which is the smallest data element we work with as programmers. Now consider that an array of char's matches exactly that many bytes. So when we write something like:

char s[4];

What we are really saying is: "allocate 4 bytes of data." We like to think about storing a string of length 3 in that character array with one byte for the null terminator, but we do not have to. In fact, any kind of data can be stored there as long as it is only 4-bytes in size. An integer is four bytes in size. Let's store an integer in s.

aviv@saddleback: demo $ cat pointer_casting.c
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  char s[4];

  s[0] = 255;
  s[1] = 255;
  s[2] = 255;
  s[3] = 255;

  int * i = (int *) s;
  printf("*i = %d\n", *i);

}

What this program does is set all the bytes in the character array to 255, which is the largest value 1-byte can store. The result is that we have 4-bytes of data that are all 1's, since 255 in binary is 11111111. Four bytes of data that is all 1's. Next, consider what happens with this cast:

int * i = (int *) s;

Now the pointer i references the same memory as s, which is 4-bytes of 1's. What's different is that i is an integer pointer not a character pointer. That means the 4-bytes of 1's is an integer not characters from the perspective of i. And when we dereference i to print those bytes as a number, we get:

aviv@saddleback: demo $ ./pointer_casting 
*i = -1

Which is the signed value for all 1's (remember two's compliment?). What we've just done is use characters as a generic container for data and then used pointer casting to determine how to interpret that data. This may seem crazy — it is — but it is what makes C so low level and useful.

We often refer to character arrays as buffers because of this property of being arbitrary containers. A buffer of data is just a bunch of bytes, and a character array is the most direct way to access that data.

Like single arrays, we can declare double arrays using the [ ], but with two. We can also do static declarations of values with { }. Here's an example:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  int darray[][4] = { {0, 0, 0, 0},
                       {1, 1, 1, 1},
                       {2, 2, 2, 2},
                       {3, 3, 3, 3}};
  int i,j;

  for(i=0;i<4;i++){
    printf("darray[%d] = { ",i);
    for(j=0;j<4;j++){
      printf("%d ",darray[i][j]); //<---
    }
    printf("}\n");
  }


}

aviv@saddleback: demo $ ./int_doublearray 
darray[0] = { 0 0 0 0 }
darray[1] = { 1 1 1 1 }
darray[2] = { 2 2 2 2 }
darray[3] = { 3 3 3 3 }

Each index in the array references another array. Like before we allow C to determine the size of the outer array when declaring statically. However, you must define the size of the inner arrays. This is because of the way the memory is allocated. While the array example above is square in size, the double array can be asymmetric.

Let's think a bit more about what a double array really is given our understanding of the relationship between pointers and arrays. For a single array, the array variable is a pointer that references the first item in the array. For a double array, the array variable references a reference that references the first item in the first array. Here's a visual of the stack diagram:

                           .---.---.---.---.
            .---.  _.----> | 0 | 0 | 0 | 0 |  <-- darray[0]
darray ---> | --+-'        '---'---'---'---'
            |---|          .---.---.---.---.
            | --+--------> | 1 | 1 | 1 | 1 |  <-- darray[1]
            |---|          '---'---'---'---'
            | --+-._       .---.---.---.---.
            |---|   '----> | 2 | 2 | 2 | 2 |  <-- darray[2]
            | --+-._       '---'---'---'---'
            '---'   '._    .---.---.---.---.
                       '-> | 3 | 3 | 3 | 3 |  <-- darray[3]
                           '---'---'---'---'               

If we follow the arrays, we see that the type of darray is actually a int **. That means, it is a pointer that references a memory address that stores another pointer that references a memory address of an integer. So when we say double array, we are also referring to double pointers.

To demonstrate this further, we can even show the dereferences directly.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  int darray[][4] = { {0, 0, 0, 0},
                       {1, 1, 1, 1},
                       {2, 2, 2017, 2},
                       {3, 3, 3, 3}};

  printf("*(*(darray+2)+2) = %d\n", *(*(darray+2)+2));
  printf("     daray[2][2] = %d\n", darray[2][2]);
}

aviv@saddleback: demo $ ./derefernce_doublearray 
*(*(darray+2)+2) = 2017
     daray[2][2] = 2017

As you can see it takes two dereferences to get to the integer value.

Now let us consider another kind of double array, an array of strings. Recall that a C string is just an array of characters, so an array of strings is a double array of characters. One of the tricky parts of string arrays is the typing declaration.

Before we declared arrays using the following notation:

char str1[] = "This is a string";

But now we know that the type of arrays and pointers are really the same, so we can also declare a string this way:

char * str2 = "This is also a string";

Note that there is a difference between these two declarations in how and where C actually stores the string in memory. Consider the output of this program:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  char str1[] = "This is a string";
  char * str2 = "This is also a string";

  printf("str1: %s \t\t &str1:%p\n",str1,str1);
  printf("str2: %s \t &str2:%p\n",str2,str2);

}

aviv@saddleback: demo $ ./string_declare 
str1: This is a string 		 &str1:0x7fff4344d090
str2: This is also a string 	 &str2:0x4006b4

While both strings print fine as strings, the memory address of the two strings are very different. One is located in the stack memory region and other is in the data segment. In later lessons we will explore this further, but for the moment, the important takeaway is that we can now refer to strings as char * types.

Given we know that char * is the type of a string, then an array of char *'s is an array of strings.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  char * strings[]={"Go Navy!",
                     "Beat Army!",
                     "Crash Airforce!",
                     "Destroy the Irish!"};
  int i;

  printf("strings: %p\n",strings);
  for(i=0;i<4;i++){
    printf("strings[%d]: '%s' %p\n",i,strings[i],strings[i]);
  }
}

aviv@saddleback: demo $ ./string_array 
strings: 0x7fff7af68080
strings[0]: 'Go Navy!' 0x400634
strings[1]: 'Beat Army!' 0x40063d
strings[2]: 'Crash Airforce!' 0x400648
strings[3]: 'Destroy the Irish!' 0x400658

Like before we can see that strings is a pointer that references a pointer to a char, but that's just an array of strings or a double array. Another thing you may notice is that the length and size of each of the strings is different. This is because the way the array is declared with char * as the type of the string rather than char [] which changes how the array is stored.

You may have notices that I have been writing main functions slightly differently then you have seen them before.

//
//argument ____.             ._____ argument
// count       |             |       variables 
//             v             v
 int main(int argc, char * argv[]);

The arguments to main correspond to the command line input. The first is the number of such arguments, and the second is a string array of the argument values. Here's an example that illuminates the arguments:

/*print_args.c*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
  int i;

  for(i=0;i<argc;i++){
    printf("argv[%d] = %s\n",i,argv[i]);
  }
}

aviv@saddleback: demo $ ./print_args arg1 arg2 arg3 x y z adam aviv
argv[0] = ./print_args
argv[1] = arg1
argv[2] = arg2
argv[3] = arg3
argv[4] = x
argv[5] = y
argv[6] = z
argv[7] = adam
argv[8] = aviv

Looking at the program and its output, you can see that there is correspondence to the arguments provided and the index in the array. Its important to note that the name of the program being run is arg[0], which means that all programs have at least one argument, the name of the program. For example:

aviv@saddleback: demo $ ./print_args 
argv[0] = ./print_args

The name of the program is not compiled into the executable. It is instead passed as a true command line argument by the shell, which forks and executes the program. The mechanics of this will become clear later in the semester when we implement our own simplified version of the shell. To demonstrate this now, consider how the arg[0] changes when I change the name of the executable:

aviv@saddleback: demo $ cp print_args newnameofprintargs
aviv@saddleback: demo $ ./newnameofprintargs 
argv[0] = ./newnameofprintargs
aviv@saddleback: demo $ ./newnameofprintargs a b c d e f
argv[0] = ./newnameofprintargs
argv[1] = a
argv[2] = b
argv[3] = c
argv[4] = d
argv[5] = e
argv[6] = f

Another interesting construction of the argv array is that the array is NULL terminated much like a string is null terminated. The reason for this is so the OS can determine how many arguments are present. Without null termination there is no way to know the end of the array.

You can use this fact when parsing the array by using pointer arithmetic and checking for a NULL reference:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

  char ** curarg;
  int i;

  for( curarg=argv , i=0 ; //initialize curarg to argv array and i to 0
       *curarg != NULL;    //stop when curarg references NULL
       curarg++, i++){     //increment curarg and i

     printf("argv[%d] = %s\n", i, *curarg);
  }

}

viv@saddleback: demo $ ./print_args_pointer a b c d e
argv[0] = ./print_args_pointer
argv[1] = a
argv[2] = b
argv[3] = c
argv[4] = d
argv[5] = e

Notice that the pointer incrementing over the argv arrays is of type char **. Its a pointer to a string, which is itself an array of chars, so its a pointer to a pointer. (POINTERS ARE MADNESS!)

Something that you will often have to do when writing programs is parse command line arguments. The required error checking procedure can be time consuming, but it is also incredibly important for the overall user experience of your program.

Lets consider a simple program that will print a string a user specified number of times. We would like to execute it this way:

run_n_times 5 string

Where string is printed n times. Now, what we know about command line arguments is that they are processed as strings, so both string and 5 are strings. We need to convert "5" into an integer 5.

There are two ways to do this. The first is atoi() which converts a string to a number, but looking at the manual page for atoi() we find that atoi() does not detect errors. For example, this command line arguments will not be detected:

run_n_times notanumber string

Executing, atoi("notanumber") will return 0, so a simple routine like:

int main(int argc, char * argv[]){
  int i;
  int n = atoi(argv[1]); //does not detect errors

  for(i=0;i<n;i++){
    printf("%s\n",argv[2]);
  }
}

will just print nothing and not return the error. While this might be reasonable in some settings, but we might want to detect this error and let the user know.

Instead, we can convert the argv[1] to an integer using scanf(), but we have another problem. We have only seen scanf() in the concept of reading from standard input, but we can also have it read from an arbitrary string. That version of scanf() is called sscanf() and works like such:

int main(int argc, char * argv[]){
  int i;
  int n;

  if( sscanf(argv[1],"%d", &n) == 0) ){
    fprintf(stderr, "ERROR: require a number\n");
    exit(1); //exit the program
  }

  for(i=0;i<n;i++){
    printf("%s\n",argv[2]);
  }
}

Recall that scanf() returns the number of items that successfully match the format string. So if no items match, then the user did not provide a number to match the %d format. So this program successfully error checks the first argument. But, what about the second argument? What happens when we run with these arguments?

./run_n_times 5

There is no argv[2] provided and worse because the argv array is NULL terminated, argv[2] references NULL. When the printf() dereferences argv[2] it wlll cause a segmentation fault. How do we fix this? We also have to error check the number of arguments.

int main(int argc, char * argv[]){
  int i;
  int n;

  if(argc < 2){
  fprintf(stderr, "ERROR: invalid number of arguments\n");
    exit(1); //exit the program
  }

  if( sscanf(argv[1],"%d", &n) == 0) ){
    fprintf(stderr, "ERROR: require a number\n");
    exit(1); //exit the program
  }

  for(i=0;i<n;i++){
    printf("%s\n",argv[2]);
  }
}

And now we have properly error checked user arguments to this simple program. As you can see, error checking is tedious but incredibly important.