Lecture – Arrays

The Development of the C Language*
https://www.bell-labs.com/usr/dmr/www/chist.html

It is interesting that one of the key design aspects of the language was representation of pointers and by extension arrays.

Ryan Robucci

Lecture – Arrays

Review

Arrays in C

Array - a collective name given to a group of similar quantities
- All integers, floats, chars, etc…
- Array of chars is called a "string"
C Arrays are a contiguous block of logical memory addresses that can be accessed using the same variable name
- Logically Contiguous vs Physically Contiguous:
  program considers the block as logically contiguous, though the OS&hardware may place the array across multiple pages of memory that might be not physically continuous
C Arrays are homogeneous
- Same data type
- Offset into memory for any element can be found by multiplying the index by sizeof(type)

Declaration of Arrays

Arrays must be declared before they may be used
- type variable_name[length];
  - Type – the variable type of the element to be stored in the array
  - Variable_name – Any name of the variable to be addressed
  - Length – computer will reserve a contiguous block of memory space according to length of array in memory

Examples

double height[10];
- Type: double
- Variable name: height
- Length: 10
float width[20];
int c[9];
char name[20];
- called a string

Array Implementation in C

Array identifier alone is a variable storing the address of the first element of the array
- Typically dereferenced with offset to access various elements of the array for reading or modification
First element of array is stored at position 0, second at position 1, nth at (n-1)th position
- a[n] is accessing (n+1) $^{th}$ element of a

Initialization

Arrays may be initialized to avoid starting with unknown values using {first,second ,etc };
Uninitialized arrays are still accessible - might access garbage contents
If array size is not specified, the length of the initialization value array is used
- int a[] = {10,20,30,40};
  - same as int a[4] = {10,20,30,40};
If specified array size > values initialized, all others initialized to zero
- int a[5]={10,20,30}; //remaining values are initialized to 0
Notable shorthand for initializing all elements to 0
- int a[5] = {0};
Array assignment is not valid outside initialization
- Syntax error:
```
int a[4];
a = {10,20,30,40};
```

Arrays that live in statically-allocated memory are initialized to 0 since statically allocated memory is zeroed

#include "stdio.h"

int x[3];
void main(){
int y[3];
for (int i=0;i<3;i++){
    printf("x[%d]:%d\n",i,x[i]);
}
for (int i=0;i<3;i++){
    printf("y[%d]:%d\n",i,y[i]);
}
}

▶︎

all

running...

x[0]:0
x[1]:0
x[2]:0
y[0]:21990
y[1]:1673393008
y[2]:32765

Here are multiple runs:

x[0]:0
x[1]:0
x[2]:0
y[0]:21975
y[1]:-187125696
y[2]:32764

x[0]:0
x[1]:0
x[2]:0
y[0]:21886
y[1]:714301776
y[2]:32767

Mixing Array and non-array declaration/definition/initialization syntax

For the adventurous, you can mix array/non-array initialized/not-initialled:

int a[]={1,2}, i,k=0;

Accessing Array Elements

Accessed with a dereference and offset using the [index] operator
- After dereference, can be used like other variables of the same type
- Can be used to read and modified

Array access examples:

c[0] = 3;
c[3] += 5;
y = c[x+1] ;

int arr[]={10,20,30,40};
int c=1,d=2,x,y;
x=arr[c+d];
++arr[c+d];
y=arr[c+d];
printf("x=arr[c+d] : %d\n",x);
printf("y=++arr[c+d] : %d\n",y);

▶︎

all

running...

x=arr[c+d] : 40
y=++arr[c+d] : 41

x=arr[c+d] : 40
y=++arr[c+d] : 41

No bounds checking

dangerous and undefined results accessing memory contents outside of the array

int x=100;
int y=200;
int A[]={10,20,30,40};
int B[]={50,60,70,80};
int u=300;
int v=400;
printf("A:\n");
for (int i=-4;i<10;i++) printf("%4d: %d\n",i,++A[i]);
printf("x:%d\n",x);
printf("y:%d\n",y);
printf("u:%d\n",u);
printf("v:%d\n",v);

▶︎

all

running...

A:
  -4: 51
  -3: 61
  -2: 71
  -1: 81
   0: 11
   1: 21
   2: 31
   3: 41
   4: 1
   5: 1
   6: -2020208511
   7: 401
   8: 301
   9: 201
x:100
y:201
u:301
v:401

A:
  -4: 51
  -3: 61
  -2: 71
  -1: 81
   0: 11
   1: 21
   2: 31
   3: 41
   4: 1
   5: 1
   6: -1760518015
   7: 401
   8: 301
   9: 201
x:100
y:201
u:301
v:401

