CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

C++ Classes (continued)

• The members of a class can be either public, private, or protected.
  • By default, all members are private.

  • Private members can only be acessed by code within the class.

  • Public members can be accessed by code outside the class (like the members of a struct can be).

  • We will cover protected later.

• Example:

     //  shape.h
  
     class rectangle {
        public:
  	 void setSize(int x, int y);
  	 int  getWidth();
  	 int  getLength();
        private:
  	 int  width;
  	 int  length;
        };                    //  <-- Note the semicolon.
  
  
     //  main.cpp
  
     #include 
     #include "shape.h"
  
     int main() {
  
        rectangle a;
        rectangle * b = NULL;
  
        a.setSize(5, 12);
        cout << a.getWidth();
  
        b = new rectangle;
        (*b).setSize(3,4);           //  These two lines do
        b->setSize(3,4);             //  the same thing.
        cout << b->getLength();
  
        return 0;
     }
  	 

• I prefer you to list the public members first, since they are the ones which form the interface to the class. Note that many books (including Prata) list the private members first.

• Names defined in a class have a scope somewhere between local and module.
  • Names defined in a class exist in their own namespace.

  • Two classes can have members with the same name.

• Note that C++ does not hide the implementation details of a class. It only restricts access.

The Scope Resolution Operator (::)

• Problem: If there is more than one function with the same name defined in different namespaces, how can we specify which one we mean?
  • Example: We want to define the function getWidth outside of the class definition. How do we specify that we are defining that getWidth function?

• Solution: Use the scope resolution operator ::.
  • Example:

       //  shape.cpp
    
       #include "shape.h"
    
       void rectangle::setSize(int x, int y) {
          width  = x;
          length = y;
       }
    
       int rectangle::getWidth() {
          return width;
       }
    
       int rectangle::getLength() {
          return length;
       }
    	       

• Why do we need this? Because there may be another function named getWidth which is a member of another class or one that is not a member of any class (that is, in the global namespace).
  • Example:

       //  shape.cpp
    
       #include "shape.h"
    
       int getWidth() {
          return screenWidth;   // Assume screenWidth is previously defined.
       }
    
       int rectangle::getWidth() {
          return width;
       }
    
       void rectangle::maximizeWidth() {       
          width = ::getWidth();               
       }
    	       

• :: without a name in front of it refers to the global namespace.

Inline Functions

• An inline function is one in which the compiler does not generate object code which makes a function call. Instead, the compiler puts the object code of the function at every place where the function is called.
  • Example:
    • A regular function.
    • An inline function.

• Inline functions can speed up your program if the function is very small (1 or 2 lines).

• Inline functions can make your program larger if the function is called many times.

• Inline functions are suggested by the keyword inline.
  • Example:

       inline int myFunc(char c);
    	       

  • The inline keyword is a suggestion to the compiler. The compiler may or may not make the function inline.

• When the compiler is compiling a function where an inline function is called, the compiler must have access to the function definition, not just the function prototype.
  • An inline function defined in a .cpp file can be called only by functions in that file.

  • If an inline function is to be called by functions in more than one ,cpp file, it must be defined in a header file which is included by those .cpp files.

• Recursive functions cannot be inlined.

Return to lecture notes index

Lectures