C++面向对象程序设计（三）

C++面向对象程序设计（三）

三、类和对象提高

1.this指针

C++程序到C程序的翻译

class CCar{
  public:
  int price;
  void SetPrice(int p);
};
void CCar::SetPrice(int p){
  price=p;
}
int main(){
  CCar car;
  car.SetPrice(20000);
  return 0;
}

struct CCar{
  int price;
}
void SetPrice(struct CCar * this,int p){
  this->price=p;
}
int main(){
  struct CCar car;
  SetPrice(&car,20000);
  return 0;
}

其作用就是指向成员对象所作用的对象。

• this指针作用

非静态成员函数中可以直接使用this指针来代表指向该函数作用的对象的指针。

class Complex{
  public:
  double real,imag;
  void Print(){cout<<real<<","<<imag;}
  Complex(double r,double i):real(r),imag(i){}
	Complex AddOne(){
    this->real++;
    this->Print();
    return * this;
  }
};
int main(){
  Complex c1(1,1),c2(0,0);
  c2=c1.AddOne();
  return 0;
}

对比以下两程序

class A{
  int i;
  public:void Hello(){
    cout<<"hello"<<endl;
  }
};
int main(){
  A*p=NULL;
  p->Hello();
}//输出了hello

class A{
  int i;
  public:
  void Hello(){cout<<i<<"hello"<<endl;}
};
int main(){
  A *p=NULL;
  p->Hello();//程序出错
}

静态成员函数中不能使用this指针！

因为静态成员函数并不具体作用与某个对象！

因此，静态成员函数的真实的参数的个数，就是程序中写出的参数个数！

习题：

一下说法不正确的是：（C）

A）静态成员函数中不能使用this指针

B）this指针就是指向成员函数所作用的对象的指针

C）每个对象的空间中都存放这一个this指针（错误）

D）类的非静态成员函数，真实的参数比缩写的参数多一

2.静态成员

静态成员：在说明前面加了static关键字的成员。

class CRectangle{
  private:
  int w,h;
  static int nTotalArea;//静态成员变量
  static int nTotalNumber;
  public:
  CRectangle(int w_,int h_);
  ~CRectangle();
  static void PrintTotal();//静态成员函数
};

普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。

sizeof运算符不会计算静态成员变量。

class CMyclass{
  int n;
  static int s;
};
//sizeof(CMyclass)等于4

普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。

普通成员函数必须具体作用与某个对象，而静态成员函数并不具体作用于某个对象。

因此静态成员不需要通过对象就能访问。

• 如何访问静态成员

(1)类名::成员名

​ CRectangle::PrintTotal();

(2)对象名.成员名

​ CRectangle r;r.PrintTotal();

(3)指针->成员名

​ CRectangle *p=&r;r->PrintTotal();

(4)引用.成员名

​ CRectangle & ref=r;int n=ref.nTotalNumber;

静态成员变量本质上就是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。

静态成员函数本质上是全局函数。

设置静态成员这种机制的目的是将和某些类紧密相关的全局变量和函数写到类里面，看上去像一个整体，易于维护和理解。

• 静态成员示例

考虑一个需要随时知道矩形总数和总面积的图形处理程序

可以用全局变量来记录总数和总面积

用静态成员将这两个变量封装进类中，就更容易理解和维护

class CRectangle{
  private:
  int w,h;
  static int nTotalArea;
  static int nTotalNumber;
  public:
  CRectangle(int w_,int h_);
  ~CRectangle();
  static void PrintTotal();
};
CRectangle::CRectangle(int w_,int h_){
  w=w_;
  h-h_;
  nTotalNumber++;
  nTotalArea+=w*h;
}
CRectangle::~CRectangle(){
  nTotalNumber--;
  nTotalArea-=w*h;
}
void CRectangle::PrintTotal(){
  cout<<nTotalNumber<<","<<nTotalArea<<endl;
}
int CRectangle::nTotalNumber=0;
int CRectangle::nTotalArea=0;
//必须在定义类的文件中对静态成员变量进行一次说明
//或初始化，否则编译能通过，链接不能通过
int main(){
  CRectangle r1(3,3),r2(2,2);
  //cout<<CRectangle::nTotalNumber;//wrong,私有
  CRectangle::PrintTotal();
  r1.PrintTotal();
  return 0;
}

在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

-以上CRectangle类写法，有缺陷

在使用CRectangle类时，有时会调用复制构造函数生成临时隐藏的CRectangle对象

（调用一个以CRectangle类对象作为参数的函数时，调用一个以CRectangle类对象作为返回值的函数时）

临时对象在消亡时会调用析构函数，减少nTotalNumber和nTotalArea的值，可是这些临时对象在生成时却没有增加nTotal和nTotalArea的值。

解决：为CRectangle类写一个复制构造函数

CRectangle::CRectangle(CRectangle &r){
  w=r.w;h=r.h;
  nTotalNumber++;
  nTotalArea+=w*h;
}

习题：

下面哪个不正确？（B）

A）静态成员函数内部不能访问同类的非静态成员变量，也不能调用同类的非静态成员函数。

B）非静态成员函数不能访问静态成员变量（错误）

C）静态成员变量被所有对象所共享

D）在没有任何对象存在的情况下，也可以访问类的静态成员

3.成员对象和封闭类

有成员对象的类叫做封闭类

class CTyre{
  private:
  int radius;
  int width;
  public:
  CTyre(int r,int w):radius(r),width(w){}
};
class CEngine{
};
class CCar{
  private:
  int price;
  CTyre tyre;
  CEngine engine;
  public:
  CCar(int p,int tr,int tw);
};
CCar::CCar(int p,int tr,int w):price(p),tyre(tr,w){
}
int main(){
  CCar car(20000,17,225);
  return 0;
}

