Start Microsoft Visual Studio 2012 and create a new CLR Console Application project named Structs.

At the top of the Structs.cpp file, immediately below the using namespace System; line, add the following structure definition:

// The Point structure definition
value struct Point
{
    int x, y;
};

The value and struct keywords start a structure definition, and you’ll notice that structures look very similar to classes in the way that they are defined. The body of the structure is enclosed in braces and finishes with a semicolon, and the public and private keywords can be used to set the access level for structure members.

Notice the use of the value keyword here. This keyword instructs the compiler that this is a .NET value type and not a traditional C++ structure. It’s important that you remember to use value when defining your structures.

This simple structure represents a point on a graph, so it has two integer data members representing the X and Y coordinates.

To create and initialize a Point object, add the following lines to the main function of your application:

// Create a Point
Point p1;

// Initialize its members
p1.x = 10;
p1.y = 20;

Notice that the code doesn’t use the gcnew operator. The gcnew operator is used to create references to objects, and value types aren’t accessed by reference. Instead, a Point has been created on the program stack, and you access it directly as p1. Because the data members are public at this point, you can access them by using the familiar dot notation.

Add two lines to print out the value of one of the structure members, like this:

Console::WriteLine("p1.x is {0}", p1.x);

Compile and run the application.

At this point, you should see the output “p1.x is 10”.

If you closed the Structs project, open it again and open the source file Structs.cpp.

Insert a debug breakpoint by clicking in the gray border to the left of the code. Click next to the declaration of p1.

A red dot appears in the border, as illustrated in the screen shot that follows.

Press F5 to start the debugging session.

After the application loads, it executes and stops at the breakpoint. You can now use the Locals pane at the bottom of the window to look at the structure of the Point type.

You should see an entry for the variable p1. Any type that has internal structure—such as Point—is indicated by a plus sign (+) to the left of the variable name.

Click the plus sign to expand the structure.

The Locals pane opens, appearing similar to the one shown in the following screen shot:

You can see that p1 has three entries below it. The first shows that it’s derived from System::ValueType, which is in turn derived from System::Object. The other two are the x and y members, which are both 32-bit integers. At this point in in the code, the structure hasn’t been fully initialized, so they don’t contain sensible values.

Press F10 three times to initialize p1 and execute the next two assignment statements.

This action results in p1 being initialized, and you will see the values of x and y change to reflect the values you set. The values also change from black to red in the Locals pane, showing that they were changed in the previous execution step.

Continue pressing F10 to single-step through the code, examining the changes that occur to p1 as you execute each line. When you’re done, discontinue debugging by clicking the Stop Debugging button on the toolbar (the dark-red square), clicking the Stop Debugging command on the Debug menu, or pressing Shift+F5.

Continue using the project from the previous exercise.

Add a constructor to your Point structure so that the code looks like this:

value struct Point
{
    int x, y;
    Point(int xVal, int yVal) { x = xVal; y = yVal; }
}

The constructor takes two int values and uses them to initialize the x and y data members. In this case, the arguments are simply being copied into the data members, but it would be simple to add some checking to ensure that the data passed in is correct.

You can now add extra code to your main function to create initialized Points.

Point p2(10,20);   // use the second constructor to set x
                   // to 10 and y to 20
Console::WriteLine("p2.x is {0}", p2.x);

Build and run the application. Check that the result is what you expect.

Create a new CLR Console Application project named Person.

At the top of the file, immediately below the using namespace System; line, add the structure definitions for Date and Person.

In the main function, create a Person object. Remember that you don’t use gcnew, because structures are value types.

// Create a Person
Person p1;

Fill in the values for the fields.

// Fill in the name
p1.name = "Fred";
p1.DOB.dd = 10;
p1.DOB.mm = 3;
p1.DOB.yyyy = 1960;

Notice how structure data members are accessed. Because the DOB member has members of its own, you simply extend the dot notation to another level to access its members. You can continue this nesting to as many levels as you like, although it is unusual to go much deeper than you’ve done here.

