Darren Woods's Profile

long LongArray[25];

declares an array of 25 long integers, named LongArray.
When the compiler sees this declaration, it sets aside enough memory to hold all
25 elements

int IntegerArray[] = { 10, 20, 30, 40, 50 };

If you need to know the size of the array, you can ask the compiler to
compute it for you. For example,

const USHORT IntegerArrayLength;
IntegerArrayLength = sizeof(IntegerArray)/sizeof(IntegerArray[0]);

int IntegerArray[5] = { 10, 20};

Although uninitialized array members have no guaranteed values, actually,
aggregates will be initialized to 0. If you don't initialize an array
member, its value will be set to 0.

Any object, whether built-in or user-defined, can be stored in an array. When
you declare the array, you tell the compiler the type of object to store and the
number of objects for which to allocate room. The compiler knows how much room
is needed for each object based on the class declaration. The class must have a
default constructor that takes no arguments so that the objects can be created
when the array is defined.

Day 10

Advanced Functions

Output: DrawShape():
******************************
******************************
******************************
******************************
******************************

DrawShape(40,2):
************************************************************
************************************************************

The constructor provided for you is called the "default" constructor, but by
convention so is any constructor that takes no parameters. This can be a bit
confusing, but it is usually clear from context which is meant.

Take note that if you make any constructors at all, the default constructor
is not made by the compiler. So if you want a constructor that takes no
parameters and you've created any other constructors, you must make the default
constructor yourself!

The point of a constructor is to establish the object; for example, the point
of a Rectangle constructor is to make a rectangle.

Constructors, like all member functions, can be overloaded. The ability to
overload constructors is very powerful and very flexible.

Up to now, you've been setting the member variables of objects in the body of
the constructor. Constructors, however, are invoked in two stages: the
initialization stage and the body.

Up to now, you've been setting the member variables of objects in the body of
the constructor. Constructors, however, are invoked in two stages: the
initialization stage and the body.

In addition to providing a default constructor and destructor, the compiler
provides a default copy constructor. The copy constructor is called every time a
copy of an object is made.

When you pass an object by value, either into a function or as a function's
return value, a temporary copy of that object is made.

All copy constructors take one parameter, a reference to an object of the
same class. It is a good idea to make it a constant reference, because the
constructor will not have to alter the object passed in. For example:

CAT(const CAT & theCat);

Here the CAT constructor takes a constant reference to an existing
CAT object. The goal of the copy constructor is to make a copy of
theCAT.

The default copy constructor simply copies each member variable from the
object passed as a parameter to the member variables of the new object. This is
called a member-wise (or shallow) copy, and although this is fine for most
member variables, it breaks pretty quickly for member variables that are
pointers to objects on the free store.

int &rSomeRef = someInt;

This is read as "rSomeRef is a reference to an integer that is initialized
to refer to someInt."

President  William_Jefferson_Clinton;

You might then declare a reference to President and initialize it with
this object:

President &Bill_Clinton = William_Jefferson_Clinton;

There is only one President; both identifiers refer to the same object
of the same class. Any action you take on Bill_Clinton will be taken on
William_Jefferson_Clinton as well.

As discussed, functions can only return one value. What if you need to get two
values back from a function? One way to solve this problem is to pass two objects
into the function, by reference. The function can then fill the objects with the
correct values. Since passing by reference allows a function to change the original
objects, this effectively lets the function return two pieces of information. This
approach bypasses the return value of the function, which can then be reserved for
reporting errors.

Once again, this can be done with references or pointers.

When the temporary object is destroyed, which happens when the function returns,
the object's destructor is called. If an object is returned by the function by value,
a copy of that object must be made and destroyed as well.

With large objects, these constructor and destructor calls can be expensive in
speed and use of memory.

An example of the latter concern is the operator new. If new
cannot allocate memory on the free store, it returns a null pointer. Since a reference
can't be null, you must not initialize a reference to this memory until you've checked
that it is not null. The following example shows how to handle this:

int *pInt = new int;
if (pInt != NULL)
int &rInt = *pInt;

