Data Types, Arrays and Strings

Simple and Structured Data Types:

A simple data type can store only one value at a time. A structured data type is one in which each data item is a collection of other data items. In a structured data type, the entire collection uses a single identifier (name). The purpose of structured data types is to group related data of various types for convenient access using the same identifier. Similarly, data can then be retrieved as an aggregate, or each component (element) in the collection can be accessed individually. Furthermore, a structured data type is a user-defined data type (UDT) with elements that are are divisible, and can be used discretely or as a single unit, as appropriate.

C++ simple data types:

integral (char, short, int, long, and bool)

enum

floating (float, double, long double)

C++ structured data types:

array

struct

union

class

***Even though individual characters in a string can be accessed, the string data type is not considered a structured data type.

Arrays

Description:

Array: collection of fixed number of components (elements), wherein all of components have same data type
One-dimensional array: array in which components are arranged in list form
Multi-dimensional array: array in which components are arranged in tabular form (not covered)

Array Basics:

Consecutive group of memory locations that all have the same type
The collection of data is indexed, or numbered, and at starts at 0
Position number is formally called the subscript or index

First element is subscript 0 (zero), sometimes called the zeroth element.
The highest element index is one less than the total number of elements in the array

Declaring Arrays:

Syntax to declare one-dimensional array:


//intExp evaluates to positive integer--indicates number of elements 
 dataType arrayName[intExp];

//declares array num containing 5 elements of type int:
//num[0], num[1], num[2], num[3], and num[4]
int num[5];

Index (intExp), any expression whose value is non-negative integer
intExp indicates number of elements
Size of array: number of elements
Compiler reserves the appropriate amount of memory

Initializing Arrays:

Accessing Array Elements:

Syntax to access array element:


  //Index value (intExp) specifies position of element in array
  arrayName[intExp]

  //fifth element in array num
  num[4];

Index (intExp), any expression whose value is non-negative integer
Specific index value (e.g., num[0]) indicates position of element in array
Position number: distance from 1st element of array, beginning at 0 (zero)
Index value indicates position of element in array
Array subscripting operator []
Array index always begins at 0


  //declare array item with five elements of type int
  int item[5];

  //assign value 35 to 5th element in item array
  item[4]=35;

  //assign value 10 to 4th element in item array
  item[3]=10;

  //assign value 45 to 3rd element in item array
  item[2]=item[3] + item[4];

Processing One-Dimensional Arrays (basic array operations using iteration):

Initialize
Input
Output
Sum and Average
Find largest element value
Find smallest element value


  //initialize named constant
  const int arraySize=5;

  //declare array list with arraySize elements of type double 
  double list[arraySize];

  //initialize 7 variables
  int i=0;
  double smallest=0.0;
  double largest=0.0;
  double sum=0.0;
  double average=0.0;
  int maxi=0;
  int mini=0;

  //1. initialize each element in array list to 0.0, beginning w/first element
  for (i=0; i < arraySize; i++)
    list[i]=0.0;

  //2. input value for each element in array list, beginning w/first element
  for (i=0; i < arraySize; i++)
    cin >> list[i];

  //3. output value for each element in array list, beginning w/first element
  for (i=0; i < arraySize; i++)
    cout << list[i] << " ";

  //4. sum and average elements in array list, and display
  for (i=0; i < arraySize; i++)
    sum = sum + list[i];
    average = sum / arraySize;

    cout << "Sum = " << sum;
    cout << "\nAverage = " << average;

  //5. find largest element value in array list, and display
  for (i=0; i < arraySize; i++)
      if (list[maxi] < list[i])
	 maxi = i;
      largest = list[maxi];
      
    cout << "\nLargest = " << largest;

  //6. find smallest element value in array list, and display
  for (i=0; i < arraySize; i++)
      if (list[mini] > list[i])
	    mini = i;
	smallest = list[mini];
  
    cout << "\nSmallest = " << smallest;

Array Index Out of Bounds


  //declare array with 10 elements of type double
  double num[10];

  //declare index variable
  int i;

Index out of bounds: no implicit safeguard; programmer must protect against indices out of bounds
Element num[i] valid index only if i = 0, 1, 2, 3, 4, 5, 6, 7, 8, or 9
Index of array within bounds: index >=0 AND index <=ARRAY_SIZE - 1
index out of bounds: index < 0 OR index > ARRAY_SIZE - 1
***Index value must always be less than size of array

Array Initialization

Like simple variables, arrays can be initialized during declaration
When initializing arrays, not required to specify size of array
Size of array determined by number of values within braces


