c++学习笔记十二

 类的操作
    1 类对象使用指针的三种情况:
            一、使用指针成员访问运算符-> ,来调用函数
            二、作为函数的参数
            三、作为类的数据成员'
          
    2 指针作为数据成员    
         示例代码如下：
         package类 包含两个数据成员一个是Box类，一个是指向package的指针  
         class Package{
            //constructor 构造器
            public : 
                Package(Box* pBox) : theBox(*pBox),pNext(0){}
            
            //get 方法
            Box getBox() const{//返回box对象
                return theBox;
            }
            


            Package* getNext(){//返回下一个package
               return pNext;
            }
         
            //成员变量
            private:
               Box theBox;
               Package* pNext;
         } 
        修忙后的package类为
         class Package{
            //constructor 构造器
            public : 
                Package(Box* pNewBox) : theBox(pNewBox),pNext(0){}
            
            //get 方法
            Box getBox() const{//返回box对象
                return theBox;
            }
            


            Package* getNext(){//返回下一个package
               return pNext;
            }
         
            //成员变量
            private:
               Box theBox;
               Package* pNext;
          } 
         
          定义TruckLoad类 用来表示一组Package对象
          
            class TruckLoad{
                public:
  //constructor 构造器
                   TruckLoad(Box* pBox=0,int count=1); 
                   Box * getFirstBox();
                   Box * getNextBox();
                   void addBox(Box* pBox); 


                private:
                   Package * pHead;      //首节点
                   Package * pTail;      //尾节点
                   Package * pCurrent;   //当前节点
           }
      
          TruckLoad 的实现 (创建一个空列表)
          TruckLoad:TurckLoad(Box * pBox,int count){
              pHead=pTail=pCurrent=0;
              if((cont>0)&&(pBox!=0)){
                    for(int i=0;i<count;i++){
                          addBox(pBox+1);
                     }
                }
          }
          定义成员函数
              /*添加节点*/
              void TruckLoad::addBox(Box* pBox){
                     Package * pPackage=new Package(Box* pBox);
                     if(pHead){                 //检查列表是不为空
                        pTail->setNext(pPackage);  //在末尾添加元素
                     }else{                     //如果列表为空
                        pHead=pPackage;         //新元素即为首元素
                        pTail=pPackage;         //相应的也是尾元素
                     } 
              }
               /*取首节点地址*/
               Box * TruckLoad::getFirstBox(){
                 pcurrent=pHead; //当前节点指向首节点
                 return pCurrent->getBox();  //从当前节点中取得Box的地址
               }
               /*取下一个节点*/ 
              Box * TruckLoad::getNextBox(){
                  if(pCurrent){      //如果当前节点不为空
                     pCurrent=pCurrent->getNext;   //当前节点指向下一个
                  }else{             //如果为空 
                     pCurrent=pHead;          //指向首节点
                  }
                  return pCurrent?pCurrent->getNext:0;                      
               }
       使用列表(见程序prog13.01)
      
       3 控制对类的访问(限制类的可访问性)
       
           嵌套类  
            用public 访问指定修饰的嵌套类
            友元类 friend class TruckLoad;
              




       示例代码如下 
            #ifndef LIST_H
            #define LIST_H
            #include "Box.h"


          /*********************************
           * List.h包含个存放列表的类      * 
           * 注：package要放在TruckLoad前  *
           *********************************/


         /*列表节点对象*/
    class Package{
public:
Package(Box * pNewBox);//构造器


  //成员方法
  Box * getBox() const;
  Package * getNext() const; 
  void setNext(Package * pPackage);//在列表末尾添加一个


package
 
  //成员变量
  private :
Box * pBox;
Package * pNext;


};
 
/*列表*/
class TruckLoad{
public:
TruckLoad(Box * pBox=0,int count=1);//构造器

//成员方法
Box * getFirstBox(); //取得首节点
Box * getNextBox();  // 取得下一节点
void addBox(Box * pBox); //向列表中添加一个新节点
//成员变量
private:
Package * pHead;//首节点
Package * pTail;//尾节点
Package * pCurrent;//当前节点
};
#endif
       


          4 副本构造函数的重要性 (用于创建军与已有对像完全相同的对象)
             实现副本构造函数  示例代码如下:
                 TruckLoad::TruckLoad(TruckLoad load){
                     //在此处实现函数副本
                  }
            引用参数
                 TruckLoad::TruckLoad(const TruckLoad &load){
                     //在此处实现函数副本
                  }
            代码实现如下：
               TruckLoad::TruckLoad(const TruckLoad &load){
                     pHead=pTail=pCurrent=0;
                     if(load.pHead==0){ //如果列表为空
                          return;
                      }
    Package * pTemp= load.pHead;
                     do{
                         addBox();
                      }while(pTemp=pTemp->pNext);
                  }
           5 对象内部的动态内存分配
           
              析构函数 可以释放内存的类成员
              定义析构函数  示例代码如下: （注：没出有返回类型或是参数）
                TruckLoad::~TruckLoad(){
                     //Code to destroy the objece  
                 }
              默认的析构函数: 如果没有显示的定义析构函数，编译器会生成一个


公共或内联析构函数


              示例代码如下:
              在.h头文件中
               class Box{
                     public: 
                         ~Box();//析构函数原型
                }
               在.cpp实现文件
               Box::Box(){
                   cout<<"Box destructor called!"<<endl;
               }
               
              实现析构函数
             list.cpp中的析构函数的定义
  
             TruckLoad::~TruckLoad(){
               while(pCurrent=pHead->pNext){
                   delete pHead;
                   pHead=pCurrent;
               }
delete pHead;
              }
                   
           6 类的引用
             引用用作类的成员  示例代码如下:
              class Package{
                  public:
                     Box & rBox;
                     Package * pNext;


                      ~Package();
                     void setNext(Package * pPackage);
                     Package(Box &rNextBox);
              }
              在list.cpp中,构造函数的定义
              TruckLoad::Package::Package(Box & rNewBox):rBox


(rNewBox),pNext(0){}