const成员函数 , 内联函数 , 友元 , static成员 , N种-构造拷贝构造的优化

const修饰成员函数

在成员函数后面加const，意味着this指针指向的对象只读。

const修饰了this指针所指向的对象还有一个好处，那就是const形参可以接受const或非const的实参，而非const的形参只能接受非const的实参。

---

inline（内联）

用inline修饰的成员函数是内联函数，当调用内联函数时，C++编译器会在调用出将内联函数展开，而不会重新开辟函数栈帧，这样做能减少消耗，提升效率。

• 内联能够减去栈帧的开销，但同时会让代码变得更长，所以有循环，有递归的函数不宜使用内联
• 内联不是强制执行的，编译器会自己判断是否要将函数展开，像有循环，递归的函数，就算加上inline设置为内联函数，在编译时也会被忽略。
• inline必须标注在函数定义的前面，标注在声明前面无效。
• 定义在类内的成员函数时默认的成员函数。

---

友元（friend）

C++中，类外是不能访问类内的成员的，而友元就可以解决这一问题。

• 友元函数不算做类的成员函数
• 在类外可以调用友元函数访问类内的一切成员变量和成员函数。、

甚至可以设置一个友元类，在别的类内就通用了。（即我是你的友元，那在我的类里就可以调用你的成员函数了）

class Date
{
friend void Display( const Date & d);
private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};
void Display (const Date& d)
{
cout<<"year:" <<d. _year<< endl ;
cout<<"month:" <<d. _month<< endl ;
cout<<"day:" <<d. _day<< endl ;
} v
oid Test ()
{
Date d1 ;
Display(d1 );
}

赋值运算符重载的友元函数：

class Date
{ 
public :
// 1:operator<<可以定义为成员函数吗？
// 2:返回值定义为void可以吗？ 为什么？
friend ostream & operator<< ( ostream& os , const Date& d );
friend istream & operator>> ( istream& is , Date& d);

private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
};

ostream & operator<<( ostream& os , const Date& d)
{
os<<"year:" <<d. _year<<endl ;
os<<"month:" <<d. _month<<endl ;
os<<"day:" <<d. _day<<endl <<endl;
return os ;
} 

//cin.operator<<(cin, d1)
istream & operator>> ( istream& is , Date& d)
{
cout<<" 请分别输入年月日： "<<endl ;
is>>d ._year;
is>>d ._month;
is>>d ._day;
return is ;
} 

void Test ()
{
Date d1 ;
cin>>d1 ;
cout<<d1 ;
}

友元类：

class Time
{
// Date是Time 的友元， 所以 Date可以访问Time的所有成员。
friend class Date;

private :
int _hour ;
int _minute ;
int _second ;
};

class Date
{
public :
void Display ()
{
cout<<"year:" <<_year<< endl;
cout<<"month:" <<_month<< endl;
cout<<"day:" <<_day<< endl;
// 定义为友元类后， 可以访问Time类对象的所有成员
cout<<"hour:" <<_t. _hour<<endl ;
cout<<"minute:" <<_t. _minute<<endl ;
cout<<"second:" <<_t. _second<<endl <<endl;
}

private :
int _year ; // 年
int _month ; // 月
int _day ; // 日
Time _t ;
};

void Test ()
{
Date d1 ;
d1.Display ();
}

友元一定程度上破坏了C++的封装性，所以不宜多用，慎用友元。

---

类内的static成员

• 类内static修饰的成员算作静态类成员，不再算进类的大小
• 类的静态成员是该类型的对象共享的,这一点与成员函数类似
• 静态函数参数中没有隐含的this指针，所以静态成员函数不能访问非静态的成员变量

N种构造拷贝构造的优化

class AA 
{}; 

AA f (AA a) 
{ 
return a ; 
} 

void Test1 () 
{ 
AA a1 ; 
a1 = f(a1); 
} 

构造 a1调用了一次构造函数，调用函数f传参给a调用一次拷贝构造函数，返回值不是引用，要调用一次拷贝构造函数，赋值给a1调用一次赋值运算符函数重载。

Test1中调用了1+1=2次AA的拷贝构造函数,1次AA的赋值运算符函数的重载。

class AA 
{}; 

AA f (AA a) 
{ 
return a ; 
} 

void Test2 () 
{ 
AA a1 ; 
AA a2 = f(a1); 
} 

创建a1调用一次构造函数，传参给a调用一次拷贝构造函数，返回值传值调用一次拷贝构造函数，但这次传值有立刻作为拷贝给a2的副本，所以省略构建a2的那次拷贝构造函数。
Test2中调用了次 1+1=2 AA的拷贝构造函数 , 0 次AA的赋值运算符函数的重载。

class AA 
{}; 

AA f (AA a) 
{ 
return a ; 
} 

void Test3 () 
{ 
AA a1 ; 
AA a2 = f(f(a1)); 
} 

构建a1调用一次构造函数，传参给a调用一次拷贝构造函数，函数返回值传值调用一次拷贝构造函数，这个返回值又立刻作为外层函数的参数，所以省去了创建形参的那次拷贝构造函数，外层函数返回值传值调用一次拷贝构造函数，因为这次传值立刻有作为创建a2的拷贝副本，所以省去构建a2的那次拷贝构造函数。
Test3中调用了 1+1+1=3 次AA的拷贝构造函数, 0 次AA的赋值运算符函数的重载。

由此可以知道，当拷贝构造完毕紧接着又要调用拷贝构造函数时，编译器会进行优化，省去一次拷贝构造函数，这样能提高效率。