SuperHack/SuperHack CD.bin/CODING/CPP/OVERVIEW.ZIP/OVERVIEW.TXT

Text File | 1996-04-26 | 11.1 KB | 695 lines

C++ Overview


by John Tal



1.0.C++ and C


C++ is an object-oriented extension to the C language.  C++ can be

used to compile C programs.  Everything you can do in C, you can also

do in C++.  C++ programs and their extensions cannot be compiled under

a C only compiler.


2.0.Object-Oriented Programming


2.1.Class


The class concept is the fundamental building block for all

objected-oriented programming systems (OOPS).  A class consists of an

object (or group of objects) and the function(s) which operate on the

obects(s).  In C++, a class is defined in a similar way to a

structure, except the keyword class is used:


..class FILE_C;     // forward reference to a class



2.2.Class Components


A class definition contains declarations for variables and functions.

A class definition also provides different security areas for

variables and functions.


..class FILE_C

..{

..  private:

..  .long.ptr;..  // file pointer

...char.name[FNAME_LEN];  // file name

...short.state;..  // file state

...short.mode;..  // file mode

..  public:

...FILE_C(void);..// class constructor

...~FILE_C(void);.        // class destructor

...short.Open(char *,short);  // open function

.      ..short.Close(void);.     // close function

...short.Read(char *,short);  // read function

...short.Write(char *,short); // write function

..};


The above FILE_C class has four private data items (objects) and six

functions which operate on those objects.  Any access to the class

objects must occur through a class function.  The private keyword

enforces this data hiding by preventing the application using the

class from having access to anything in the class private area.  Only

the class functions themselves can access private objects.


2.3.Class Constructors And Destructors


The FILE_C class has a FILE_C() function as a constructor and a

~FILE_C() function as a destructor.  The constructor is a function

with the same name as the class which is invoked at the creation of

an instance of the class and is intended to provide any

initialization the class requires.   The destructor function also

has the same name as the class but with a '~' (tilde) character in

front of it.  A destructor is provided for any cleanup work to occur

within the class at the termination of the class instance (such as

making sure the file is closed).


A class instance is created in two different ways.  The first is by

declaring a class instance in the same way a standard C language

variable is created.


.short.x;         //  create a variable named x

.FILE_C  LogFile;   // create a unique instance of the FILE_C class



The second method of creating a class instance is by allocating a new

instance through a pointer and the new keyword.


.FILE_C * pLogFile;.// create a pointer to a FILE_C class


.pLogFile = new FILE_C;.// create an instance and assign ptr


The new keyword is provided as an improved calloc or malloc.  The new

keyword calculates the size of the memory block to be allocated to

the item being created.


2.3.1.Constructors With Parameters


Like any function, a constructor can take parameters.   The

parameters would be supplied at the time of the creation of a new

class instance.


.class FILE_C

.{

.....

.  public:

..FILE_C(char *pFileName);

.};


.FILE_C.LogFile("LogFileName");  // constructor with parm



2.4.Class Function Calling


Class member functions are called like normal C functions.  The

difference is that they use syntax similar to that used for structure

membership.


.

.FILE_C.LogFile;.// create instance of FILE_C

.FILE_C * pInputFile;.// create ptr to instance of FILE_C


.pInputFile = new FILE_C;   // create instance of FILE_C


.LogFile.Open("LogFile",O_APPEND);    // open LogFile


.InputFile -> Open("InputDat",O_READONLY);  // open InputFile


.InputFile -> Read(buffer,sizeof(buffer));  // read InputFile



From the above example, a file pointer is never sent to the FILE_C

functions as would be in standard C file functions.  This is because

each instance of the FILE_C maintains its own control information

internal to the class itself in its own private area.  C++ usually

simplifies interfaces between classes and applications because

classes are complete in themselves.  They contain all the attributes

and/or objects that describe the class within.



2.5.Class Function Declaration


A class definition (such as class FILE_C ...) would occur in an

include file.  The actual functions of the class would be declared in

a C++ source file.   Each class function is prefixed with the class

name to which it belongs and the symbol '::'.


.short FILE_C::Open(char * pFileName,short mode)

.{

..mode = mode;   // referencing private data item


..strcpy(name,pFileName);


..//  perform open


. .return (status);

.}



2.6.Inline Functions


If a class function is performing a very simple task, it can be

declared an an inline function.  An inline function is an expanded

version of the function declaration within the class with begin and

end braces surronding the inline statement(s).


.class FILE_C

.{

.  private:

.    char.name[FNAME_LEN];  // file name

.....

.  public:

.     FILE_C(char *pFileName) { strcpy(name,pFileName); }

.....

.};



The above example shows the FILE_C constructor implemented as an

inline function.  Inline functions should be limited to functions

having only a few (preferrably one) statement(s).



3.0.Derived Classes


One of C++' most powerful features is to use classes as building

blocks in creating entirely new classes.


.class BROWSE_C : FILE_C   // browse derived from file

