Static Arrays

Dynamic arrays vs static arrays

int A[6];

int* A = new int[6];

• Dynamic arrays: What we've seen so far. The size of the arrays can change from run to run of the program.

  If your program creates and array to store data in a file, and the file (rather than you the programmer) is what determines how many elements ought to be in the array. The size of the array is bound to change from run to run of the program, because the file may change.

• Static arrays: A static array has its size determined and fixed when the program is compiled, so from run to run of the program the array's size is always the same.

Q: For a static array A, do you have to delete [] A, when you don't need it anymore?

No. (Only when A is created by new int [6]). 

You can sometimes write simpler code using static arrays

• (Names of the week) If you wanted to hardcode the names of the days of the week into a program, you know the size will be 7, so there's no point in making a dynamic array.
• (Vertices of a quadrilateral) Consider a program that uses an array to store the vertices of a quadrilateral. Since we know that a quadrilateral always has exactly four vertices, we could use static arrays.

  
  struct Quad
  {
    char label;
    point vert[4];
  };
  

Difference between dynamic and static arrays

To understand the difference between this version of Quad and the previous version, consider this picture:

Note:

• In the dynamic version, the pointer (instead of the array) is embedded in the Quad object; the array is outside of the Quad object, somewhere else in memory.
• In the static version, the entire array vert is embedded in the Quad object.

The above picture really tells you all you need to know to understand the difference between using static and dynamic arrays ... when you really can use static arrays.

Q: Can you change the contents of a static array?

A: Of course, yes

Quick check

Q (0,0) (1,0) (1,1) (0,1)
Q (0,0) (1,0) (1,1) (0,1)
P (1,0) (2,0) (2,1) (1,1)

Q (0,0) (1,0) (1,1) (0,1)
Q (1,0) (2,0) (2,1) (1,1)
P (1,0) (2,0) (2,1) (1,1)

// step 1
Quad S;
...       // S has 'Q' and (0,0), (1,0), (1,1), and (0,1) 
print(S); // It will print Q (0,0) (1,0) (1,1) (0,1)

// step 2
Quad R;
R = S;    // Copying will have different meanings!
R.label = 'P';    

// step 3
for(int i = 0; i < 4; i++)
  R.vert[i].x++;

print(S);
print(R);

Dynamic Version	Static Version

Swapping the static arrays

Q: How does swap(A,B) behave differently for two Quads, A and B, with the dynamic versus static array versions of Quad?

A: Once again, the above picture should tell you that while the result is the same, a lot more work gets done in the static case, where the entire contents of the arrays are swapped, rather than simply the pointers.

Guarding header files

Rule for struct definition

• A struct's definition may appear in as many files as you like, but only once per .cpp file.

Problem

struct point
{
  double x, y;
};
point readpoint();

#include "point.h"
#include <iostream>
using namespace std;

point readpoint()
{
  point p;
  char c;
  cin >> c >> p.x
      >> c >> p.y >> c;  
  return p;
}

#include "point.h"     // NOTE HERE
#include "triangle.h"  // NOTE HERE

int main()
{
  triangle T = readtriangle();
  point P = T.vertex[0];
  return 0;
}

#include "point.h"
struct triangle
{
  point vertex[3];
};
triangle readtriangle();

#include "triangle.h"

triangle readtriangle()
{
  triangle t;
  for(int i = 0; i < 3; i++)
    t.vertex[i] = readpoint();
  return t;
}

$ g++ -c point.cpp
$ g++ -c triangle.cpp
$ g++ -c main1.cpp
In file included from triangle.h:1:0,
                 from main1.cpp:2:
point.h:1:8: error: redefinition of 'struct point'
point.h:1:8: error: previous definition of 'struct point'

• So, main.cpp #includes point.h. This gives the first definition of point in main.cpp
• However, main.cpp also #includes triangle.h, which in turn #includes point.h! This amounts to the second definition of point in main.cpp!

Fix: guard your header files

• The #define lets you give a string x and say "every time you see x in the source code, replace it with string y."

• The #ifndef (read as "if not defined") preprocessor directive allows us to test whether or not a certain string has been #defined already.

  
  cout << "This is ";
#ifndef SILLYSTYRING
  cout << "not ";
#endif
  cout << "much fun!" << endl;

  cout << "This is ";
  cout << "not ";
  cout << "much fun!" << endl;

  cout << "This is ";
  cout << "much fun!" << endl;

How does this help us with our multiple-definition problem?

#ifndef POINTHEADER  // NOTE HERE 
#define POINTHEADER  // NOTE HERE

struct point
{
  double x, y;
};
point readpoint();

#endif              // NOTE HERE

#include "point.h"
struct triangle
{
  point vertex[3];
};
triangle readtriangle();

#include "point.h"
#include "triangle.h"

int main()
{
  triangle T = readtriangle(); 
  point P = T.vertex[0];

  return 0;
}

1. Now, in compiling main.cpp we first #include the file point.h. Since this is the first time the compiler has seen point.h it'll find that POINTHEADER has not been defined. Therefore all the code until the #endif, which is essentially the whole file, will be seen and evaluated by the compiler. This will include the line that #defines POINTHEADER.
2. Now, the next time we come across point.h, which is when main.cpp does the #include "triangle.h", the compiler will hit that #ifndef line and will find that POINTHEADER has been defined, and therefore everything up to the #endif, which is essentially the whole file, will be ignored by the compiler. This way we never get any multiple definitions.

Practice Problems

1. Write a program that reads a date in mm/dd/yyyy format and prints it out in "dd monthname yyyy" format.

   Tip: It might be helpful to know that a static array can be initialized with a list of values in { }'s. For example, an array of the first 10 prime numbers can be constructed like this:

   int prime[10] = {2,3,5,7,11,13,17,19,23,29};

   Note: this problem is purely about static arrays, it doesn't concern structs at all. Here's a solution.