1、const成员函数：
在成员函数后面加const，const修饰this指针所指向的对象，也就是保证调用这个const成员函数的对象在函数内不会被改变
思考以下几种场景
1. const对象可以调用非const成员函数和const成员函数吗？ x
2. 非const对象可以调用非const成员函数和const成员函数吗？ 对
3、const成员函数内可以调用其它的const成员函数非const成员函数吗？
前对 后x
4、非const成员函数内可以调用其它的const成员函数非const成员函数吗？对
权限可以被缩小，但是不可以被放大。const权限小，非const权限大
int a = 10;
int *p1 = &a;//值可以被改变
const int *p2 = &a;//把a的地址给给p2，通过改变p指向的内容改变值
int const*p3 = &a;//同上
p1 = p2; //不可以
p2 = p1;//可以 权限问题
///////////////////////////////////
//p1 、p2、p3都可以被改,p4,p5不能被改
int *const p4 = &a;//p4不能被改
const int* const p5 = &a;//都不能被改2、inline（内联）
以inline修饰的函数叫做内联函数，编译时C++编译器会调用内联函数的地方展开，没有 函数压栈的开销，内联函数提升程序运行的效率。
1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉 内联。
3. inline必须函数定义放在一起，才能成为内联函数，仅将inline放在声明前是不起不作用的。
4. 定义在类内的成员函数默认定义为内联函数。
问题–C++建议以const/枚举/内联去替代宏，为什么？
宏的优点：
1. 增强代码的复用性。
2. 提高性能。
宏也有很多缺点:
1. 不方便调试宏。（因为预编译阶段进行了替换）
2. 导致代码可读性差，可维护性差，容易误用。
3. 没有类型安全的检查。
3、友元函数： 在C++中友元函数允许在类外访问该类中的任何成员，就象成员函数一样，友元函数用关键字friend说明。
1. 友元函数不是类的成员函数。
2. 友元函数可以通过对象访问所有成员，私有和保护成员也一样
友元是突破访问限定符的一种函数
#include<iostream>
#include<stdlib.h>
using namespace std;
class Date
{
friend bool operator<(Date& aa1, Date& aa2);//去掉则不能访问类内的成员函数，b要访问a必须在a中声明b是a的朋友
public:
Date(int a1, int a2)
: _a1(a1)
, _a2(a2)
{}
private:
int _a1;
int _a2;
};
bool operator<(Date& aa1, Date& aa2)
{
return aa1._a1 < aa2._a2;
}
int main()
{
Date(1, 2);
Date(2, 3);
system("pause");
return 0;
}
友元类也是相同的声明方法B要访问A，就必须在A中声名B；
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 ();
} 4、static成员函数：
类的静态成员
1. 类里面static修饰的成员，成为静态类成员。
2. 类的静态成员是该类型的所有对象对象所共享。
注意静态成员函数没有隐含this指针参数，所以可以使用类型::作用域访问符直接调用静态成员函数。
代码如下：
#include<iostream>
#include<stdlib.h>
using namespace std;
class Date
{
public:
Date()
{
cout << "Date()" << endl;
count++;
}
void Display()
{
cout << "年：" << _year << endl;
cout << "月" << _month << endl;
cout << "日" << _day << endl;
}
static void printcount()
{
cout << "Date count:" << count<<endl;
}
private:
int _year;
int _month;
int _day;
private:
static int count;//静态成员变量，用于统计创建个数
};
int Date::count = 0;
void test()
{
Date d1, d2;
//访问静态成员
Date::printcount();
}
int main()
{
test();
system("pause");
return 0;
}
1）、静态成员函数不可以访问非静态的成员
2）、 非静态的成员函数可以访问静态成员
5、
Test1中调用了 _ 次AA的拷贝构造函数 _ 次AA的赋值运算符函数的重载。 Test2中调用了
次AA的拷贝构造函数,_ 次AA的赋值运算符函数的重载。 Test3中调用了 次AA的拷贝构造函数, 次AA的赋值运算符函数的重载。 class AA {}; AA f (AA a) { return a ; } void Test1 () { AA a1 ; a1 = f(a1); } void Test2 () { AA a1
; AA a2 = f(a1); }void Test3 () { AA a1 ; AA a2 = f(f(a1)); }
答案：
1） 2 1
2） 2 0
3） 3 0
