C++学习笔记四

15、友元函数

1.为什么要引入友元函数？

在对某些成员函数多次调用时，由于参数的类型检查和安全性检查都需要时间开销，

从而影响了程序的运行效率，引入友元后可以提高程序的运行效率；

2.使用格式：

a.是一种定义在类外部的【类】或【普通函数】，但需要在类体内进行说明(前面加

friend关键字)

b.不是成员函数，但可以访问类中的私有成员。(重要！！！！)

3.友元的分类：

a.友元函数

b.友元类

#include<iostream.h>

class Time{

public:

Time(int new_hours,int new_minutes) {hours = new_hours;minutes = new_minutes;}

friend void Time12(Time time); //友元函数申明在类内部

friend void Time24(Time time);

private:

int hours,minutes;

};

void Time12(Time time) //友元函数定义在类外部

{ // ->友元函数可以使用类的私有成员

if(time.hours > 12)

{

time.hours-=12;

cout<<time.hours<<":"<<time.minutes<<"PM:"<<endl;

}

else

{

cout<<time.hours<<":"<<time.minutes<<"AM:"<<endl;

}

}

void Time24(Time time)

{

cout<<time.hours<<":"<<time.minutes<<endl;

}

void main()

{

Time time1(24,57),time2(12,34);

Time12(time1);

Time24(time1);

Time12(time2);

Time24(time2);

}

总结：

a.友元函数申明在类内部

b.友元函数定义在类外部

->友元函数可以使用类的私有成员

16、友元类 （36_友元二.cpp）

#include<iostream.h>

class X

{

friend class Y; //在类X中申明友元类Y

public:

void Set(int i) { x = i;}

void Display() { cout<<"x="<<x<<","<<"y="<<y<<endl; }

private:

int x;

static int y;

};

class Y{ //在类X外部定义友元类Y

public:

Y(int i,int j);

void Display();

private:

X a; //可以在友元类Y内部定义之前的类X的对象，用来访问X类的内部变量

};

int X::y=1;

Y::Y(int i,int j)

{

a.x = i;

X::y = j;

}

void Y::Display()

{

cout<<"x="<<a.x<<",";

cout<<"y="<<X::y<<endl;

}

void main()

{

X b;

b.Set(5);

b.Display(); //5 1

Y c(6,9);

c.Display(); //6 9

b.Display(); //5 1

}

总结：

a.在类X中申明友元类Y

b.在类X外部定义友元类Y

c.可以在友元类Y内部定义之前的类X的对象，用来访问X类的内部变量

17、对象的生存期

1.对象的生存期：指对象从被创建开始到释放为止的时间；

2.按生存期对对象的分类

a. 局部对象：被定义在一个函数体或程序块内，作用域小，生存期短；

b. 静态对象：被定义在一个文件中，它的作用域从定义时起到文件结

束止；它的作用域较大，生存期较长；

c. 全局对象：被定义在某个文件中，它的作用域在包含该文件的整个

程序中；它的作用域最大，生存期最长；

#include<iostream.h>

#include<string.h>

class A

{

public:

A(char *st);

~A();

private:

char string[];

}

A::A(char *st)

{

strcpy(string,st);

cout<<"Constructor called for"<<string<<endl;

}

A::~A()

{

cout<<"Destructor called for"<<string<<endl;

}

void fun()

{

A FunObject("FunObjectct");

static A StaticObject("StaticObject");

cout<<"In fun()"<<endl;

}

A GlobalObject("GlobalObject"); //Constructor called for GlobalObject

void main()

{

A MainObject("MainObject"); // Constructor called for MainObject

cout<<"In main(),before called fun()"<<endl; // In main(),before called fun()

fun();
// Constructor called for FunObjectct

// Constructor called for StaticObject

// In fun()

// Destructor called for FunObjectct

cout<<"In main(),after called fun()"<<endl; // In main(),after called fun()

// Destructor called for MainObject

}

// Destructor called for StaticObject

// Destructor called for GlobalObject

总结：

a.全局变量在main函数外，所以一般最先构造。

b.全局变量在main函数退出才释放，才调用析构函数。

c.全局变量的生存期最长。