类的非默认成员函数（普通函数、内联函数、友元函数）

一、类的普通成员函数

普通成员函数本质上是一个包含指向具体对象this指针的普通函数，即c++类的普通成员函数都隐式包含一个指向当前对象的this指针。

class Person
{
public:
    Person()
    {
        _name = "LiMing";
        _age = 20;
    }
    void Show()
    {
        cout << this->_name << endl;//this指针是隐含的，不写也可以调用类成员
        cout << this->_age << endl;
    }
private:
    char* _name;
    int _age;
};

二、内联函数

(1)内联函数是指用inline关键字修饰的函数。在类内定义的函数被默认成内联函数。编译时，会类似宏替换，嵌入调用处。
(2)用处：是为了消除函数调用时的时间开销，通常用于调用频繁，占用内存小的函数。
(3)注意：
递归函数不能定义为内联函数
内联函数一般适合于不存在while和switch等复杂的结构且只有1~5条语句的小函数上，否则编译系统将该函数视为普通函数。
内联函数只能先定义后使用，否则编译系统也会把它认为是普通函数。
对内联函数不能进行异常的接口声明。

class Class
{
public:
    Class()
    {
        a = 1;
        b = 2;
    }
    inline void Display()
    {
        cout << a << endl;
        cout << b << endl;
    }
    int a;
    int b;
};
void main()
{
    Class c1;
    c1.Display();
}

三、友元

(1)友元函数

友元函数是能够访问类中的私有成员的非成员函数。友元函数从语法上看，它与普通函数一样，即在定义上和调用上与普通函数一样，友元函数用关键字friend说明。

class Class
{
public:
    friend void Display(const Class& c);//友元函数声明

    Class()
    {
        a = 1;
        b = 2;
    }
private:
    int a;
    int b;
};

//对象内成员a,b是私有的，但该函数在类内声明为友元函数，此时可以访问私有成员
void Display(const Class& c)
{
    cout << c.a << endl;
    cout << c.b << endl;
}

void main()
{
    Class c1;
    Display(c1);
}

(2)友元类

当一个类作为另一个类的友元时，这就意味着这个类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。

class Person
{
    friend class Student;
public:
    Person()
    {
        _name = "LiMing";
        _age = 20;
    }
private:
    char* _name;
    int _age;
};

class Student
{
public:
    Student()
    {
        _sno = 100;
    }
    void Show(const Person& p)
    {
        cout << p._name << endl;
        cout << p._age << endl;
        cout << _sno<< endl;
    }

private:
    int _sno;
    Person _p;
};

int main()
{
    Person p;
    Student s;
    s.Show(p);
}

友元一定程度上破坏了C++的封装，友元不宜多用。
友元关系不具对称性。即 A 是 B 的友元，但 B 不一定是 A 的友元。 友元关系不具传递性。即 B 是 A 的友元，C 是 B 的友元，但是 C 不一定是 A 的友元。

四、const修饰成员函数

class Class
{
public:    
    void Display() 
    {
        cout << "Display ()" << endl;       
    }
    void Display() const //函数内this指向的对象不可改变->void Display(const Class *this)
    { 
        cout << "Display () const" << endl;  
    }
};
void main() 
{
    Class c1;    
    c1.Display();
    const Class c2;     
    c2.Display();//调用const成员函数
}

注意

权限只能缩小，不能放大。

1.在类中被const声明的成员函数只能访问const成员函数,而非const函数可以访问任意的成员函数,包括const成员函数
2.在类中被const声明的成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.

五、static成员

class Count
{
public:
    static int times;
};

int Count::times = 10;

int main()
{
    Count cou;
    cout << cou.times << endl;
}

补充：

关于类的静态成员:
1.静态成员函数内部不能使用非静态成员函数和非静态成员变量。
2.非静态成员函数内可以使用静态成员变量，调用静态成员函数。
3.静态成员函数放在代码段；
4.静态成员函数没有隐含this指针参数，可以使用类型::作用域访问符直接调用静态成员函数。
5.静态成员变量必须要在类外进行初始化,因为静态成员变量在类中仅仅是声明，没有定义。初始化方法 [类型 类名::变量名=初始值]。
6.类的静态成员被该类的所有对象所共享。