In this example a pointer to int, pInt, is declared and initialized with
the memory returned by the operator new. The address in pInt is
tested, and if it is not null, pInt is dereferenced. The result of dereferencing
an int variable is an int object, and rInt is initialized
to refer to that object. Thus, rInt becomes an alias to the int
returned by the operator new.

1:  CAT&  rFrisky;
2:  CAT & rFrisky;
3:  CAT  &rFrisky;

White space is completely ignored, so anywhere you see a space here you may put
as many spaces, tabs, and new lines as you like.

having the &
near the CAT can lead to the following bug:

CAT&  rFrisky, rBoots;

Casual examination of this line would lead you to think that both rFrisky
and rBoots are references to CAT objects, but you'd be wrong. This
really says that rFrisky is a reference to a CAT, and rBoots
(despite its name) is not a reference but a plain old CAT variable.

When your program allocates memory on the free store, a pointer is returned. It
is imperative that you keep a pointer to that memory, because once the pointer is
lost, the memory cannot be deleted and becomes a memory leak.

As you pass this block of memory between functions, someone will "own"
the pointer. Typically the value in the block will be passed using references, and
the function that created the memory is the one that deletes it. But this is a general
rule, not an ironclad one.

The function prototype is a statement, which means it ends with a semicolon.
It consists of the function's return type, name, and parameter list.

long Area(int length, int width);

Variables defined outside of any function have global scope and thus are
available from any function in the program, including main().

Local variables with the same name as global variables do not change the
global variables. A local variable with the same name as a global variable hides
the global variable, however. If a function has a variable with the same name as
a global variable, the name refers to the local variable--not the global--when
used within the function.

C++ enables you to create more than one function with the same name. This is
called function overloading. The functions must differ in their parameter list,
with a different type of parameter, a different number of parameters, or both.
Here's an example:

int myFunction (int, int);
int myFunction (long, long);
int myFunction (long);

Suppose you write a function that doubles whatever input you give it. You
would like to be able to pass in an int, a long, a
float, or a double. Without function overloading, you would
have to create four function names:

int DoubleInt(int);
long DoubleLong(long);
float DoubleFloat(float);
double DoubleDouble(double);

With function overloading, you make this declaration:

int Double(int);
long Double(long);
float Double(float);
double Double(double);

This is easier to read and easier to use. You don't have to worry about which
one to call; you just pass in a variable, and the right function is called
automatically.

Note that inline functions can bring a heavy cost. If the function is called
10 times, the inline code is copied into the calling functions each of those 10
times. The tiny improvement in speed you might achieve is more than swamped by
the increase in size of the executable program. Even the speed increase might be
illusory. First, today's optimizing compilers do a terrific job on their own,
and there is almost never a big gain from declaring a function inline.
More important, the increased size brings its own performance cost.

What's the rule of thumb? If you have a small function, one or two
statements, it is a candidate for inline. When in doubt, though, leave
it out

A more accurate mental picture is of a series of cubbyholes
aligned top to bottom. The top of the stack is whatever cubby the stack pointer (which
is another register) happens to be pointing to.

Each of the cubbies has a sequential address, and one of those addresses is kept
in the stack pointer register. Everything below that magic address, known as the
top of the stack, is considered to be on the stack. Everything above the top of the
stack is considered to be off the stack and invalid.

Here's what happens when a program, running on a PC under DOS, branches to a function:

1. The address in the instruction pointer is incremented to the next instruction
past the function call. That address is then placed on the stack, and it will be
the return address when the function returns.



2. Room is made on the stack for the return type you've declared. On a system
with two-byte integers, if the return type is declared to be int, another
two bytes are added to the stack, but no value is placed in these bytes.



3. The address of the called function, which is kept in a special area of
memory set aside for that purpose, is loaded into the instruction pointer, so the
next instruction executed will be in the called function.



4. The current top of the stack is now noted and is held in a special pointer
called the stack frame. Everything added to the stack from now until the function
returns will be considered

"local" to the function.



5. All the arguments to the function are placed on the stack.



6. The instruction now in the instruction pointer is executed, thus executing
the first instruction in the function.



