Win32 Programming

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 usea_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 stackstack(); • 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: https://cs.fit.edu/smsvn/<tracks-username> • 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 0-40. • Prints the list out forwards and then in reverse • Demonstrates inserting a value 31337 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++ 2013 • 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).

Win32 Programming