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.全局变量的生存期最长。