In this lesson we're going to introduce you to a 
really new, fascinating part of C++.
Up to this point, all you could declare in a  
program was the basic, built-in, primitive C++ 
types.
Shorts and ints and bools and strings and 
characters.
And there's not a whole lot that you can do what 
those individually.
Suppose that you wanna write a program to take 
care of the inventory of a business.
You can't hardly do that with ints and strings and 
characters, unless you were able to combine 
them in to
structures. Bags of variables that you could carry 
around.
And that's exactly what a struct is. So, a struct is 
your introduction to object oriented
programming. Get into a lot more details when 
we look at classes,
but this is just an introduction. It allows you to 
declare an abstract kind of object and so, we call 
them objects instead of variables.
So, you can build programs to better
simulate the real world. You can make types for 
tables and chairs and buildings and students and 
trees and whatever you want.
So, you are going to take different types and 
bundle them together into one
type that you name yourselves. Let's take a look 
at the syntax. For a struct, it is going to be the 
keyword "struct",
the type name, and then member variables.
So, in this case in our example, you're going to 
place this in its own header file called say, 
"point.h".
The keyword struct indicates to the compiler that 
this is a type that you are inventing. You're going 
to name it
"point" (that's the type name) and then your 
member variables
will be, the first one is a member variable of type 
float
and its name is "m_Xcoord".
Now, I prefer to use the "m_" as a prefix to the 
names of variables that are members of
structs and classes. Classes will come later.
That way when you see that variable name in the  
future in the program, you know that it's a 
member variable of some user defined type.
So, in this case we have two floats in "m_X", 
"m_Y",
and the last point I want to make is, don't forget 
that semicolon! The semicolon at the end of the 
definition is extremely important if you forget it,
you'll generate I don't know how many errors. 
Dozens upon dozens. I counted once, it's 73, but 
that was several years ago.
I don't know what it'll give you now. Don't forget 
that semicolon after the definition of a struct or a 
class.
So, let's take a look. You see what our definition 
for "point" is, it's two floats one for the X value, 
one for the Y value. Now, suppose that I declare
a point. Well the declaration is just like any other 
declaration. Just like you're declaring and int or a 
character or a bool or anything. It's always
type and name. Type and name. So, "p1" and 
"p2" are of type point. Each one of those objects 
contains two floats.
So, one float is what? It's 4 bytes. There are two 
floats, there are 8 byes in each, there are 16 byes 
of memory declared in this line of code.
So each one of these guys "p1" and "p2", have an 
x-coordinate and a y-coordinate. How to I access 
the member variables of an object
of type struct? You use a new kind of operator, it's 
called the "dot operator".
And there it is. To make sure you see it, I got an 
extra big arrow. To make sure that you 
understand that it is a dot, there it is and,
just emphasize, that is the operator. The dot 
operator, so
to assign to the x-coordinate of "p1", I
have to write then, "p1.m_Xcoord" and then the 
usual assignment.
I want to make something very clear to you. What 
is this? It is a point. A point object. But what is 
this? It is a float.
And you can treat it just like you treat any float any 
other instance.
So if I want to read into the y-coordinate the value 
six, there it is.
If I want to write it out, then I can write it out, as 
such. That's just a float.
Structs within structs. Well, of course you can 
use the type, what you've defined a type, say 
point here,
you can use that in another type. So, I can 