stack smashing protection

to run this example I had to disable GCC stack smashing protection

-fno-stack-protector

otherwise the following resulted

*** stack smashing detected ***: terminated
Aborted                 (core dumped)

Char Array

Character arrays can be initialized using “string literals”
- String literals are specified with double quotes and are an array of constant characters and are terminated by null character
- A null character terminates c-style strings
  - '\0' – null character
Equivalent char arrays example:
- char string1[] = "first";
- char string1[] = {'f', 'i', 'r', 's', 't', '\0'};
Can access individual characters
- if (string1[3] == 's') print("understood\n");
Length of string literal is the number of explicit characters+1
- char string[5] = "first";
  - Error: 6 characters in string literal due to null character
char string[10] = "first";
- Equivalent to char string[10] = {'f', 'i', 'r', 's', 't', '\0', '\0', '\0', '\0', '\0'};
No simple syntax for non-initial string assignment
- ```
char string[10];
string="hello";
```
  will result in a syntax error

Intialzation Example

char string[10] = "first";
printf("string:\n");
for (int i=0;i<10;i++) printf("  %d: 0x%8x %c\n",i,string[i],string[i]);

▶︎

all

running...

string:
  0: 0x      66 f
  1: 0x      69 i
  2: 0x      72 r
  3: 0x      73 s
  4: 0x      74 t
  5: 0x       0 
  6: 0x       0 
  7: 0x       0 
  8: 0x       0 
  9: 0x       0

string:
    0: 0x      66 f
    1: 0x      69 i
    2: 0x      72 r
    3: 0x      73 s
    4: 0x      74 t
    5: 0x       0 
    6: 0x       0 
    7: 0x       0 
    8: 0x       0 
    9: 0x       0

scanf()

Function for taking input from stdin
Example: scanf("%s", string1);
- %s Reads characters from stdin until whitespace encountered
  - Can write beyond end of array

in general avoid scanf() with %s -- it is dangerous

use of scanf and %s is sufficient at first for learning C, but safer alternatives that avoid buffer-overruns will be explained in a later lecture

Example Program

#include <stdio.h>
int main(){
  char string1[11]="^^^^^^^^^^", string2[]="string";
  int i;
  printf("Enter a string: ");
  scanf("%s", string1);
  printf("string1 is: %s\nstring2 is: %s\n",
              string1, string2);
  for(i=0;string1[i]!='\0';i++)
    printf("%c",string1[i]);
  printf("$\n");
  for(i=0;i<11;i++)
    printf("[%2d] 0x%2x, %c\n",i,string1[i],string1[i]);
  printf("\n");
  return 0;
}

• include for printf/scanf



• prompt
• getting input using scanf
• printing strings using printf

• printing by iteration
    through char array

Enter a string: Hello there
string1 is: Hello
string2 is: string
Hello$
[ 0] 0x48, H
[ 1] 0x65, e
[ 2] 0x6c, l
[ 3] 0x6c, l
[ 4] 0x6f, o
[ 5] 0x 0, 
[ 6] 0x5e, ^
[ 7] 0x5e, ^
[ 8] 0x5e, ^
[ 9] 0x5e, ^
[10] 0x 0,

 
 
 
 
 
 
 
 
 
•NULL-termination from scanf
 
 
 
 
•NULL-termination from intialization

Multidimensional Arrays

Multidimensional Array initialization:
- Unspecified elements in given row – initialized to 0
- Rows not given – initialized to 0
Ex
- int a[3][2] = {{1},{3,4}};
- Result shown in table
  
  $\rm _{R}\ ^{C}$ 0 1
  
  0 1 0
  
  1 3 4

$\rm _{R}\ ^{C}$	0	1
0	1	0
1	3	4

Passing Arrays to Functions

functions can accept arrays by using the array declaration syntax, without a specified dimension size
- void ChangeElement(int array[ ], int index, int value);
- if you pass an array size, it is ignored since it would have no impact on storage related to the function and no bounds checking is performed
  - void ChangeElement(int array[300], int index, int value);
To pass an array argument to a function specify the name of the array without any brackets
- myFunction(myArrayName);
Arrays can be thought of as “pass by reference”
- The memory address for the array is copied and passed by value
Name of array is the address of the first element
- Knows where the array is stored in memory
Modifies original memory locations

#include <stdio.h>
void ChangeElement(int array[ ], int index, int value){
 array[index]=value;
}

void main(){
    int arr [ ]={10,20};
    ChangeElement(arr,0,99); //a becomes 99,20
    for(int i=0;i<2;i++)
        printf("[%2d]: %2d\n",i,arr[i]);
}

▶︎

all

running...

