Lab 3.1 — Some CodeLab Exercises

Unlike most of the other labs that consist of small programs or class definitions (designed specifically for 3142), this lab is composed of a bunch of smaller code fragments from the standard CodeLab inventory, dealing with pointers, fairly trivial class declarations and definitions, and some simple examples of inheritance (without polymorphism). Your existing knowledge of Java class definitions (and the examples in the lecture notes) should get you most of the way through the class exercises; there's just a bit of code organization that we alluded to, that we'll elaborate upon here.

Declaration vs Definition

We've discussed this to some extent: a declaration is simply an announcement of the existence of a class, variable, or function, while a definition provides the details (the set of data members and member functions for classes, a possible initial value for a variable, and the function body for a function). When specifying a class, there are several alternatives as to where to place the various components of the class definition (i.e., the class declaration + the member function definitions). We'll address this in more detail in the chapter in Chapter 15. For the moment, we just give crude guidelines to allow you to do these simple exercises. (when doing the CodeLab exercises, you will not have to deal with files or filenames, but the following presentation will make the terminology understandable).

For illustrative purposes, we'll focus on a class named Simple with a single int data member named val, a default constructor, and a single member function name getVal.

Function Definitions within the Class Declaration in the Header (.h) File

// Simple.h

class Simple {
public:
	Simple(int val) : val(val) {}		// outside val is data member; inside val is parameter
	int getVal() {return val;}		// inline function
private:
	int val;						// data members are part of class declaration
};			

• Place the function definitions in the class declaration
  • this is similar to what we do in Java
  • it's rarely done for all the functions, but often done for the simple and small ones (for example get/set functions)
  • functions defined within the class declaration are called inline
• when placed within the class declaration, the body of the functions are, by definition, within class scope
  • accessing data members (e.g. val) refers to those of the receiving object

    Simple s1(5), s2(10);	// initilalizes s1's val to 5, and s2's to 10
    cout << s1.getVal() << endl;	// the val insoide getVal will refer to that of s1
    cout << s1.getVal() << endl;	// the val insoide getVal will refer to that of s2
    					

  • though parameters and local variables can 'shadow' them if named the same (we discussed this in the context of Java constructors and the need for this in that case
  • the member initalization list eliminates the need for this by having a fixed format of the form data-member(expression)
• the above would typically be placed within a .h file

Function Definitions Separated from the Class Declarations

// Simple.h (interface/header) file
class Simple {
public:
	Simple(int val);			// headers only
	int getVal();
private:
	int val;						// data members are part of class declaration
};			

//Simple.cpp (implementation/source) file

Simple::Simple() : val(val) {}
int Simple::getVal() {return val;}

• Separation of interface and implementation
• in this approach, the interface, i.e., the class declaration consisting of member function headers and data members, goes in the .h file, and the implementation, i.e., the member function definitions (function bodies) go in the .cpp file.
  • the Simple:: uses the scope resolution operator to:
    • indicate this is a member function and thus has access to data members
    • place the function body into class scope (as discussed above)

Mixtures of the Above

• as mentioned above, short, simple functions are often coded inline (in the .h file), while the others are placed in the corresponding .cpp file
• if all functions are placed inline (the first approach), no .cpp file is necessary
• there are times (e.g., templates, as we will see) when we have no choice but to have even relatively large and complex functions be inline

  class Simple {
  public:
  	Simple(int val);			// headers only
  	int getVal();
  private:
  	int val;						// data members are part of class declaration
  };			
  inline Simple::Simple() : val(val) {}
  inline int Simple::getVal() {return val;}
  		

  • rather than placing them in the class declaration, we can put them in the .h file AFTER the class declaration
  • the syntax requires a scope resolution operator AND the inline keyword
    • in .h file

      class Simple {
      public:
      	Simple(int val);			// headers only
      	int getVal();
      private:
      	int val;						// data members are part of class declaration
      };			
      inline Simple::Simple() : val(val) {}
      inline int Simple::getVal() {return val;}
      						

    • the keyword inline is necessary since everything is going into the .h file (more on that later)

The Class Definition Exercises in CodeLab

• The class definitionx exercises in CodeLab come in three flavors:
  • Write an interface (.h) file
    • For this sort of exercise you simply supply the class declaration, i.e., the declarations of the data members and the member function headers
  • Write the implementation (.cpp) file,
    • For these, you are to supply the member function definitions (function bodies). Don't forget the scope resolution operator
  • Write a full definition
    • In this exercise you are to supply both the class declaration as well as the member function definitions. You can write the definitions inline, or after the declaration (I believe it should work with or without the inline keyword)

static (Class) Members

• static data member and member functions have the same semantics as in Java — there is a single copy of a static data member for the class, and static member functions take no receiver (instead they are invoked with the class name and scope resolution operator, e.g. SomeClass::f()) and can only refer to the static data member of the class.
• the static keyword is used only in the class declaration, the subsequent definition does not contain static in the header.
• Unlike Java, data members in C++ cannot be initialized at the point of the declaration
  • (non-static) data members are typically initialized in the constructor
  • static data members are almost always initialized in the corresponding .cpp file

    // Simple.h
    
    class Simple {
    	…
    	static int nextId;
    	…
    };
    				

    // Simple.cpp
    
    int Simple::nextId = 1000;