C++个人学习笔记三（this指针，静态成员，成员对象和封闭类，友元，常量成员函数）

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 ++; //等价于 real ++;
this->Print(); //等价于 Print
return * this;
}
}; 
int main() {
Complex c1(1,1),c2(0,0);
c2 = c1.AddOne();
return 0;
} //输出 2,1

静态成员函数中不能使用 this 指针！ 因为静态成员函数并不具体作用与某个对象! 因此，静态成员函数的真实的参数的个数，就是程 序中写出的参数个数！

 

静态成员

 

静态成员：在说明前面加了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; p->PrintTotal();

4) 引用.成员名 CRectangle & ref = r; int n = ref.nTotalNumber;

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

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

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

void CRectangle::PrintTotal()
{
cout << w << "," << nTotalNumber << "," <<
nTotalArea << endl; //wrong
}
CRetangle::PrintTotal(); //解释不通，w 到底是属于那个对象的？

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

成员对象和封闭类

 

有成员对象的类叫 封闭（enclosing)类。

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

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

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

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

class CTyre {
public:
CTyre() { cout << "CTyre contructor" << endl; }
~CTyre() { cout << "CTyre destructor" << endl; }
};
class CEngine {
public:
CEngine() { cout << "CEngine contructor" << endl; }
~CEngine() { cout << "CEngine destructor" << endl; }
};
class CCar {
private:
CEngine engine;
CTyre tyre;
public:
CCar( ) { cout << “CCar contructor” << endl; }
~CCar() { cout << "CCar destructor" << endl; }
};
int main(){
CCar car;
return 0;
}

输出结果：

CEngine contructor
CTyre contructor
CCar contructor
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。

友元

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

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

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); //声明友元
};
友元（friends,P199）
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的友元类，
//故此处可以访问其私有成员
}
};
int main(){ return 0; }

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

常量成员函数

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

class Sample {
private :
int value;
public:
Sample() { }
void SetValue() { }
};
const Sample Obj; // 常量对象
Obj.SetValue (); //错误 。常量对象只能使用构造函数、析构函数和 有
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,一个不是，算重载。

可以在const成员函数中修改的成员变量

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