C++第6章 静态成员与友元

25
静态成员函数 class Directory{ public: static void setpath(char const *newpath); // 静态公有的函数 private: static char path [];// 静态字符串 }; char Directory::path [199] = "/usr/local"; //静态数据成员的初始化 void Directory::setpath(char const *newpath) // 静态函数 { strncpy(path, newpath, 199); } void main() { Directory::setpath("/etc"); // 通过类名调用setpath()成员函数 Directory dir; 26 setpath()成员函数 dir.setpath("/etc");//通过象调用 }
20
const成员函数
class Point { public: int GetX() const; //const成员函数 int GetY() const; //const成员函数 void SetPt (int, int); void OffsetPt (int, int); private: int xVal, yVal; }; int Point::GetY() const //const成员函数的实现 { return yVal; } const成员函数应该在函数原型说明和函数定义中都增加const限定：
11
6-1-4 静态成员函数
静态成员函数
#include<iostream.h> class Student { public： static char* sName() //静态成员函数是所有对象共享的 { cout<<noOfStudents<<endl； return name； //error哪个对象? } 一个静态成员函数不与任 protected： 何对象相联系，故不能对 char name[40]； 非静态成员进行默认访问 static int noOfStudents； }；
一个指向一个链表第一成员的指针 定义为static
#include <iostream> #include <string.h> class Student {
public: 避免了定义一个 Student(char* pName); 全局的pFirst ~Student(); protected: static Student* pFirst; Student* pNext; char name[40];
};
10
6-1-4 静态成员函数
静态成员函数
返回静态成员函数定义是类的内部实现，属于类定义的一部分。 它的定义位置与一般成员函数一样。 一个静态成员函数不与任何对象相联系，故不能对非静态成员进 行默认访问。
class Student { public: static int number( ) { //静态成员函数 return noOfStudents; } protected: char name[40]; static int noOfStudents; };
24
嵌套类和局部类中静态成员变量的使用
嵌套类中的静态成员变量 class outer{ class inner { static int i; //正确 }; }; int outer::inner::i = 100; 局部类中静态成员变量 void f(){ class local { static int i; //错误 }; }
6-2 友元函数
友元的使用 在类里声明一个普通函数，标上关键字friend，就成了该类的友元， 可以访问该类的一切成员。 一个类的成员函数可以是另一个类的友元。
class Student { public： //... friend void Teacher:: assignGrades(Student); protected： Teacherx pT； int semesterHours； float gpa； }；
16
6-2 友元函数
整个类可以是另一个类的友元，该友元称为友 类
友类的每个成员函数都可访问另一个类中的保护或私有数据 成员
class Student { public: friend class Teacher；//友类 }; float gpa；
class Teacher { public: void assignGrades(Student& s)； //赋成绩 void adjustHours(Student& s); //调整学时数 //… protected： void noOfStudents; Student* pList[100]； }
12
6-2 友元函数
友元函数
需要友元的原因
• 有时候，普通函数需要直接访问一个类的保护或私有数据成员。 • 需要友元的另一个原因是为了方便重载操作符的使用。
友元函数不是成员函数，它是类的朋友，因而能够访问类的全部 成员。 在类的内部，只能声明它的函数原型，加上friend关键字
13
14
6-2 友元函数
友元函数提高效率的例子
Vector Multiply(Matrix&m,Vector&v) //友元定义 { if(m．szr!= v.sz) //直接访问保护数据 { cerr<<”badmultiplying MatrixwithVector.／n"； exit(1)； } Vector r(m.sz1)； //直接访问保护数据 for(int i=0；i<m.sz1; i++) //直接访问保护数据 { r.V[i]=0； //直接访问保护数据 for(int j=0; j<m.szr；j++) //直接访问保护数据 r.V[i]+=m.m[i*m.szr+j]*v.v[j]；//直接访问保护数据 } return r； 15 }
局部类
void Render (Image &image) { class ColorTable { //在方法内定义的局部类 public: ColorTable(void) { /* ... */ } AddEntry(int r, int g, int b) { /* ... */ } }; ColorTable colors; //在方法内定义的局部类对象 } 局部类不能在其局部作用域外访问 局部类必须完全定义在局部作用域内。所以，它的所有成员函数必须是内联的， 这就决定了局部类的成员函数
6-2 友元函数
友元函数提高效率的例子
#include <iostream> class Vector{ public: Vector(int); ~Vector( ){ delete[ ]v; } //将堆中数组空间返还 Vector(Vector & ); int Size( ){ return sz; } void Display( ); int& Elem(int); //返回向量元素 friend Vector Multiply(Matrix& m,Vector& v); protected: int* v; //指向一个数组,表示向量 int sz; //元素个数 };
17
类的作用域
类本身可被定义在三种作用域内： 1. 全局作用域。这是所谓全局类，绝大多数的C++类是定义在 该作用域中，我们在前面定义的所有类都是在全局作用域中。 2. 在另一个类的作用域中。这是所谓嵌套类，即一个类包含在 另一个类中。 3. 在一个块的局部作用域中。这是所谓局部类，该类完全被块 包含
int Student::noOfStudents =0; //静态数据成员在类外分配空间和初始化
8
6-1-3 静态数据成员
静态数据成员用得比较多的场合一般为：
用来保存流动变化的对象个数 作为一个标志，指示一个特定的动作是否发生 一个指向一个链表第一成员或最后一个成员的指针
9
6-1-3 静态数据成员
4
本章结构
静态成员的需要性
静态成员的使用 静态成员 静态数据成员
静态成员与友元
wk.baidu.com静态成员函数
友元
5
6-1-1 静态成员的需要性
有一些属性是类中所有对象共有的 如果放在全局变量中，则它们在类的外面，既不 安全，又影响了重用性
class Student
{
//... protected： Student* pFirst； //链表首指针 int count； //学生数 }； 这两个信息是每个
对象都有的,却没有 集中成一个成员供 所有对象共享。
6
6-1-2 静态成员使用
静态成员的使用
class Student {
//....
protected: static int noOfStudents; //定义类的静态成员
}
S1,S2是两个Student对象
S1.noOfStudents
==
21
const成员函数
class Set { public: Set (){} bool Member(const int) const; void AddElem(const int); }; bool Set::Member (const int elem) const { } 非常量成员函数不能被常量成员对象调用，因为它可能企图修改常量的数 据成员： const Set s; s.AddElem(10); // 非法: AddElem不是常量成员函数 s.Member(10); // 正确 但构造函数和析构函数对这个规则例外，它们从不定义为常量成员，但 可被常量对象调用（被自动调用）。它们也能给常量的数据成员赋值，除非数 据成员本身是常量。
第五章内容回顾
动态内存分配
堆 需要new和delete的原因 分配堆对象
拷贝构造函数
拷贝构造函数的概念 临时对象和无名对象 构造函数用于类型转换
1
第六章
静态成员与友元
2
预习检查
什么关键字标识了静态成员? 什么关键字标识了友元?
3
3
本章目标
静态成员 友元
18
嵌套类
class Rectangle { public: Rectangle (int, int, int, int); class Point { //定义一个嵌套类 public: Point (int, int); private: int x, y; }; Point topLeft, botRight; //声明嵌套类对象 }; Rectangle::Point::Point (int x, int y){}//嵌套类函数定义 void main() { Rectangle::Point pt(1,1); //嵌套类对象的定义 } 19
22
const成员函数和const对象
const int i=1 ；//定义整型常量 const classA a(2)；//定义常量对象 为了确保const对象的数据成员不会被改变，在C++中， const对象只能调用const成员函数。不能调用非const成员函数
23
静态数据成员 静态数据成员：类的静态数据成员仅创建和初始化一次，且在程序 开始执行的时候创建，然后被该类的所有对象共享 静态数据成员的访问方式是： 类名::静态数据成员名 class Test { public: static int public_int; private: static int private_int; }; int Test::public_int=145; void main() { printf("%d\n",Test::public_int); // 正确 } 注意：静态数据成员的初始化必须在类外
S2.noOfStudents
==
Student:: noOfStudents
7
6-1-2 静态成员使用
Student(char* pName ="no name") { cout <<"create one student\n"; strncpy(name, pName,40); name[39]='\0'; noOfStudents++; //静态成员：每创建一个对象，学生人数增1 cout <<noOfStudents <<endl; } ~Student() { cout <<"destruct one student\n"; noOfStudents--; //每析构一个对象，学生人数减1 cout <<noOfStudents <<endl; }