7. Local variables are pushed onto the stack as they are defined.

When the function is ready to return, the return value is placed in the area of
the stack reserved at step 2. The stack is then popped all the way up to the stack
frame pointer, which effectively throws away all the local variables and the arguments
to the function.

The return value is popped off the stack and assigned as the value of the function
call itself, and the address stashed away in step 1 is retrieved and put into the
instruction pointer. The program thus resumes immediately after the function call,
with the value of the function retrieved.

When you begin your program, your operating system (such as DOS or Microsoft
Windows) sets up various areas of memory based on the requirements of your
compiler. As a C++ programmer, you'll often be concerned with the global name
space, the free store, the registers, the code space, and the stack.

int *pAge = 0;

This declares pAge to be a pointer to int. That is,
pAge is declared to hold the address of an int.

Note that pAge is a variable like any of the variables.

unsigned short int * pAge = &howOld;  // make pointer to howOld

pAge is a pointer that now contains the address of the
howOld variable

The indirection operator (*) is also called the dereference
operator. When a pointer is dereferenced, the value at the address stored by the
pointer is retrieved.

To assign the value in howOld to the new variable yourAge
by way of the pointer pAge, you would write

unsigned short int yourAge;
yourAge = *pAge;

The indirection operator (*) in front of the variable pAge
means "the value stored at." This assignment says, "Take the value stored at the
address in pAge and assign it to yourAge."

Pointers are used, most often, for three tasks:


• Managing data on the free store.
  
  
  
• Accessing class member data and functions.
  
  
  
• Passing variables by reference to functions.

The stack is cleaned automatically when a function returns. All the local
variables go out of scope, and they are removed from the stack. The free store
is not cleaned until your program ends, and it is your responsibility to free
any memory that you've reserved when you are done with it.

The advantage to the free store is that the memory you reserve remains
available until you explicitly free it. If you reserve memory on the free store
while in a function, the memory is still available when the function
returns.

The advantage of accessing memory in this way, rather than using global
variables, is that only functions with access to the pointer have access to the
data. This provides a tightly controlled interface to that data, and it
eliminates the problem of one function changing that data in unexpected and
unanticipated ways.

For this to work, you must be able to create a pointer to an area on the free
store and to pass that pointer among functions.

unsigned short int * pPointer = new unsigned short int;

If new cannot create memory on the free store (memory is, after all,
a limited resource) it returns the null pointer. You must check your pointer for
null each time you request new memory.

delete pPointer;

When you delete the pointer, what you are really doing is freeing up the
memory whose address is stored in the pointer.

Animal *pDog = new Animal; delete pDog; //frees the memory    

pDog = 0; //sets pointer to null    //... delete pDog; //harmless

Although line 28 is redundant (the end of the program would have returned
that memory) it is a good idea to free this memory explicitly. If the program
changes or is extended, it will be beneficial that this step was already taken
care of.

Another way you might inadvertently create a memory leak is by reassigning
your pointer before deleting the memory to which it points. Consider this code
fragment:

1:   unsigned short int * pPointer = new unsigned short int;
2:   *pPointer = 72;
3:   pPointer = new unsigned short int;
4:   *pPointer = 84;

The code should have been written like this:

1: unsigned short int * pPointer = new unsigned short int;
2: *pPointer = 72;
3: delete pPointer;
4: pPointer = new unsigned short int;
5: *pPointer = 84;

Cat *pCat = new Cat;

This calls the default constructor--the constructor that takes no parameters.
The constructor is called whenever an object is created (on the stack or on the
free store).

You accessed data members and functions by using the dot (.)
operator for Cat objects created locally. To access the Cat
object on the free store, you must dereference the pointer and call the dot
operator on the object pointed to by the pointer. Therefore, to access the
GetAge member function, you would write

 (*pRags).GetAge();

Parentheses are used to assure that pRags is dereferenced before
GetAge() is accessed.

Because this is cumbersome, C++ provides a shorthand operator for indirect
access: the points-to operator (->),

