第三讲 类和对象提高

第三讲 类和对象提高

1 this指针

1、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指针作用：（1）指向成员函数所作用的对象

(2)非静态成员函数中可以直接使用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 ++; //等价于 real ++; 
this->Print(); //等价于 Print
return * this;
}

int main()
{
Complex c1(1,1),c2(0,0);
c2=c1.AddOne();
return 0;
}

//输出2,1

2 静态成员函数

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

静态函数并不具体作用与某个对象，静态成员函数的真实的参数的个数，就是程序中写出的参数个数。

2.1静态成员

1、概念：在定义前面加了static关键字的成员。

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

注意：

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

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

普通成员函数必须作用与某一个对象，而静态成员函数并不具体作用与某一个对象，静态成员不通过对象就能访问。

2、如何访问静态成员

类名：：成员名

CRectangle::PrintTotal();

对象名.成员名

CRectangle r;r.PrintTotal();

指针->成员名

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

引用.成员名

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

注意：

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

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

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

example1:

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类对象作为函数的返回值时;

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

3、成员对象和封闭类

一个类的成员变量如果是另一个类的对象就称为成员对象，有成员对象的类叫封闭类（enclosing）

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;
}

任何生成封闭类对象的语句,都要让编译器明白,对象中的成员对象是如何初始化的。
具体的做法就是:通过封闭类的构造函数的初始化列表。

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

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

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

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

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

封闭类的复制构造函数：

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

4、友元（friends）

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

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

class CCar ; //提前声明 CCar类,以便后面的CDriver类使用
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();
};

友元类：如果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的友元类,
//故此处可以访问其私有成员
}
};
int main(){
return 0; }

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

5、常量成员函数

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

注意：<!–常量对象只能使用构造函数、析构函数和有const说明的函数

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

常量成员函数内部不能改变属性的值，也不能调用非常量成员函数–>

class Sample {
private :
int value;
public:
void func() { };
Sample() { }
void SetValue() const {
value = 0; // wrong
func(); //wrong
}
};
const Sample Obj;
Obj.SetValue (); //常量对象上可以使用常量成员函数

在定义常量成员函数和声明常量成员时都应该使用const关键字。

class Sample {
private :
int value;
public:
void PrintValue() const;
};
void Sample::PrintValue() const { //此处不使用const会
//导致编译出错
cout << value;
}
void Print(const Sample & o) {
o.PrintValue(); //若 PrintValue非const则编译错
}

常量成员函数：如果一个成员函数中没有调用非常量成员函数，也没有修改其成员变量的值，最好将其写成常量成员函数。

常量成员函数的重载：两个函数,名字和参数表都一样,但是一个是const,一个不是,算重载。

#include <iostream>
using namespace std;
class CTest {
private :
int n;
public:
CTest() { n = 1 ; }
int GetValue() const { return n ; }
int GetValue() { return 2 * n ; }
};

mutable成员变量：可以在const成员函数中修改成员变量。

class CTest
{
public:
bool GetData() const
{
m_n1++;
return m_b2;
}
private:
mutable int m_n1;
bool m_b2;
};