总览c & c++ zt

musicbug

标题     总览c & c++    jldelphi（原作）
  
关键字     c++
  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}







对该文的评论 人气：1584  
      jldelphi (2002-1-22 14:22:50)  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}





      jldelphi (2002-1-22 14:22:50)  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}





      jldelphi (2002-1-22 14:22:50)  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}





      jldelphi (2002-1-22 14:22:50)  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}





      jldelphi (2002-1-22 14:22:50)  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}





      jldelphi (2002-1-22 14:22:50)  


1.0.C++ 和 C

C++是C语言的一个面向对象（object-oriented）的扩展(大师们都建议我们在学习C++的时候，把C++当成一门新的语言对待).
C++可以被用来编译C程序。你使用C所完成的任何工作，都可以使用C++完成。
C++程序与他们的扩展不能在C环境下编译通过。

2.0.面向对象编程

2.1.类
类是所有面向对象程序系统（OOPS）的基本组成。
一个类包含一个（或一组）对象和操作对象的函数

2.2.类的组成
一个类的定义包含变量和函数的宣告
一个类的定义同样为变量和函数提供不同的安全区域
class FILE_C
{
private:
  long ptr;     // 文件指针
  char name[FNAME_LEN];  // 文件名
  short state;    // 文件状态
  short mode;    // 文件模式

public:
  FILE_C(void);    // 类构造器
  ~FILE_C(void);.   // 类析构器
  short.Open(char *,short); // open 函数
  short.Close(void);.  // close 函数
  short.Read(char *,short); // read 函数
  short.Write(char *,short);// write 函数
};

上面的FILE_C类包含四个私有数据成员（对象）和六个操作那些对象的函数
任何有权使用类的对象都必须通过类的函数操作
private关键字:说明它里面的数据除了类成员函数以外的任何对象都不能访问

2.3.类的构造器和析构器
FILE_C类有一个FILE_C()构造函数和一个~FILE_C析构函数
构造函数与类同名，它在类的实例创建的时候调用
并且初始化任何类的需要
析构函数在类名之前加上~字符
析构函数可以在类的实例终止时进行进行任何清除工作
类的实例可以用两种方式创建。
一种是使用标准C语言创建一个变量的方式创建：

  short.x;     //  创建一个名为x的变量

  FILE_C  LogFile;   //  创建一个类FILE_C的实例

另外一种方式是通过指针和new关键字分派一个新的实例：

  FILE_C *pLogFile;   // 创建一个指向类FILE_C的指针


  pLogFile = new FILE_C; // 创建一个实例并且分配空间

2.3.1.使用参数构造
构造函数也可以象其他函数一样使用参数。
参数使用在创建一个新的类实例的时候
.class FILE_C
{
  ....

public:

  FILE_C(char *pFileName);

};


FILE_C.LogFile("LogFileName");  // 使用参数构造

2.4.类函数调用
类函数的调用方法与普通的C函数相同
不同的是它们使用相似的语法构造成员资格

.FILE_C LogFile;    // 创建一个类FILE_C的实例

.FILE_C *pInputFile;.   // 创建一个指向类FILE_C的实例的指针

.pInputFile = new FILE_C;  // 创建一个类FILE_C的实例


.LogFile.Open("LogFile",O_APPEND);    // 打开LogFile


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


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

从以上的示例可以看出，一个文件指针从来没有像标准C文件函数那样发送到FILE_C函数
每一个FILE_C的实例维持它自己的控制信息
C++通常在类和应用之间使用单一化界面因为类在它自己内部完成
它们包含所有属性和/或对象的内部描述

2.5.类函数声明
一个类的定义（比如FILE_C）将可能出现在一个头文件
实际的函数实现将出现在C++源文件
每一个类函数前面都使用符号::代表它的归属
.short FILE_C::Open(char * pFileName,short mode)
{
mode = mode;    // 提取私有数据项

strcpy(name,pFileName);

//  执行打开操作

return (status);
}

2.6.Inline函数
如果一个类函数执行一个非常简单的任务，他可以被宣告成一个内联函数
一个内联函数实际上是一个函数的扩展，它在类中宣告并实现，通过包含inline声明
class FILE_C

{
private:
char.name[FNAME_LEN];  // 文件名

.....

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

.....

};

上面的示例显示了FILE_C内联函数构造器的实现
注意：内联函数不能滥用

3.0.继承类
class BROWSE_C : FILE_C   // browse继承自file
{     
private:
short  curline;
...
public:
BROWSE_C(void);
~BROWSE_C(void);
OpenFile(char *);
};

上面的示例，BROWSE_C类将不仅可以访问它所有的成员data/object，而且可以访问
FILE_C类的所有public/protected成员

下表显示了父子类的继承关系

.父..子

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

.Private.....在继承类中不可见

.Protected...在继承类中被当作私有成员

.Public......在继承类中被当作受保护的成员


从上表可以看出，BROWSE_C可以使用
任何 FILE_C的public/protected数据和函数 FILE_C
应用程序将不能接受任何
FILE_C 类的私有数据或函数
这些是默认的类安全继承协议

3.1.自定义类继承
当定义继承类时，默认的安全继承可以重载：
class BROWSE_C : public FILE_C   // browse 继承自 file
{
private:
short  curline;
...
public:
    BROWSE_C(void);
    ~BROWSE_C(void);
    OpenFile(char *);                 
};


上例中，所有的FILE_C 类的公共功能同样
公开到使用BROWSE_C 类的应用程序中

3.2.容器类
容器类是包含别的类的类。
以下是使用一个类实现binary tree的例子：

class TREE_C
{
private:
  struct TNODE_S. // 容器类
     {
    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;

在binary tree 例子中，树中的每一个节点在TREE_C 类的实例
并不是都需要。所以每一个节点包含在TREE_C 类，
并且类TREE_C实行所有的包含在其内的TNODE_S操作

3.3.虚拟函数
虚拟函数提供一种方法为类基类具有
特有的或行为适当的到当前继承类

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.操作重载
自从C++类定义详细的在类的实例操作
以来，C++允许所有标准操作（i.e.'+','-', '*', '/', '++', '--'）
可以被当前类重新定义或重载

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";.   // 现在pChar = 'ABCDEF'

5.0.C++ 输入/输出
C++输出把C语言的printf家族简单化
C++定义关键字cout,cin,stdout,stdin设备
C++根据当前变量类型自动格式化

/*  C */

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

/*  C++ */

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

//  C++另外一种方式

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

/* C */

scanf("%d",&sRate);

/* C++ */


cin >> sRate;



7.0.Reference Variables


C++提供一种语法允许程序员更加容易地使用指针到应用程序中

/*  C */

short Afunc(short * psShort)
{
   *psShort++;
}



/*  C++ */


short Afunc(short & Short)
{
   Short++;
}