Arrays and strings in C

C vs C++: Arrays

In this lecture, we will see how the C language handles arrays. And as before, you will see that many differences are superficial and what you've learned for C++ in this class nicely applies to C. As a reminder of the differences we've already covered:

Compiler is gcc not g++
Files are named .c not .cpp
Included libraries are different (stdio.h)
printf instead of cout
scanf instead of cin

Today we will look at arrays and strings. The short description is that C requires you to be more explicit with how much memory you need for an array, but after that, pointers and array usage is the same.

Allocating Memory for an Array: malloc or calloc

C++	C
`int* nums = new int[12];`	`#include <stdlib.h> int* nums = malloc( 12*sizeof(int) );`

In C, we instead use the keywords malloc or calloc. They're almost, but not exactly, the same.

malloc

The prototype for malloc is:

void* malloc(int);

You need to do #include <stdlib.h> to use malloc and calloc.
The parameter of type int needs to be the number of bytes that you want for your array from the operating system.
When requesting space for an array of 5 ints, for example, to arrive at the correct number of bytes to request:
- You need to know not only the 5.
- But, you also also the number of bytes required by a single int.
  Most systems represent an int with 4 bytes, but not always, and embedded systems can be different from platforms. To know how many bytes your type needs, use the sizeof() function.
  sizeof(int) returns the number of bytes needed to store a single int. This is then multiplied by 5 (because you need room for 5
Because malloc just accepts the number of raw bytes to be allocated, it has no knowledge of the type you're going to store within that space, so it doesn't know whether to return a int* or a char* or what. So, it just returns a void*.
This void pointer can be cast to any of those types. So, for our array of 5 ints, we finally end up at:
```
int* intArr = malloc( 5*sizeof(int) );
```
Say we instead want 12 doubles, then it looks like this:
```
double* doubles = malloc( 12*sizeof(double) );
```

calloc

C++	C
`double* A = new double[10]; for(int i=0; i<10; i++) A[i] = 0;`	`#include <stdlib.h> double* A = calloc(10, sizeof(double));`

calloc has two input parameters.
- the number of elements that are allocated
- the size of the type
They are essentially the same; for malloc, you just need to multiply them together.
The other significant difference is that calloc zeroes it out the allocated memory for you!

The choice between malloc and calloc is largely a personal preference between the two, as long as you're knowledgeable about these differences.

Filling an Array with scanf

Remember that scanf requires a pointer to know which memory address will be filled. For example, reading an int:

int* nums = malloc( 10*sizeof(int) );
for( int i = 0; i < 10; i++ )
   scanf("%d", &nums[i]);   // we just need the & to get the address of the array cell

free

Remember to delete your memory allocation when you're finished with your arrays!

The C equivalent of delete is the function free:

 
free(intArr);
free(doubles);

Strings

Null character

As we learned from the previous lecture, strings in C are instead explicit arrays of chars. There is a small catch, though:

The final char of your array must be a null character (ASCII code 0).

So, if you were to encode the word "hi" as a C string, you would need an array of size three:


char str[3];
str[0] = 'h';
str[1] = 'i';
str[2] = 0; //alternatively, the character '\0'
print("%s\n", str);

Using c-style strings

#include <string.h>

This library provides a wide variety of useful string functions in string.h.

Copying: strcpy()

You can copy strings using the strcpy function. The prototype is as follows:

char* strcpy(char* s_to, const char* s_from);

This function copies string s_from to s_to. For conveniece, the function returns s_to as well.

Sample code:


#include <iostream>
using namespace std;

string s1;
s1 = "hello world";
cout << s1 << endl;


#include <string.h>


char s1[128];
strcpy(s1, "hello world");
print("%s\n", s1);

Comparing strings and length of a string: strcmp(), strlen()

You can compare two strings using strcmp function. The prototype is as follows:
```
int strcmp(const char* a, const char* b);
```
This function compares strings a and b.
- If they are equal, then it returns 0.
- If a is smaller than b, it returns a negative value.
- If a is larger than b, it returns a positive value.
You can get the length of a string using strlen function.

Sample code:


#include <iostream>
using namespace std;

int main()
{
  cout << "two strings:" << endl;
  string s1, s2;
  cin >> s1 >> s2;

  if ( s1 > s2 ) 
    cout << s1 << " > " << s2 << endl;
  else if ( s1 < s2 ) 
    cout << s1 << " < " << s2 << endl;
  else
    cout << s1 << " = " << s2 << endl;


  cout << "length of s1=" << s1.length() << endl;

  return 0;
}


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

int main()
{
  printf("two strings:\n");
  char s1[128], s2[128];
  scanf("%s%s", s1, s2);

  if ( strcmp(s1, s2) > 0 )
    printf("%s > %s\n", s1, s2);
  else if ( strcmp(s1, s2) < 0 )
    printf("%s < %s\n", s1, s2);
  else
    printf("%s = %s\n", s1, s2);

  int len = strlen(s1);
  printf("length of s1=%d\n", len);

  return 0;
}

$ ./a.out
two strings:
alice bob
alice < bob
length of s1=5

$ ./a.out
two strings:
bob alice
bob > alice
length of s1=3

$ ./a.out
two strings:
alice alice
alice = alice
length of s1=5

Mandatory Practice Problem

Write a C program that reads data.txt containing strings and prints them out in reverse and the maximum string. For example, consider the following file data.txt

8
this function returns a length of string s

$ ./a.out
s
string 
of 
a 
length
returns 
function
this
maximum = this

Solution

Practice Problems

Write a C program solution to read n numbers from a user and print them in reverse:
```
$ ./a.out
How many? 5
5 3 9 2 3
3 2 9 3 5
```
Write a C program solution that reads the file format numbers.txt into an array. Then compute the average and find the max. Yes, this can be done without an array, but use an array for practice:
```
$ ./fileread
Average is 34.850000
Max is 94
```
Read firstname and lastname, and prints out lastname, firstname with letters capitalized.
```
$ ./name
Alan Turing
TURING, ALAN
```
See a program solution.