SI204: Structs 4: Operator overloading and static arrays

Previously in SI204 ...

We saw how programs get broken up into pieces using using .h files and #include. This lecture we'll look into more detail about how that's done, the organization benefits of doing it, and a few of the pitfalls. We considered a program like this:

point.h point.cpp main0.cpp


struct point {
  double x, y;
};
void read(point&);


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

void read(point& p) {
  char c;
  cin >> c >> p.x
      >> c >> p.y >> c;  
}


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

int main() {
  point p;
  read(p);
  cout << "dist is " 
       << sqrt(p.x*p.x + p.y*p.y) << endl;
  return 0;
}

When a program consists of multiple .cpp files like this, you can compile each .cpp file separately, and then link, like this:

~/$ g++ -c point.cpp            compiles point.cpp to produce  point.o
~/$ g++ -c main0.cpp            compiles main0.cpp to produce main0.o
~/$ g++ -o ex0 main0.o point.o  links point.o and main0.co to produce executable ex0

... or you can compile and link it all at one go, like this:

~/$ g++ -o ex0 main0.cpp point.cpp

Large programs can take minutes or even hours to compile from scratch. When you compile separately, a change in one .cpp means only that .cpp needs to be recompiled - for the rest, the old .o files can be reused. So separate compilation is the way to go once projects start to grow.

The Rules in Short

Now, there's one problem that can come up, which is illustrated by the following example:

The way around this problem is to guard your .h files with #defines. The #include that we've been using and the #define that we're about to use are examples of "preprocessor directives". The #define lets you give a string x and say "every time you see x in the source code, replace it with string y." This can be used and abused in all sorts of ways, but for the moment we'll simply use #define to determine whether or not this is the first time the compiler has seen our .h while compiling a give .cpp file. We can test whether or not a certain string has been #defined already using the #ifndef preprocessor directive, which we read as "if not defined". For example

Golden rule number 2: All .h files should be "protected" by #ifndefs this way!

Operator Overloading: a little something fun

C++ allows the programmer to make new types that really act like the builtin types, by which I mean that the usual operators, like *, <, ++, work with the new types, and I/O with << and >>, and so on.

There's actually some controversy about this, i.e. about whether or not it's a good idea to let programmers do this. Some people feel that it leads to hard-to-follow code.

In any event, it's not going to be a major theme for this course, but I'd like to show it to you so that you understand that we really can build new types in C++ if we want to. Also, I should note, this is why + and >> and so on work with C++ string objects. The implementers of the string library defined all these operators for their nice string type.

Simple program

So if you want to tell the compiler what + means for two point objects, you need to define the function operator+(point a,point b) --- i.e. overload the + operator for points. The prototype is clear:

Note

"Operator overloading" is the term used for defining versions of the C++ operators for the new structs we define. In general, if you have an expression A Π B, where "Π" stands for some operator, then that is equivalent to a function call operatorΠ(A,B). So, to subtract two points we'd define

point operator-(point A, point B);

... and to compare two points with less than we'd define

bool operator<(point A, point B);

... or to multiply a point (on the left) by a real number (on the right) we'd define

point operator*(point A, double w);

I/O and overloading

Static Arrays

Dynamic arrays vs static arrays

The other kind of array is static. A static array is local to the scope in which it is declared. It also means you can't pass around pointers to the array, so you won't be returning or sending static arrays to and from functions. Common practice is to use static arrays when you know the size of the array at compile-time. It's easy to create them inside of a struct, if you know you always need 10 ints, for instance.

Dynamic arrays are more general - anything you can do with static arrays you can do with dynamic arrays, and then some. However, in some instances static arrays are simple - for example 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.

Syntax

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.

Difference between dynamic and static arrays

You see that in the static array version the array of vertices is embedded in the Quad object. In the dynamic version, the pointer is embedded in the object, while the array is outside of the object, somewhere else in memory. Compare the static array version of main with the dynamic array version of main.

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: Suppose that I have a Quad object S that contains the label 'Q' and the vertices (0,0) (1,0) (1,1) (0,1). I then print out S and then R. What will I get?

A: It depends whether I'm using the static version of Quad or the dynamic version. (Drag your mouse for answers)

This is not a reason to use static over dynamic, but it is a good example of how and why they behave differently.

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 picture should tell you that while the result it 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.

point.h	point.cpp	main1.cpp
`struct point { double x, y; }; void read(point&);`	`#include "point.h" #include <iostream> using namespace std; void read(point& p) { char c; cin >> c >> p.x >> c >> p.y >> c; }`	`#include "point.h" #include "triangle.h" int main() { triangle T; read(T); point P = T.vertex[0]; return 0; }`
triangle.h	triangle.cpp
`#include "point.h" struct triangle { point* vertex; }; void read(triangle&);`	`#include "triangle.h" void read(triangle& t) { t.vertex = new point[3]; for(int i = 0; i < 3; i++) read(t.vertex[i]); }`

Creating an Array of 6 `int`s
Static Array	Dynamic Array
`int A[6]`	`int *A = new int[6]`

Static Version	Dynamic Version
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)

Multi-File with Structs