程序设计与算法（三）C++面向对象程序设计-郭炜 第三周
总结整理：
目录：
- 1.this指针
- 2.静态成员
- 3.成员对象和封闭类
- 4.友元 （friends)
- 5.常量成员函数
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 ++; //等价于 real ++; this->Print(); //等价于 Print return * this; }
}; int main() { Complex c1(1,1),c2(0,0); c2 = c1.AddOne(); //c1被修改，把c1的值赋值给c2return 0;
} //输出 2,1class A { int i;public: void Hello() { cout << "hello" << endl; }
}; // void Hello(A * this ) { cout << "hello" << endl; } int main()
{ A * p = NULL; p->Hello(); // Hello(p);
}
// 输出：hello--------------------------------------------
class A { int i;public: void Hello() { cout << i << "hello" << endl; }
}; // void Hello(A * this )// { cout << this->i << "hello" << endl; }
//this若为NULL，则出错！！ 找不到空指针指向的对象的i
int main()
{ A * p = NULL; p->Hello(); // Hello(p);
}
// 输出：hello
静态成员函数中不能使用 this 指针！
因为静态成员函数并不具体作用与某个对象!
因此，静态成员函数的真实的参数的个数，就是程序中写出的参数个数！
类的非静态成员函数，真实的参数比所写的参数多1，多出来的是this指针
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; p->PrintTotal(); 并不只属于到p所指向的那个对象
4) 引用.成员名
CRectangle & ref = r; int n = ref.nTotalNumber
静态成员示例
考虑一个需要随时知道矩形总数和总面积的图形 处理程序
可以用全局变量来记录总数和总面积
用静态成员将这两个变量封装进类中，就更容易 理解和维护
#include<iostream>
using namespace std; 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; }//输出结果： //2,13//2,13此CRectangle类写法， 有何缺陷？
在使用CRectangle类时，有时会调用复制构造函数 生成临时的隐藏的CRectangle对象
调用一个以CRectangle类对象作为参数的函数时,
调用一个以CRectangle类对象作为返回值的函数时
临时对象在消亡时会调用析构函数，减少nTotalNumber 和 nTotalArea的值，可是这些临时对象在生成时却没有增加 nTotalNumber 和 nTotalArea的值，因此最终可能数量小于应有的。
解决办法：为CRectangle类写一个复制构造函数
CRectangle :: CRectangle(CRectangle & r )
{w = r.w; h = r.h; nTotalNumber ++; nTotalArea += w * h;
}在静态成员函数中，不能访问非静态成员变量， 也不能调用非静态成员函数。非静态成员函数可能需要调用非静态成员变量，那不能确定是哪一个非静态成员变量，因此不能
void CRectangle::PrintTotal()
{ cout << w << "," << nTotalNumber << "," << nTotalArea << endl; //wrong}
CRetangle::PrintTotal(); //解释不通，w 到底是属于那个对象的？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; }上例中，如果 CCar类不定义构造函数， 则下面的语句会编译出错：
CCar car;
因为编译器不明白 car.tyre该如何初始化。car.engine 的初始化没问题，用 默认构造函数即可。
任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何 初始化的。
具体的做法就是：通过封闭类的构造函数的初始化列表。
成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量 ，只要表达式中的函数或变量有定义就行。
封闭类构造函数和析构函数的执行顺序
封闭类对象生成时，先执行所有对象成员的构造函数，然后才执 行封闭类的构造函数。
对象成员的构造函数调用次序和对象成员在类中的说明次序一致 ，与它们在成员初始化列表中出现的次序无关。
当封闭类的对象消亡时，先执行封闭类的析构函数，然后再执行 成员对象的析构函数。次序和构造函数的调用次序相反。
封闭类实例
#include<iostream>
using namespace std;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
**/4.友元 （friends)
友元分为友元函数和友元类两种
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); //声明友元
};
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; }友元类之间的关系不能传递，不能继承
5.常量成员函数
如果不希望某个对象的值被改变，则定义该对象的时候可以在前面加 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,一个不是，算重载。
#include <iostream>
using namespace std;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;
}
//1,2mutable成员变量
可以在const成员函数中修改的成员变量
class CTest { public: bool GetData() const { m_n1++; return m_b2; } private: mutable int m_n1; bool m_b2;
};lsof linux命令,***Linux命令实时监测系统（top,htop,iotop,lsof,tcpdump,netstat,vmstat,iostat）...)