Every class member function has a hidden parameter: the this
pointer. this points to the individual object. Therefore, in each call
to GetAge() or SetAge(), the this pointer for the
object is included as a hidden parameter.

const int * pOne;
int * const pTwo;
const int * const pThree;

pOne is a pointer to a constant integer. The value that is pointed
to can't be changed.

pTwo is a constant pointer to an integer. The integer can be
changed, but pTwo can't point to anything else.

pThree is a constant pointer to a constant integer. The value that
is pointed to can't be changed, and pThree can't be changed to point to
anything else.

for (n-=3; n>0; n++)

which might have been clearer. However, this idiom is so common in C++ that
there is little sense in fighting it.

switch (choice)
{
choice 0:
choice 1:
choice 2:
       cout << "Less than 3!";
       break;
choice 3:
       cout << "Equals 3!";
       break;
default:
       cout << "greater than 3!";
}

#define EVER ;;
for (EVER)
{
    // statements...
}

You make a new type by declaring a class. A class is just a collection of
variables--often of different types--combined with a set of related
functions.

One way to think about a car is as a collection of wheels, doors, seats,
windows, and so forth. Another way is to think about what a car can do: It can
move, speed up, slow down, stop, park, and so on. A class enables you to
encapsulate, or bundle, these various parts and various functions into one
collection, which is called an object.

class Cat
{
unsigned int  itsAge;
unsigned int  itsWeight;
Meow();
};

You define an object of your new type just as you define an integer
variable:

unsigned int GrossWeight;         // define an unsigned integer
Cat Frisky;                       // define a Cat

Once you define an actual Cat object--for example, Frisky--you use
the dot operator (.) to access the members of that object. Therefore,
to assign 50 to Frisky's Weight member variable, you would write

Frisky.Weight = 50;

In the same way, to call the Meow() function, you would write

Frisky.Meow();

When you use a class method, you call the method. In this example, you are
calling Meow() on Frisky.

As a general rule of design, you should keep the member data of a class
private. Therefore, you must create public functions known as accessor methods
to set and get the private member variables. These accessor methods are the
member functions that other parts of your program call to get and set your
private member variables.

1:       // Cat class declaration
2:       // Data members are private, public accessor methods
3:       // mediate setting and getting the values of the private data
4:
5:  class Cat
6:  {
7:  public:
8:       // public accessors
9:     unsigned int GetAge();
10:    void SetAge(unsigned int Age);
11:
12:    unsigned int GetWeight();
13:    void SetWeight(unsigned int Weight);
14:
15:      // public member functions
16:    Meow();
17:
18:      // private member data
19: private:
20:    unsigned int  itsAge;
21:    unsigned int  itsWeight;
22:
23: }; 

A member function definition begins with the name of the class, followed by
two colons, the name of the function, and its parameters

If the constructor took one parameter, you would write

Cat Frisky (3);

In the event that the constructor takes no parameters at all, you leave off
the parentheses and write

Cat Frisky ;

This is an exception to the rule that states all functions require
parentheses, even if they take no parameters.

SetAge() cannot be const because it changes the member
variable itsAge. GetAge(), on the other hand, can and should
be const because it doesn't change the class at all. GetAge()
simply returns the current value of the member variable itsAge.
Therefore, the declaration of these functions should be written like this:

void SetAge(int anAge);
int GetAge() const;

If you declare a function to be const, and the implementation of
that function changes the object by changing the value of any of its members,
the compiler flags it as an error.

If you make GetAge() a const function--as you should--the
contract also promises that GetAge() won't change the Cat on
which it is called.

C++ is strongly typed, which means that the compiler enforces these contracts
by giving you a compiler error when you violate them

Like other functions, the definition of a class method has a function header
and a function body.

The definition must be in a file that the compiler can find.

you put the declaration of the Cat class into a file named
CAT.HPP, and you put the definition of the class methods into a file
called CAT.CPP. You then attach the header file to the .CPP
file by putting the following code at the top of CAT.CPP:

#include Cat.hpp