You can also initialize all the members of Person in one line. Remove the four initialization lines you entered in step 4 and then change the line where you create the Person.

Person p1 = {"Fred", {10, 3, 1960}};

Can you see what is going on here? The data in the braces—called an aggregate initializer—provides data for the initialization of the structure. The Person structure contains two items: a String and a Date. Therefore, there are two items in the list. Because Date has members of its own, its entries are also enclosed in braces.

If you decide that the date of birth is wrong, you can simply create a new Date and copy it into the Person object, such as in the following:

// Create a new Date
Date newDOB = {1, 4, 1955};
p1.DOB = newDOB;

The new Date takes the values specified in the initializer and then copies it into the Person object, overwriting the values in the Date that’s already there.

You can see the configuration of the Person structure by running the application under control of the debugger. Place a breakpoint in the application at the line where p1 is created by clicking in the gray margin to the left of the code.

Press F5 to start the debugging session.

After the application loads, it executes and stops at the breakpoint. You can now use the Locals pane at the bottom of the window to look at the structure of the Person type.

Click the plus sign to the left of p1 in the Locals pane to expand the structure of Person.

Observe that it has Name and DOB members, and if you click the plus sign to the left of DOB, you can expand its structure, as well.

Press F10 to step through the code until all the members are initialized.

The members of p1 display in red as each value changes.

When you’ve finished, press Shift+F5 to stop debugging or, on the toolbar, click the Stop Debugging button.

Create a new CLR Console Application project named Enums.

At the top of the Enums.cpp file, immediately below the using namespace System; line, add the following structure definition:

// The Weekday enum definition
public enum class WeekDay
{
    Monday, Tuesday, Wednesday, Thursday, Friday,
    Saturday, Sunday
};

The enum class keywords start an enumeration definition, and you’ll notice that, once again, enums are defined similarly to classes. The body of the enumeration is enclosed in braces and finishes with a semicolon. The use of the enum and class keywords indicates to the compiler that this is a value type and not a traditional C++ enumeration.

The enumeration itself consists of a comma-separated set of names, each of which represents an integer constant.

You create enumeration variables the same as you create any other type. To create and initialize a WeekDay object, add the following lines to the main function of your application:

// Create a WeekDay
WeekDay w = WeekDay::Monday;

As with structures, the code doesn’t use the gcnew operator. An enumeration variable of type WeekDay has been created on the program stack, and you access it directly as w. Notice how the enumeration variable is initialized with one of the members of the enumeration. This syntax is how you initialize enumeration variables and how you can change their values later on.

Try printing out the value of the WeekDay object like this:

Console::WriteLine("Value of w is {0}", (int)w);

The value 0 should be printed. Each of the named constants making up the enumeration represents an integer value. By default, these values start from 0 and increase by one for each subsequent member of the enumeration. You can test this output by changing the value that you initially assigned to w, for example, WeekDay::Saturday. When you run the code again, the value 5 should print.

You must cast the enumeration to an int in order to be able to print it; you will get an error if you try to print the enumeration without casting it.

It would be good to be able to print out the symbol associated with the enumeration as well as its numeric value. You can do this using the Format member of the Enum base class, as in the following example:

String ^s = Enum::Format(WeekDay::typeid, w, "G");
Console::WriteLine("The day is {0}", s);

Format needs to be informed as to the type of the enumeration, which you do it by using Enum::typeid and the value itself. The “G” indicates the format for the conversion: this is general format, which means a string.

Continue using the project from the previous exercise. If you’ve closed it, on the File menu, click Open Solution to open the project again.

After the WriteLine statements, add the following switch statement code:

// Switch on the weekday
switch(w)
{
case WeekDay::Monday:
    Console::WriteLine("It's a Monday!");
    break;
case WeekDay::Tuesday:
    Console::WriteLine("It's a Tuesday!");
    break;
case WeekDay::Wednesday:
    Console::WriteLine("It's a Wednesday!");
    break;
default:
    Console::WriteLine("It's some other day...");
}