[ 0]: 99
[ 1]: 20

[ 0]: 99
[ 1]: 20

Passing Array Elements

Array elements are passed by value
- Original memory location is not modified
- Ex. myFunction(myArray[3]);
  - myArray is not modified by this function

Protecting Array Elements

const modifier will help protect contents of constant-elements by generating compiler messages
- Example message
  - warning: passing argument 1 of ‘myFunction’ discards qualifiers from pointer target type
  - note: expected ‘char *’ but argument is of type ‘const char *’
- Message is generated regardless of whether array is modified

#include <stdio.h>
void ChangeElement(int array[ ], int index, int value){
 array[index]=value;
}

void main(){
    const int arr [ ]={10,20};
    ChangeElement(arr,0,99); //a becomes 99,20
    for(int i=0;i<2;i++)
        printf("[%2d]: %2d\n",i,arr[i]);
}

▶︎

all

running...

/tank/robucci/GIT/cmpe311/Lectures/CBasics/9qyqvrxn0_code_chunk: In function ‘main’:
/tank/robucci/GIT/cmpe311/Lectures/CBasics/9qyqvrxn0_code_chunk:8:19: warning: passing argument 1 of ‘ChangeElement’ discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
    8 |     ChangeElement(arr,0,99); //a becomes 99,20
      |                   ^~~
/tank/robucci/GIT/cmpe311/Lectures/CBasics/9qyqvrxn0_code_chunk:2:24: note: expected ‘int *’ but argument is of type ‘const int *’
    2 | void ChangeElement(int array[ ], int index, int value){
      |                    ~~~~^~~~~~~~
[ 0]: 99
[ 1]: 20

code_chunk.c: In function ‘main’:
code_chunk.c:8:19: warning: passing argument 1 of ‘ChangeElement’ discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
    8 |     ChangeElement(arr,0,99); //a becomes 99,20
      |                   ^~~
code_chunk.c:2:24: note: expected ‘int *’ but argument is of type ‘const int *’
    2 | void ChangeElement(int array[ ], int index, int value){
      |                    ~~~~^~~~~~~~

Warning is based on the argument passing, not the actual operations in the code.
In the following function, the array is not modified yet the same warning is generated

#include <stdio.h>
int ReadElement(int array[ ], int index){
 return array[index];
}

void main(){
    const int arr [ ]={10,20};
    printf("arr[0]: %d",ReadElement(arr,0));
}

▶︎

all

running...

/tank/robucci/GIT/cmpe311/Lectures/CBasics/ycjdjwqas_code_chunk: In function ‘main’:
/tank/robucci/GIT/cmpe311/Lectures/CBasics/ycjdjwqas_code_chunk:8:37: warning: passing argument 1 of ‘ReadElement’ discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
    8 |     printf("arr[0]: %d",ReadElement(arr,0));
      |                                     ^~~
/tank/robucci/GIT/cmpe311/Lectures/CBasics/ycjdjwqas_code_chunk:2:21: note: expected ‘int *’ but argument is of type ‘const int *’
    2 | int ReadElement(int array[ ], int index){
      |                 ~~~~^~~~~~~~
[ 0]: 99
[ 1]: 20

code_chunk.c: In function ‘main’:
code_chunk.c:8:31: warning: passing argument 1 of ReadElement discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
    8 |     printf("%d",ReadElement(arr,0));
      |                               ^~~
code_chunk.c:2:23: note: expected ‘int *’ but argument is of type ‘const int *’
    2 | int ReadElement(int array[ ], int index){
      |                   ~~~~^~~~~~~~

arr[0]: 10

Function with Const Array

Coding rule: always provide const modifier in parameter types where appropriate even though it is optional
This rule includes arrays where elements are not modified
- Example:
```
  int AccessElement(const int a[], int index);
```
  - This function would not generate a warning when called
  - Does generate an error if attempt to modify the array in the function
- Also serves as good documentation
  - Programmer of caller function understands that though the array is passed by reference, it will not be modified

#include <stdio.h>
int ReadElement(const int array[ ], int index){
 return array[index];
}

void main(){
    const int arr [ ]={10,20};
    printf("arr[0]: %d",ReadElement(arr,0));
}

▶︎

all

running...

[ 0]: 99
[ 1]: 20

arr[0]: 10

Lecture – Arrays

Table of Contents

Review

Arrays in C

Declaration of Arrays

Examples

Array Implementation in C

Initialization

Mixing Array and non-array declaration/definition/initialization syntax

Accessing Array Elements

Char Array

scanf()

Example Program

Multidimensional Arrays

Passing Arrays to Functions

Passing Array Elements

Protecting Array Elements

Function with Const Array