1.友员有三种形式：
友员类、友员成员函数和友员函数。
2.友员可以访问并修改类的私有或保护数据调用类的私有或保护成员函数，使类既有封装性，又有灵活性
3.友员关系不能传递
，
不是互逆的。
第八讲 类与对象
6.5 静态成员和对象组织
6.6 模板静态成员为什么引入静态成员? 创建了一个对象，则这个对象将拥有所有类中的成员，如果某个数据对所有对象都一样，则这个数据只要有一个拷贝，而不是每个对象都重复定义这个数据，形成内存浪费。简言之：一个数据拷贝，所有对象共享。
§ 6.5 静态成员和对象组织例如有类：
class student {
char *name,*num;
int total; //学生总人数
public,…… };
应用程序中声明对象为：
student a,b,c;
则对象 a,b,c 中都有数据 total，而学生总数是一样的，
所以 total 被重复定义了两次。若把 total 声明为静态成员，就可避免这个问题。
§ 6.5 静态成员和对象组织静态数据成员定义形式? 在所要定义的数据成员前加关键字 static,
如,
class student {
char *name,*num;
static int total;
public,…… };
将学生总人数 total 声明为静态成员
§ 6.5 静态成员和对象组织例 1：静态数据成员的应用（与教材例题不同）
#include <iostream.h>
#include <string.h>
class st_n {
public:
};
st_n(char *,char *);
~st_n( );
void print( );
char *name,*num; //学生姓名、学号。
static int total; //学生总人数,静态数据
§ 6.5 静态成员和对象组织
st_n::st_n(char *n1,char *n2) {
name=new char[strlen(n1)+1];
num =new char[strlen(n2)+1];
strcpy(name,n1);
strcpy(num,n2);
++total; //学生人数加 1 }
int st_n::total=0; //静态成员的初始化
void st_n::print( ) {
cout << "\n name:" << name
<< "\n num," << num
<< "\n total," << total; }
st_n::~st_n ( ) {
delete [ ] name;
delete [ ] num;
- -total; //学生人数减 1 }
§ 6.5 静态成员和对象组织
void main( ) {
st_n a("Wang ","000001 ");
st_n b("Yang ","000002 ");
st_n c(" Tang ","000003 ");
a.print( );
b.print( ); }
结果,name,Wang
num,000001
total,3
name,Yang
num,000002
total,3
注意,a,b,c 的 total 都是 3，即说明静态成员只有一个,且为所有对象共享。
§ 6.5 静态成员和对象组织例 1 有关内容总结
1,total 被声明为静态成员数据,a,b,c三个对象共享这个数据成员，即只有一个拷贝。
2,静态数据必须在应用之前初始化,格式为：
类型名 类名,:数据名 =初始值； 如：
int st_n::total = 0;
3,静态数据可声明为 private 或 public,
§ 6.5 静态成员和对象组织静态函数注意点
只能访问静态数据,不能访问其它成员。
可以没有对象而进行函数调用。
目的,对静态数据成员进行访问修改。
形式,在一般函数声明前加 static
§ 6.5 静态成员和对象组织例：静态函数的应用（接前例）
#include <iostream.h>
#include <string.h>
class st_n {
public:
};
st_n(char *,char *);
~st_n( );
void print( );
static int getTotal( ); //静态函数
char *name,*num; //学生姓名、学号。
static int total; //学生总人数,静态成员
§ 6.5 静态成员和对象组织
st_n::st_n(char *n1,char *n2) {
name=new char[strlen(n1)+1];
num =new char[strlen(n2)+1];
strcpy(name,n1);
strcpy(num,n2);
++total; //学生人数加 1 }
int st_n::total=0; //静态成员的初始化
§ 6.5 静态成员和对象组织
void st_n::print( ) {
cout << "name:" << name << endl;
<< "num," << num << endl; }
st_n::~st_n ( ) {
delete [ ] name;
delete [ ] num;
- -total; //学生人数减 1 }
int st_n::getTotal( ) //定义静态函数
{
return total; //只能访问静态函数
}
§ 6.5 静态成员和对象组织
void main( ) {
st_n a("Wang ","000001 ");
st_n b("Yang ","000002 ");
st_n c(" Tang ","000003 ");
a.print( );
cout << " total," << a.getTotal << endl;
b.print( );
cout << " total," << st_n::getTotal << endl; }
结果,name,Wang
num,000001
total,3
name,Yang
num,000002
total,3
§ 6.5 静态成员和对象组织例 2 有关内容总结
1,函数 getTotal 被声明为静态成员函数；
2,静态函数可以通过对象调用,也可以通过无对象调用；
如,
a.getTotal( ); //由对象调用
st_n::getTotal( ); //由类属名调用
3,静态函数只能对静态数据进行操作,不能对其它数据进行操作。
§ 6.5 静态成员和对象组织模 板 (template)
什么要定义模板? 对不同类型的数据进行同样的操作,
由于类型不同这些操作要重复定义,如求两数的和,
int add(int a,int b)
{ return a+b; }
float add(float a,float b)
{ return a+b; }
前者为求两整数的和,后者为求两实数的和,函数体内的操作都一样,但我们必须重复这些定义,如果应用模板,可将类型参数化,只建立一个抽象的形式,具体作用于什么类型到应用时再决定。
§ 6.6 模板函数模板例 3,函数模板的应用
#include <iostream.h>
template <class Type> //声明模板
void sort(Type x[ ],int size)
{
for (int i=0; i<size-1; i++)
for (int j=i+1; j<size; j++)
if(x[i] >x[j] ) {
Type t=x[i];
x[i]= x[j];
x[j]=t; }
}
§ 6.6 模板
void mian( )
{
int a[ ]={4,3,4,5,8,9};
double d[9]={2.0,4.3,1.8,9.5};
sort(a,6); //对整 型数进行排序
sort(d,9); //对双精度实型进行排序
cout << " \n output sort for int a,"
for(int i=0; i<6; i++) cout << a[i] << ",";
cout << " \n output sort for double d," ;
for(int j=0; j<9; j++) cout << d[j] << ",";
}
结果,output sort for int a,3,4,4,5,8,9,
output sort for double d,0.0,0.0,0.0,
0.0,0.0,1.8,2.0,4.3,9.5,
§ 6.6 模板例 3 有关内容总结
1,定义了一个模板函数 sort,将类型声明为函数的形式 参数；
2,在函数的具体调用中,形式参数的类型为,
int 和 double；
3,仅定义了一个模板,可应用于多种类型,使编程简便,代码重用；
4,类型放在 < > 中,而不是 [ ] 或 ( ) 中。
§ 6.6 模板例 4,函数模板的应用
#include <iostream.h>
template <class T> //声明模板
T max(T a,T b)
{
return (a>b? a:b);
}
void main( )
{ int a=9,b=99;
cout << "max(a,b)," << max(a,b) << endl;
float c=5.0,d=9.0;
cout << "max(c,d)," << max(c,d) <<endl;
}
§ 6.6 模板结果,
max(a,b),99
max(c,d),9.0
例 4 有关内容总结
1,定义了一个模板函数 max,将类型声明为函数的形式 参数。
具体形式为,
template <class T>
T max( T a,T b) {……}
2,在函数的具体调用中,形式参数的类型为 int 和 double。
3,仅定义了一个模板,可应用于多种类型,使编程简便,代码重用。
§ 6.6 模板
1,静态成员有,
静态数据 和 静态函数 。
2,静态成员可以通过 对象调用,
也可以通过 类属直接调用,如,
cout << a.getTotal( );
//对象调用
cout << st_n::getTotal( );
// 类属调用
3,不管创建多少对象,静态成员只有一个拷贝,所有对象 共享这个静态成员。
4,静态数据必须初始化,静态函数只能对静态数据进行操作。
5,定义了一个模板,可应用于多种类型,使编程简便,代码重用。
一,判断题 (说明理由 )
1,静态数据只可以由静态函数访问和修改。
2,静态数据为所有对象共享,
所以可认为静态数据是属于类的,而不是属于对象的。
3,静态数据和函数只能声明为公有类型。
二,应用静态数据和静态函数的作用是什么?
静态数据与普通数据有何区别?
三,改错并说明理由,
(1) include <iostream.h>;
class example ( )
{
private:
int date;
static int count
public;
void example( int y= 10) ( date=y;)
static int getcount { }
( cout <<,date=,<< date;
return count; )
}
(2) Template (class T)
T max(T a; T b; Tc );
//求 a,b,c 的最大值
{ int t;
if(a>b)
{
if(a>c) t=a
else t=c; }
else;
{
if(b>c) t=c;
else t=b;
}
};
友员类、友员成员函数和友员函数。
2.友员可以访问并修改类的私有或保护数据调用类的私有或保护成员函数，使类既有封装性，又有灵活性
3.友员关系不能传递
，
不是互逆的。
第八讲 类与对象
6.5 静态成员和对象组织
6.6 模板静态成员为什么引入静态成员? 创建了一个对象，则这个对象将拥有所有类中的成员，如果某个数据对所有对象都一样，则这个数据只要有一个拷贝，而不是每个对象都重复定义这个数据，形成内存浪费。简言之：一个数据拷贝，所有对象共享。
§ 6.5 静态成员和对象组织例如有类：
class student {
char *name,*num;
int total; //学生总人数
public,…… };
应用程序中声明对象为：
student a,b,c;
则对象 a,b,c 中都有数据 total，而学生总数是一样的，
所以 total 被重复定义了两次。若把 total 声明为静态成员，就可避免这个问题。
§ 6.5 静态成员和对象组织静态数据成员定义形式? 在所要定义的数据成员前加关键字 static,
如,
class student {
char *name,*num;
static int total;
public,…… };
将学生总人数 total 声明为静态成员
§ 6.5 静态成员和对象组织例 1：静态数据成员的应用（与教材例题不同）
#include <iostream.h>
#include <string.h>
class st_n {
public:
};
st_n(char *,char *);
~st_n( );
void print( );
char *name,*num; //学生姓名、学号。
static int total; //学生总人数,静态数据
§ 6.5 静态成员和对象组织
st_n::st_n(char *n1,char *n2) {
name=new char[strlen(n1)+1];
num =new char[strlen(n2)+1];
strcpy(name,n1);
strcpy(num,n2);
++total; //学生人数加 1 }
int st_n::total=0; //静态成员的初始化
void st_n::print( ) {
cout << "\n name:" << name
<< "\n num," << num
<< "\n total," << total; }
st_n::~st_n ( ) {
delete [ ] name;
delete [ ] num;
- -total; //学生人数减 1 }
§ 6.5 静态成员和对象组织
void main( ) {
st_n a("Wang ","000001 ");
st_n b("Yang ","000002 ");
st_n c(" Tang ","000003 ");
a.print( );
b.print( ); }
结果,name,Wang
num,000001
total,3
name,Yang
num,000002
total,3
注意,a,b,c 的 total 都是 3，即说明静态成员只有一个,且为所有对象共享。
§ 6.5 静态成员和对象组织例 1 有关内容总结
1,total 被声明为静态成员数据,a,b,c三个对象共享这个数据成员，即只有一个拷贝。
2,静态数据必须在应用之前初始化,格式为：
类型名 类名,:数据名 =初始值； 如：
int st_n::total = 0;
3,静态数据可声明为 private 或 public,
§ 6.5 静态成员和对象组织静态函数注意点
只能访问静态数据,不能访问其它成员。
可以没有对象而进行函数调用。
目的,对静态数据成员进行访问修改。
形式,在一般函数声明前加 static
§ 6.5 静态成员和对象组织例：静态函数的应用（接前例）
#include <iostream.h>
#include <string.h>
class st_n {
public:
};
st_n(char *,char *);
~st_n( );
void print( );
static int getTotal( ); //静态函数
char *name,*num; //学生姓名、学号。
static int total; //学生总人数,静态成员
§ 6.5 静态成员和对象组织
st_n::st_n(char *n1,char *n2) {
name=new char[strlen(n1)+1];
num =new char[strlen(n2)+1];
strcpy(name,n1);
strcpy(num,n2);
++total; //学生人数加 1 }
int st_n::total=0; //静态成员的初始化
§ 6.5 静态成员和对象组织
void st_n::print( ) {
cout << "name:" << name << endl;
<< "num," << num << endl; }
st_n::~st_n ( ) {
delete [ ] name;
delete [ ] num;
- -total; //学生人数减 1 }
int st_n::getTotal( ) //定义静态函数
{
return total; //只能访问静态函数
}
§ 6.5 静态成员和对象组织
void main( ) {
st_n a("Wang ","000001 ");
st_n b("Yang ","000002 ");
st_n c(" Tang ","000003 ");
a.print( );
cout << " total," << a.getTotal << endl;
b.print( );
cout << " total," << st_n::getTotal << endl; }
结果,name,Wang
num,000001
total,3
name,Yang
num,000002
total,3
§ 6.5 静态成员和对象组织例 2 有关内容总结
1,函数 getTotal 被声明为静态成员函数；
2,静态函数可以通过对象调用,也可以通过无对象调用；
如,
a.getTotal( ); //由对象调用
st_n::getTotal( ); //由类属名调用
3,静态函数只能对静态数据进行操作,不能对其它数据进行操作。
§ 6.5 静态成员和对象组织模 板 (template)
什么要定义模板? 对不同类型的数据进行同样的操作,
由于类型不同这些操作要重复定义,如求两数的和,
int add(int a,int b)
{ return a+b; }
float add(float a,float b)
{ return a+b; }
前者为求两整数的和,后者为求两实数的和,函数体内的操作都一样,但我们必须重复这些定义,如果应用模板,可将类型参数化,只建立一个抽象的形式,具体作用于什么类型到应用时再决定。
§ 6.6 模板函数模板例 3,函数模板的应用
#include <iostream.h>
template <class Type> //声明模板
void sort(Type x[ ],int size)
{
for (int i=0; i<size-1; i++)
for (int j=i+1; j<size; j++)
if(x[i] >x[j] ) {
Type t=x[i];
x[i]= x[j];
x[j]=t; }
}
§ 6.6 模板
void mian( )
{
int a[ ]={4,3,4,5,8,9};
double d[9]={2.0,4.3,1.8,9.5};
sort(a,6); //对整 型数进行排序
sort(d,9); //对双精度实型进行排序
cout << " \n output sort for int a,"
for(int i=0; i<6; i++) cout << a[i] << ",";
cout << " \n output sort for double d," ;
for(int j=0; j<9; j++) cout << d[j] << ",";
}
结果,output sort for int a,3,4,4,5,8,9,
output sort for double d,0.0,0.0,0.0,
0.0,0.0,1.8,2.0,4.3,9.5,
§ 6.6 模板例 3 有关内容总结
1,定义了一个模板函数 sort,将类型声明为函数的形式 参数；
2,在函数的具体调用中,形式参数的类型为,
int 和 double；
3,仅定义了一个模板,可应用于多种类型,使编程简便,代码重用；
4,类型放在 < > 中,而不是 [ ] 或 ( ) 中。
§ 6.6 模板例 4,函数模板的应用
#include <iostream.h>
template <class T> //声明模板
T max(T a,T b)
{
return (a>b? a:b);
}
void main( )
{ int a=9,b=99;
cout << "max(a,b)," << max(a,b) << endl;
float c=5.0,d=9.0;
cout << "max(c,d)," << max(c,d) <<endl;
}
§ 6.6 模板结果,
max(a,b),99
max(c,d),9.0
例 4 有关内容总结
1,定义了一个模板函数 max,将类型声明为函数的形式 参数。
具体形式为,
template <class T>
T max( T a,T b) {……}
2,在函数的具体调用中,形式参数的类型为 int 和 double。
3,仅定义了一个模板,可应用于多种类型,使编程简便,代码重用。
§ 6.6 模板
1,静态成员有,
静态数据 和 静态函数 。
2,静态成员可以通过 对象调用,
也可以通过 类属直接调用,如,
cout << a.getTotal( );
//对象调用
cout << st_n::getTotal( );
// 类属调用
3,不管创建多少对象,静态成员只有一个拷贝,所有对象 共享这个静态成员。
4,静态数据必须初始化,静态函数只能对静态数据进行操作。
5,定义了一个模板,可应用于多种类型,使编程简便,代码重用。
一,判断题 (说明理由 )
1,静态数据只可以由静态函数访问和修改。
2,静态数据为所有对象共享,
所以可认为静态数据是属于类的,而不是属于对象的。
3,静态数据和函数只能声明为公有类型。
二,应用静态数据和静态函数的作用是什么?
静态数据与普通数据有何区别?
三,改错并说明理由,
(1) include <iostream.h>;
class example ( )
{
private:
int date;
static int count
public;
void example( int y= 10) ( date=y;)
static int getcount { }
( cout <<,date=,<< date;
return count; )
}
(2) Template (class T)
T max(T a; T b; Tc );
//求 a,b,c 的最大值
{ int t;
if(a>b)
{
if(a>c) t=a
else t=c; }
else;
{
if(b>c) t=c;
else t=b;
}
};