.{.

.  private:

.    short  curline;

.    ...

.  public:

.    BROWSE_C(void);

.    ~BROWSE_C(void);

.    OpenFile(char *);

.};



From the above example, the BROWSE_C class will have access not only

to all of its own member data/objects, but also to all FILE_C class

member functions which were declared as public or protected in

FILE_C.  The following table breaks down class security areas for

immediate classes and derived classes.



.Immediate..Derived

.----------..---------

.Private...Not-visible in derived class

.Protected..Visible as Private in derived

.Public...Visible as Protected in derived


From the above example, the BROWSE_C class would be able to access

any data and functions which were defined as protected or public in

the FILE_C class.  The application would not be able to access any of

the data or functions of the FILE_C class without going through a

public member function of the BROWSE_C class.   These are the default

security inheritance protocols for classes.


3.1.Customizing Class Inheritance


The default security inheritance can be overridden when defining

the derived class:


.class BROWSE_C : public FILE_C   // browse derived from file

.{.

.  private:

.    short  curline;

.    ...

.  public:

.    BROWSE_C(void);

.    ~BROWSE_C(void);

.    OpenFile(char *);

.

.};


From the above example, all public functions of FILE_C class are also

public to applications using the BROWSE_C class.

.

3.2.Container Classes


Container classes are classes which contain other classes.  An example

would be a class to implement a binary tree:


.class TREE_C

.{


.   private:



.    struct TNODE_S. // the contained class

.    {

.      PVOID          pvData;

.      struct TNODE_S *pstLeft;

.      struct TNODE_S *pstRight;

.    };

.    typedef struct TNODE_S TNODE_T;

.    typedef TNODE_T *TNODE_P;

.    typedef TNODE_T **TNODE_PP;

.

.    TNODE_P  pstHead;

.    TNODE_P  pstNode;

.....

.

.public:

.

.    TREE_C(VOID);

.    ~TREE_C(VOID);

.    SHORT    Delete(PVOID);          // Remove entry

.    SHORT    Find(PVOID,PPVOID);     // Find entry

.    SHORT    Insert(PVOID);          // Insert entry

.....

.};

.

.typedef TREE_C * TREE_CP;

.typedef TREE_C ** TREE_CPP;


In the binary tree example, it was not desirable for each node of the

tree to be an instance of the TREE_C class.  So each node is

contained in the TREE_C class and the TREE_C class operates on all

the TNODE_S structures/classes contained within it.


3.3.Virtual Functions


Virtual functions provide a way for a base class function to take on

the characteristics or behavior appropriate to the current derived

class.


.class FILE_C

.{

.  private:

.    char.name[FNAME_LEN];  // file name

.....

.  public:

.     FILE_C(char *pFileName) { strcpy(name,pFileName); }

.     virtual short Reset(void);

.};


.class BROWSE_C : FILE_C   // browse derived from file

.{.

.  private:

.    short  curline;

.    ...

.  public:

.    BROWSE_C(void);

.    ~BROWSE_C(void);

.    OpenFile(char *);

.    short Reset(void);

.};


.short BROWSE_C::Reset(void)

.{

.    FILE_C::Reset();

.    curline = 0;

        }





4.0.Operator Overloading


Since C++ classes define in detail the characters of and operations

upon the class instance, C++ allows all standard operators (i.e. '+',

'-', '*', '/', '++', '--') to be redefined or overloaded for the

current class.


.class STRING_C

.{

.   private:

.     char * pChar;

.     int  len;

.....

.   public:

.     STRING_C(const char * = 0);  // provide default value

.    ~STRING_C(delete pChar);

.     void operator+(char *)

      .};


.STRING_C::operator+(char *pC)

.{

.   char * pBuf;

.   pBuf = new char[len=strlen(pC)+len];

           strcpy(pBuf,pChar);

.   strcat(pBuf,pC);

       .   delete pChar;

.   pChar = pBuf;

.}



.STRING_C  Str("ABC");


.Str + "DEF";.   // internal pChar now = 'ABCDEF'


.

Operator overloading still involves functions to simulate the

operator being overloaded.  Overloading simply provides a mechanism

for abbreviating the operations.



5.0.C++ Input/Output


C++ output is simplified over that of C printf family functions.  C++

defines the keywords cout and cin and the stdout and stdin devices.

C++ automatically formats the output based on the current variable

type.



./*  In C */


.printf("%s = %d\n", szRate, sRate);


.//  In C++


.cout << szRate << " = " << sRate << "\n";



.//  Another C++ alternative


.cout << form("%s = %d\n", szRate,sRate);



./*  In C */


.scanf("%d",&sRate);


.//  In C++


.cin >> sRate;



7.0.Reference Variables


C++ provides a syntax which allows programmers who are not

comfortable with C pointer syntax to more easily write applications

which use pointers.



./*   In C */


.short Afunc(short * psShort)

.{

.   *psShort++;

.}



.//   In C++


.short Afunc(short & Short)

.{

.   Short++;

.}