CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Read chapter 9 from C++ Primer Plus (2nd ed.), by Stephen Prata.

Scope and Lifetime (continued)

• Try to minimize the scope and duration of items in your program.
  • This reduces name pollution, enforces abstractions through hiding, and can reduce memory use.

  • Example: If a variable must be accessible by several functions in the same module (.cpp file) but by no other functions, define it outside of any function by use the static keyword.
    • Then it will have static duration and module scope.

  • Example: If a function is called by other functions in the same module but should not be called by functions outside that module, use the static keyword.
    • Then it will have static scope.

  • Example: If a variable is only used in one function, but must keep its value between function calls, define it inside the function and use the static keyword.
    • Then it will have static duration and local scope.

  • Note that the static keyword can affect the scope or the lifetime, depending on the context.

Conversions and Casts

• We have two problems:
  1. How can we convert a value from one type to another type? This is called type conversion.

  2. How can we treat the bits that make up a value as another type? This is called type transfer. Note that we are not changing the bits in the value.

• In C++ you can use C-style casting. C++ guesses whether you want to do type conversion or type transfer.
  • Example:
    

       myInt = 3 + (int) myFloat;
       onePtr = (MyStruct *) twoPtr;
    	       

• C++ also has function-style casts.
  • Example:

       myInt = 3 + int(myFloat);
    	       

  • Note that this will not work for the pointer example above, since the * would be confused with the multiply operator.

• The newest form of casting in C++ is the best. There are four forms of this cast.
  • dest = static_cast<newType>(source);
    dest = const_cast<newType>(source);
    dest = reinterpret_cast<newType>(source);
    dest = dynamic_cast<newType>(source);

  • static_cast does what the old cast does. It will also cast up and down in a class hierarchy (which we will see later).

  • const_cast converts a const variable to a non-const variable.

  • reinterpret_cast is a type transfer.

  • dynamic_cast is part of the Run Time Type Identification (RTTI) feature of C++. (We will cover RTTI later.)

• Casts never change the source value. They are part of an assignment statement or a function call.

• In this course, you should always use the new casting style.

The size_t Type

• The sizeof operator returns the number of bytes required to store a value of a given type. Note that it is an operator, not a function.
  • Example:

       x = sizeof pi;
       y = sizeof(myStruct);
    	       

  • Parentheses are only needed when the operand is a type. They are optional for a variable.

• Problem: What is the type of x and y?
  • If we use an int we may run into problems when we want to compile our program on different machines, because some machines use a 16-bit int and some use a 32-bit int.

• Solution: C++ has a type used just for this. It is the type size_t and is defined in <stddef.h>.
  • Example:

       size_t x = sizeof pi;
       size_t y = sizeof(myStruct);
    	       

Objects

• An object is an item with
  
  1. an identity which makes it distinct from other objects,
  2. properties or attributes,
  3. the ability to respond to requests.

• We all deal with objects in our everyday life.
  • Examples: our car, our TV, our friend.

• As humans, we tend to categorize objects in order to bring simplicity and order to the world around us. The two most common ways we categorize objects are
  
  1. membership,
  2. composition.
  • In membership categorization, we group together all objects that have something in common.
    • Examples: all bicycles, all children, all green elephants.

  • In composition categorization, we group together all objects that compose another object.
    • Examples: the parts of my bicycle.

    • Note that aside from being a part of a common object, these objects may have nothing in common.

Return to lecture notes index

Lectures