如果CCar类不定义构造函数，则下面的语句会编译出错：

CCar car;

因为编译器不明白car.tyre该如何初始化。car.engine的初始化没问题，用默认构造函数即可。

任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何初始化的。

具体的做法就是：通过封闭类的构造函数的初始化列表。

成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量，只要表达式中的函数或变量有定义就行。

• 封闭类构造函数和析构函数的执行顺序

封闭类对象生成时，先执行所有对象成员的构造函数，然后才执行封闭类的构造函数。

对象成员的构造函数调用次序和对象成员在类中的说明次序一致，与它们在成员初始化列表中出现的次序无关。

当封闭类的对象消亡时，小执行封闭类的析构函数，然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。

class CTyre{
  public:
  CTyre(){cout<<"CTyre constructor"<<endl;}
  ~CTyre(){cout<<"CTyre destructor"<<endl;}
};
class CEngine{
  public:
  CEngine(){cout<<"CEngine constructor"<<endl;}
  ~Cengine(){cout<<"CEngine destructor"<<endl;}
};
CCar{
  private:
  CEngine engine;
  CTyre tyre;
  public:
  CCar(){cout<<"CCar constructor"<<endl;}
  ~CCar(){cout<<"CCar destructor"<<endl;}
};
int main(){
  CCar car;
  return 0;
}
//输出结果
CEngine constructor
CTyre constructor
CCar constructor
CCar destructor
CTyre destructor
CEngine destructor

• 封闭类的复制构造函数

封闭类的对象，如果是用默认复制构造函数初始化的，那么它里面包含的成员对象，也会用复制构造函数初始化。

class A{
  public:
  A(){cout<<"default"<<endl;}
  A(A&a){cout<<"copy"<<endl;}
};
class B{A a};
int main(){
  B b1,b2(b1);
  return 0;
}
//输出：
//default
//copy

说明b2.a使用类A的复制构造函数初始化的。而且调用复制构造函数时的实参就是b1.a。

习题：

以下说法正确的是：（B）

A）成员对象都是用无参构造函数初始化的(有时是复制构造函数)

B）封闭类中的成员对象的构造函数先于封闭类的构造函数被调用

C）封闭类中成员对象的析构函数先于封闭类的析构函数被调用（先封闭类）

D）若封闭类有多个成员对象，则它们的初始化顺序取决于封闭类构造函数中的成员初始化列表（看说明的顺序）

4. 常量对象、常量成员函数和常引用

• 常量对象

如果不希望某个对象的值被改变，则定义该对象的时候可=可以再前面加const关键字。

class Demo{
  private:
  int value;
  public:
  void SetValue(){}
};
const Demo Obj;//常量对象

• 常引用

在类的成员函数后面可以加const关键字，则该成员函数称为常量成员函数。

常量成员函数执行期间不应修改其所作用的对象。因此，在常量成员函数中不能修改成员变量的值（静态成员变量除外），也不能调用同类的非常量成员函数（静态成员函数除外）。

class Sample{
  public:
  int value;
  void GetValue() const;//常量成员函数
  void func(){};//非常量成员函数
  Sample(){}//构造函数
};
void Sample::GetValue() const{
  value=0;//错误
  func();//错误
}
int main(){
  const Sample o;
  o.value=100;//错误，常量对象不可以被修改
  o.func();//错误，常量对象上面不能执行非常量成员函数
  o.GetValue();//正确，常量对象上可以执行常量成员函数
  return 0;
}

• 常量成员函数的重载

class CTest{
  private:
  int n;
  public:
  CTest() {n=1;}
  int GetValue() const {return n;}//常量成员函数
  int GetValue(){return 2*n;}
};
int main(){
  const CTest objTest1;
  CTest objTest2;
  cout<<objTest1.GetValue()<<","<<objTest2.GetValue();
  return 0;
}

• 常引用

引用前面可以加const关键字，成为常引用。不能通过常引用，修改其引用的变量。

const int &r=n;
r=5;//不可以
n=4;//可以

可以用对象的引用作为参数，如：

class Sample{
};
void PrintfObj(const Sample & o){
};

5.友元

友元分为友元函数和友元类两种

1)友元函数：一个类的友元函数可以访问该类的私有成员。

class CCar;
class CDriver{
  public:
  void ModifyCar(CCar * pCar);
};
class CCar{
  private:
  int price;
  friend int MostExpensiveCar(CCar cars[],int total);//声明友元函数
  friend void CDriver::ModifyCar(CCar * pCar);//声明友元函数
}
void CDriver::ModifyCar(CCar * pCar){
  pCar->price+=1000;
}
int MostExpensiveCar(CCar cars[],int total){
  int tmpMax=-1;
  for(int i=0;i<total;++i)
    if(cars[i].price>tmpMax)
      tmpMax=cars[i].price;
  return tmpMax;
}
int main(){
  return 0;
}

可以将一个类的成员函数（包括构造函数、析构函数）说明为另一个类的友元。

class B{
  public:
  void function();
};
class A{
  friend void B::function();
};

2)友元类：如果A是B的友元类，那么A的成员函数可以访问B的私有成员。

class CCar{
  private:
  int price;
  friend class CDriver;//声明CDriver为友元类
};
class CDriver{
  public:
  CCar mycar;
  void ModifyCar(){
    myCar.price+=1000;//因CDriver是CCar的友元类，因此可以访问其私有成员
  }
};

友元类之间的关系不能传递，不能继承。

习题：

以下关于友元的说法哪个是不正确的（B）

A）一个类的友元函数可以访问该类对象的私有成员

B）友元类的关系是相互的，即若类A是类B的友元，则类B也是类A的友元（错误）

C）在一个类中可以将另一个类的成员函数声明为友元

D）类之间的友元关系不能传递