Welcome to Programming and Data Structures

In C++, the simplest way to create a new aggregate data type is by defining a struct. A struct is a collection of variables, possibly of different types, that are grouped together under a single name.

As a simple example, let us consider a point in the x, y plane. In mathematical notation, points are often written in parentheses, with a comma separating the coordinates. For example, \((0, 0)\) indicates the origin, and \((x, y)\) indicates the point \(x\) units to the right and \(y\) units up from the origin.

To create a new data type that represents a point, we can use this struct definition:

struct Point {
  double x, y;
};

This definition indicates that there are two elements in this structure, named x and y. These elements are called instance variables or members.

The struct definition must appear before it is used and be in scope where you use it. This means that they generally appear outside of any function definition, usually at the beginning of the program (after the include statements) so that they are available in all the functions. If building a program in multiple files, the struct definition generally goes into a header or module file that other files can import or include to make use of.

A struct defines a new type of data. Think of it as a “blueprint” that describes how to build an item of that type. struct Point does not actually create a point anymore than the blueprint of a house gives you something to live in. To actually make a point that we can work with, we need to create a variable using the new data type that has been defined. The value that is created is referred to as an instance of the struct.

Point blank;
blank.x = 3.0;
blank.y = 4.0;

The first line is a conventional variable declaration: blank has type Point. The next two lines initialize the instance variables of the structure. The “dot notation” used here is similar to the syntax for invoking a function on an object, as in fruit.size().

The result of these assignments is shown in the following state diagram:

As usual, the name of the variable blank appears outside the box and its value appears inside the box. In this case, that value is a compound object with two named instance variables.

struct Point() {
  double x, y;
};

int main() {
  Point nice;
  ???
}

struct Point {
   double x, y;
};
int main() {
   Point blue;
   blue.x = 3.0;
   Point.x = 3.0; 
} #distractor