double sales[] = {12.25, 32.50, 16.90, 23, 45.68};

//same result as...
double sales[5] = {12.25, 32.50, 16.90, 23, 45.68};

Using a loop


// Fig. 7.3: fig07_03.cpp
// Initializing an array's elements to zeros and printing the array.
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
   int n[ 10 ]; // n is an array of 10 integers

   // initialize elements of array n to 0
   for ( int i = 0; i < 10; ++i )        
      n[ i ] = 0; // set element at location i to 0

   cout << "Element" << setw( 13 ) << "Value" << endl;

   // output each array element's value
   for ( int j = 0; j < 10; ++j )        
      cout << setw( 7 ) << j << setw( 13 ) << n[ j ] << endl;
} // end main

Using an Initializer List

// Fig. 7.4: fig07_04.cpp
// Initializing an array in a declaration.
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
   // use initializer list to initialize array n
   int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
   
   cout << "Element" << setw( 13 ) << "Value" << endl;

   // output each array element's value
   for ( int i = 0; i < 10; ++i )
      cout << setw( 7 ) << i << setw( 13 ) << n[ i ] << endl;
} // end main

Specifying Array Size with Constant and Setting Array Elements with Calculations

// Fig. 7.5: fig07_05.cpp
// Set array s to the even integers from 2 to 20.
#include 
#include 
using namespace std;

int main()
{
   // constant variable can be used to specify array size
   const int arraySize = 10; // must initialize in declaration
   
   int s[ arraySize ]; // array s has 10 elements

   for ( int i = 0; i < arraySize; ++i ) // set the values
      s[ i ] = 2 + 2 * i;

   cout << "Element" << setw( 13 ) << "Value" << endl;

   // output contents of array s in tabular format
   for ( int j = 0; j < arraySize; ++j )   
      cout << setw( 7 ) << j << setw( 13 ) << s[ j ] << endl;
} // end main

Array Partial Initialization

Be careful when partially initializing arrays (may return unexpected results)
Initialize all elements to zero
If there are fewer values in the Initializer List then the remaining elements are initialized to zero
If there are no values in the Initializer List then all elements are initialized to zero
Following statement declares array num with 5 elements, and initializes ALL elements to zero (0):

int num[5] = {0};

Following statement declares array n with 10 elements and initializes all elements to 0

int n[10] = {};  //initialize all elements of array n to 0

Following statement declares array num with 5 elements,
and initializes num[0] to 8, num[1] to 5, num[2] to 12, all others to 0

int num[5] = {8, 5, 12};

Following statement declares array num with 3 elements,
and initializes num[0] to 5, num[1] to 6, and num[2] to 3

int num[] = {5, 6, 3};

Following statement declares array num with 100 elements,
and initializes num[0] to 4, num[1] to 7, all others to 0

int num[100]= {4, 7};

Array Processing Restrictions

C++ does not allow aggregate operations on arrays (e.g., assignment, reading and printing contents of array--must be done element-wise)
Aggregate operation: any operation that manipulates entire collection (e.g., array) as single unit


  int myArray[5] = {2, 4, 6, 8, 10};
  int yourArray[5];

  yourArray = myArray; //illegal assignment

Must perform member-wise copy:


  int myArray[5] = {2, 4, 6, 8, 10};
  int yourArray[5];

  //legal, member-wise copy
  for (int i=0; i < 5; i++)
    yourArray[i] = myArray[i];

Same with IO: must perform member-wise instructions:


  int myArray[5];

  cout << myArray; //illegal
  cin >> myArray; //illegal

  //legal, member-wise input
  for (int i=0; i < 5; i++)
    cin >> myArray[i];

  //legal, member-wise output
  for (int i=0; i < 5; i++)
    cout << myArray[i];

Arrays as Parameters

Arrays passed by reference only
Ampersand (&) not used when declaring array as formal parameter--still passed by reference
Can omit array size during declaration as formal parameter--ignored by compiler when specified
Base address of array passed to formal parameter

Array name is address of the first element

Good programming practice: using reserved word const in declaration of array as formal parameter
prevents function from altering actual parameter


//Function to print array:
//array and number of elements passed to parameters
//listSize specifies number of elements to be printed
void printArray(const int list[], int listSize)
{
int counter;

for (counter = 0; counter < listSize; counter++)
  cout << list[counter] << " ";
}

In function call statement, when passing array as actual parameter, only use array name--NO brackets ([]):


