Win32 Programming Lesson 4: Classes and Structures

Last Time…  We covered a quick overview of C++  Now, we look in more detail at the way classes work  This is important, as you’ll need a working knowledge in order to interoperate with Win32 APIs

Classes  Remember Structures?  Well, it’s pretty handy to be able to combine the functions that use or manipulate the structure and the data itself  That’s basically a class

Stacks  Imagine a stack Remind me…  Now, for a stack we want to be able to push and pop things off it  Could implement in a struct… but can’t protect from direct manipulation  Solution: A Class

Simple Class stack  Fairly simple: class stack { private: int count; // Number of items on stack int data[STACK_SIZE]; // The items themselves public: // Initialize the stack void init(); // Push an item on the stack void push(const int item); // Pop an item from the stack int pop(); };

Member Variables  In our stack, we declare two private member variables We don’t want direct manipulation Three levels of protection:  Public – anyone can access  Private – nobody outside the class  Protected – similar to private except allows access from derived classes

Functions  inline void stack::init() { count = 0; //Zero the stack counter… }  Zeroes the stack counter, and gets the stack ready for useful work

Similarly…  inline void stack::push(const int item) { data[count] = item; count++; } inline int stack::pop() { --count; return(data[count]); }

Using our stack…  stack a_stack; // Stack we want to use a_stack.init(); // Initialize the count… a_stack.push(1); a_stack.push(2); std::cout << “Stack top: ” << a_stack.pop() << “\n”;

Our stack shortcomings…  There are several… Let’s focus on just one: initialization Before we use the stack, it would be nice if we didn’t rely on the programmer to initialize it!

Constructor  We can create a constructor which is called automagically…  Add: // Initialize the stack stack(); inline stack::stack() { count = 0; } No longer need stack.init()!

Destructor  Sometimes it is important to know when a class is being destroyed For example, a class which internally allocates memory must free the memory when it exits Thus, there are destructors… inline stack::~stack() { if (count !=0) std::cerr << “Warning: non-empty stack\n”; }

Parameterized Constructors  Sometimes, it’s handy to force a constructor to take parameters that initialize the class  For example, a class which holds firstnames and lastnames might require these on instantiation Example: person(const std::string fname, const std::string lname);

friend Functions  Suppose we wished to compare two of our stacks…  The member variables are private!  Solution: make everything public (doh!)  Better solution: the friend keyword  Can define a friend function or a friend class which has access to the private members of the class

static variables  Suppose you want to keep a running total of how many stacks you have at one time  Could declare a global variable outside the class, but this is pretty ugly  Instead, declare a static inside of private… private: static int stack_count; Tells the system that there is only ever one stack_count variable, no matter how many stacks we create

Classes…  There’s a lot we haven’t covered in classes and C++ right now – inheritance, overloading, all that good stuff  But what we have is enough to get you started with the Win32 APIs  Remember, learning C++ in this class is a means to an end, not an end in itself

Pointers & Classes (OOH!)  Just to mess with your heads… and because it’s useful  Classes can also contain pointers  This provides a really neato™ way of constructing linked lists

Consider  class item { public: int value; item *next_ptr; }  next_ptr is a pointer to another item  We can create an object with the new syntax: class item *new_ptr; new_ptr = new item;

delete  If new creates an object out of thin air (actually, the heap, but we’ll get to that later)…  We must delete it  Use: delete pointer; pointer = NULL; // Not needed, but good habit Warning deleting pointers to arrays is different (look this up)

Example: Linked list  You can create a linked list quite easily, by creating two different classes: a link_list container and a class which holds the data elements  Hint: you’ll need to use the friend notation to make sure you can manipulate the pointers…

Here…  class linked_list { private: class linked_list_element { public: int data; // Data in this el. private: // Pointer to next element linked_list_element *next_ptr; friend class linked_list; }; public: linked_list_element *first_ptr; // First element // Initialize the linked list… linked_list() {first_ptr = NULL;} // Other member functions… };

Adding to the list…  void linked_list::add_list(int item) { linked_list_element *new_ptr; new_ptr = new linked_list_element; (*new_ptr).data = item; (*new_ptr).next_ptr = first_ptr; first_ptr = new_ptr; }

Assignment Part I  Just a quick test of SVN  You should have an SVN repository at:  In it, you will find a project a0. Read the comments and fix it!  Due Tuesday, before class. It should take you no more than 30 mins

Assignment Part II  Create a program which does the following: Implements a doubly-linked list – that’s a linked list which is linked backward and forward – in a class Populates it with X random integer values, between 0 and MAX in value, where X and MAX are taken from the command line:  “dblprog 20 40” would create a linked list with 20 random values in the range Prints the list out forwards and then in reverse Demonstrates inserting a value in position 7, and printing the list again You must use a class for this! Program should be a command line program in Visual C Think carefully about what to check in. Make sure when you check it out elsewhere it still builds! Please name your project “dblprog” – that way, we can grade just by cutting and pasting Due: 7 days from now before class starts. Make a new project in your repository called a1 (just like a0 that’s already there).