This tells the compiler to read CAT.HPP into the file, just as if
you had typed in its contents at this point. Why bother separating them if
you're just going to read them back in? Most of the time, clients of your class
don't care about the implementation specifics. Reading the header file tells
them everything they need to know; they can ignore the implementation files.

Just as you can ask the compiler to make a regular function inline, you can
make class methods inline. The keyword inline appears before the return
value. The inline implementation of the GetWeight() function, for
example, looks like this:

inline int Cat::GetWeight()
{
return itsWeight;         // return the Weight data member
}

You can also put the definition of a function into the declaration of the
class, which automatically makes that function inline. For example,

class Cat
{
public:
int GetWeight() { return itsWeight; }    // inline
void SetWeight(int aWeight);
};

Note the syntax of the GetWeight() definition. The body of the
inline function begins im-mediately after the declaration of the class method;
there is no semicolon after the paren-theses.

1:  #include <iostream.h>
2:  class Cat
3:   {
4:  public:
5:   Cat (int initialAge);
6:   ~Cat();
7:    int GetAge() { return itsAge;}             // inline!
8:    void SetAge (int age) { itsAge = age;}     // inline!
9:    void Meow() { cout << "Meow.\n";}             // inline!
10:  private:
11: int itsAge;
12: };

You're probably wondering why two keywords do the same thing. This is an
accident of history. When C++ was developed, it was built as an extension of the
C language. C has structures, although C structures don't have class methods.
Bjarne Stroustrup, the creator of C++, built upon structs, but he
changed the name to class to represent the new, expanded functionality.

{
     temp = a;
     a = b;
     b = temp;
}

This block of code acts as one statement and swaps the values in the
variables a and b.

There are five mathematical operators: addition (+), subtraction
(-), multiplication (*), division (/), and modulus
(%).

myAge += 2;

The self-assigned addition operator (+=) adds the rvalue to the
lvalue and then reassigns the result into the lvalue.

There are self-assigned subtraction (-=), division (/=),
multiplication (*=), and modulus (%=) operators as well.

Both the increment operator (++) and the decrement
operator(--) come in two varieties: prefix and postfix. The prefix
variety is written before the variable name (++myAge); the postfix
variety is written after (myAge++).

The semantics of prefix is this: Increment the value and then fetch it. The
semantics of postfix is different: Fetch the value and then increment the
original.

This can be confusing at first, but if x is an integer whose value
is 5 and you write

int a = ++x;

you have told the compiler to increment x (making it 6) and
then fetch that value and assign it to a. Thus, a is now
6 and x is now 6.

A logical NOT statement evaluates true if the expression
being tested is false. Again, if the expression being tested is false, the value
of the test is TRUE! Thus

if ( !(x == 5) )

is true only if x is not equal to 5. This is exactly the same as
writing

if (x != 5)

The conditional operator (?:) is C++'s only ternary operator; that
is, it is the only operator to take three terms.

The conditional operator takes three expressions and returns a value:

(expression1) ? (expression2) : (expression3)

This line is read as "If expression1 is true, return the value of
expression2; otherwise, return the value of expression3." Typically, this value
would be assigned to a variable.

unsigned short Width = 5;

It can become tedious, repetitious, and, most important, error-prone to keep
writing unsigned short int. C++ enables you to create an alias for this
phrase by using the keyword typedef, which stands for type
definition.

to define constants in C++:

const unsigned short int studentsPerClass = 15;

Every enumerated constant has an integer value. If you don't specify
otherwise, the first constant will have the value 0, and the rest will
count up from there. Any one of the constants can be initialized with a
particular value, however, and those that are not initialized will count upward
from the ones before them. Thus, if you write

enum Color { RED=100, BLUE, GREEN=500, WHITE, BLACK=700 };

then RED will have the value 100; BLUE, the value
101; GREEN, the value 500; WHITE, the value
501; and BLACK, the value 700.

Object-oriented programming attempts to respond to these needs, providing
techniques for managing enormous complexity, achieving reuse of software
components, and coupling data with the tasks that manipulate that data.

The essence of object-oriented programming is to treat data and the
procedures that act upon the data as a single "object"--a self-contained entity
with an identity and certain characteristics of its own.