//Call to function printArray(), list is one-dimensional array
//arraySize is scalar variable of type integer
printArray(list,arraySize);

Array's Base Address:

Base address: memory location of first array element
Example: if num is one-dimensional array,
base address of num is address (memory location) of num[0]
When passing arrays as parameters, base address of array passed to formal parameter
Functions cannot return value of type array

Intro to Vectors

C++ Standard Template Library class template vector
Capabilities that are not provided for C style pointer-based arrays
More robust type of array
Can be defined to store any data type using following format
```
  vector< type > name( size );
```
Vectors use template notation (not covered yet)
More powerful, less error prone alternative to arrays
Access to member functions
See Fig 7.25

Arrays vs. Vectors

Problems with Arrays vs. Vectors (and other containers: list, map, etc.):

An array is a homogeneous data structure (elements have same data type) that stores a sequence of consecutively numbered objects--allocated in contiguous memory. Each object of the array can be accessed by using its number (i.e., index). When you declare an array, you set its size. (It's possible to create "dynamic" arrays, but still array sizes, once set, cannot be altered). The array cannot hold any more elements than its initial size. For example:
int myArray[] = new int[5];
This snippet of code will create an array (on the "heap" or "free store" memory, using the new keyword) holding up to five integers. If more elements are desired (say, a 6th or 7th integer), a larger array will need to be declared, and all of the elements from the old array copied into the new one--and adding the 6th or 7th integer to the new array.

For these and other reasons, arrays can be difficult to use reliably...

What's wrong with arrays?

Unknown size: arrays don't know their own size

Fixed size: can't modify once set

Lack of subscript (range) checking: can go out-of-bounds, (cause for buffer overflow)

Array name converts to a pointer to its first element (potentially causing problems--any of the above)

Vector benefits:

easier to write

easier to read

less error prone

in many applications, just as fast, also...

inherent support to: add new elements beyond current size, resize, sort, search, erase elements, etc.

  void f(int a[], int s)
  {
      // do something with a; the size of a is s
      for (int i = 0; i < s; ++i) a[i] = i;
  }

  int arr1[20];
  int arr2[10];

  void g()
  {
      f(arr1,20);
      f(arr2,20);
  }

The second call will write all over memory that doesn't belong to arr2. Generally, a programmer will get the size right, but it's extra work, and, sometimes, every so often someone makes the mistake. A simpler and cleaner version using the standard library vector:

  void f(vector& v)
  {
	// do something with v
	for (int i = 0; i < v.size(); ++i) v[i] = i;
  }

  vector v1(20);
  vector v2(10);

  void g()
  {
	f(v1);
	f(v2);
  }

Since an array doesn't know its size, there can be no array assignment:

  void f(int a[], int b[], int size)
  {
	a = b;	// not array assignment
	memcpy(a,b,size);	// a = b
	// ...
  }

Again, vector:

  void g(vector& a, vector& b, int size)
  {
	a = b;	
	// ...
  }

Another advantage of vector here is that memcpy() is not going to do the right thing for elements with copy constructors, such as strings.

  void f(string a[], string b[], int size)
  {
	a = b;	// not array assignment
	memcpy(a,b,size);	// disaster
	// ...
  }

Using vector...

  void g(vector& a, vector& b, int size)
  {
	a = b;	
	// ...
  }

An array is of a fixed size determined at compile time (unless placed on the "free store" or "heap" and accessed through pointers):

  const int S = 10;

  void f(int s)
  {
	int a1[s];	// error
	int a2[S];	// ok

	// to extend a2, must change to an array
	// allocated on free store using malloc() and use realloc() (C-style)
	// ...or, use new and delete (C++-style)
  }

In contrast using vectors:

  const int S = 10;

  void g(int s)
  {
	vector v1(s);	// ok
	vector v2(S);	// ok
	v2.resize(v2.size() * 2);
	// ...
  }

Benefits of Arrays over Vectors:

Notational support for initialization or arrays (not with vectors)

char myChar[] = "Test"; //array of 4 characters

A vector is a container class while an array is an allocated memory
Can directly access element of array from memory, in vector or other container classes, must use specific functions.

Consider the following snippet of code...

static const char* suits[4] = { "Hearts", "Diamonds", "Clubs", "Spades" };

Will this list change during the program life-cycle? No. Will members need to be manipulated, searched, or various other operations performed? No. We just need a reference list. Do we need a vector? No.

Much of the time, just need to allocate space for storage. That is, hold some data somewhere. The art of programming is choosing the right tool for the job.