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
评论0