第4章 类和对象(2)

对象的引用作为函数参数
本质上对原对象操作，传递效率高
可以改变实参对应的对象
示例：
void changeColor(Dog &rdog, char *color) {
rDog.setColor(color);
} Dog dog; changeColor(dog, “red”); cout<<“dog’s new color is”<<dog.getColor()<<endl;
友元类（friend class)
一个类是另一个类的友元
该友元类的所有成员函数都是这个类的友元
class complex { private: double real, image; public: friend class Play; }; class Play { private: public: void showComplex(); complex Add(complex &); }
}; 不允许改变该类的所有数据成员！
常对象
const Dog dog(“Tom”,”black”,4); 定义时必须初始化 不允许改变数据成员的值 只能调用常成员函数 综合示例：p120, 例4.16
作业： 4-7 4-8 4-9 4-10
对象的指针作为函数参数
仅仅传递对象的地址，传递效率高
可以改变实参对应的对象
示例：
void changeColor(Dog *pdog, char *color) {
pDog->setColor(color);
} Dog dog; changeColor(&dog, “red”); cout<<“dog’s new color is”<<dog.getColor()<<endl;
class Play { private: public: void showComplex( ); };//这个类须写在complex类前 void Play::showComplex() { complex c1(10,20); cout<<c1.real<<“+”<<c1.image<<“i”; }//这个函数须写在complex类之后
友元成员函数
另一个类的成员函数可作为本类的友元
class complex { // 复数类 private: double real, image;//实部，虚部 public: add(complex &c) { real += c.real; image +=c.image; } friend void Play::showComplex(); };
P p; Q q; R r; public: X(参数表0):p(参数表1):r(参数表2):q(参数表3) { …… }
}; 首先构造p，然后q，然后r，最后X；按对象定义的次序构造！ 析构顺序正好相反
示例(P116,例4.14）
日程表对象，含有
日期对象 时间对象
观察所有对象的构造，析构次序
const
Sample & Sample::Set(int i) {
this->i = i; return *this;
}
对象数组和对象指针
对象数组
以对象为元素的数组
Dog dog[100];//每个元素均调用一次默认构造函数
定义时初始化
每个元素均调用一次构造函数 Dog dog[3]={Dog(“Tom”,”yellow”,1), Dog(“John”,”Black”), Dog(“spotty”,”black&white”,2);
对象作为函数参数
即实参赋给形参，浅拷贝 bool IsBlackDog(Dog tdog) {
return true;
tdog = thisDog
if (!strcmp(tdog.getColor(), “black”)) { else
return false;
} Dog thisDog(“Tom”,”black”,4); if (IsBlackDog(thisDog)) cout<<“I like black dog.”;
破坏了类的封装性，不提倡使用！
友元函数
普通函数访问类的私有成员 示例
class complex { // 复数类 private: double real, image; //实部，虚部 public: add(complex &c) { real += c.real; image +=c.image; } friend void showComplex(const complex &c); } void showComplex(const complex &c) { cout<<c.real<<“ + ”<<c.image<<”i”; }
static members
静态成员
静态数据成员的定义和使用
示例：
class Dog { private: static int serialno;//私有静态数据成员 char name[15]; int age; public: static int totalNumber; //公有有静态数据成员，可以在对象未定义时使用 Dog() { char name[15]; sprintf(name,“dog%d”,serialno++); strcpy(, name); } … }; int Dog::serialno=0; //私有静态数据成员必须在类外初始化 p = new Dog[100];
第4章 类和对象(2)
目录
this指针 对象数组和对象指针 对象作为函数参数 静态成员 友元(friend) 对象成员 常对象
this指针
THIS 指针
this指针
一个指
不需要声明或定义，直接使用 this->age=tage;
区别数据成员和局部变量：this->age = age 返回当前对象的引用：
object data members
对象成员
对象成员的定义和使用
一个类的数据成员可以是属于另一个类的对象 示例
class A { } class B {
private: A a;
对象的嵌套，比如Dog类可以包括Eye类、Food类…
}
对象成员的构造
除了调用类本身的构造函数，还要调用对象成员的构造函数 class P,Q,R; class X {
friend
友元
私有数据成员也能在类外访问？
破例，不遵守规则
一般人不行，朋友可以破例
一个类可以指定“友元”，友元可以访问 该类的私有数据成员 友元可以是
一个普通函数，如IsBlackDog(Dog &dog); 某个类的成员函数，如Cat.ShowDogs( ); 某个类，这个类的所有成员函数均可访问本类
访问元素
dog[2].bark( );
使用new、delete操作对象
动态创建和删除对象 示例：
Dog *p; char dogname[15]; p = new Dog[100]; for (int i=0;i<100;i++) {
sprintf(dogname, “dog %d”, i); Dog[i].setName(dogname);
只能在本类内使用 必须在类外初始化
静态成员函数
属于类，而不属于对象 定义：
没有对象照样可以调用 只能访问静态数据成员
访问
class Dog { … static void showSerialNo(); … } void Dog::showSeriaNo() { … } 通过类访问：Dog::showSerialNo(); 通过对象访问： dog.showSerialNo();
静态数据成员的说明
公有静态数据成员(public型)
Dog::totalNumber=100;
用类访问（在对象未定义时使用） 用对象访问（在对象定义后使用）
Dog dog; dog.totalNumber=50;
私有静态数据成员(private型) 属于同一类的对象，其静态数据成员共享同一 内存，取同样的值，不论对象如何改变
常数据成员 常成员函数 常对象
常数据成员
class Test {
const double PI; //这里禁止初始化 Test(int x ):PI(x){ }
}; Test t(3.1); 不一定要用常量初始化！
常成员函数
class Dog { ……
public:
void selfIntroduction( ) const;
} delete[ ] p; (本例也可使用静态成员在构造函数中设置name)
对象指针
Dog * pDog; pDog = new Dog(“Tom”); pDog->bark( ); (*pDog).selfIntroduction( ); delete pDog; 与普通变量用法无异！
对象作为函数参数