访问修饰符、友元、this指针

访问修饰符

访问修饰符有：public、private、protected三种，描述如下：
public：公有成员，在类的外部是可访问的，可以不通过类函数来进行访问和修改
private：私有成员，在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员
protected：受保护的成员，受保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的
定义格式和使用方法如下：

#include <iostream>
using namespace std;

class hello_world
{
public:
    int public_value; /* 公有成员 */
private:
    int private_value; /* 私有成员 */
protected:
    int protected_value; /* 受保护的成员 */

public:
    void set_value(int value1, int value2); /* 类函数,用来操作私有成员和受保护的成员 */
    void show_value(); /* 打印所有的成员值 */
};

void hello_world::set_value(int value1, int value2)
{
    this->private_value = value1;
    this->protected_value = value2;
}

void hello_world::show_value()
{
    std::cout << "public_value: " << public_value << std::endl;
    std::cout << "private_value: " << private_value << std::endl;
    std::cout << "protected_value: " << protected_value << std::endl;
}

int main(int argc, char const *argv[])
{
    hello_world hw;

    hw.public_value = 1;
    // hw.private_value = 2; 错误，无法访问
    // hw.protected_value = 3; 错误，无法访问
    hw.set_value(2, 3);

    hw.show_value();

    return 0;
}

打印结果：
public_value: 1
private_value: 2
protected_value: 3

 

友元

友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员，可以在友元函数中实例化类，然后可以访问所有的类成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。有如下几种方式来实现友元。

全局函数友元

#include <iostream>
#include <string>
using namespace std;

class PersonalInfo {
    friend void visitPerInfo(PersonalInfo* pi); /* 全局函数做友元 */

   public:
    PersonalInfo() {
        m_name = "faker";
        m_wage = 99999;
    }

   public:
    string m_name; /* 名字是公共属性，大家都可以知道 */

   private:
    int m_wage; /* 工资是私有属性，一般人不给知道 */
};

/* 全局函数访问 */
void visitPerInfo(PersonalInfo* pi) {
    cout << "name: " << pi->m_name << endl; /* 输出: name: faker */
    cout << "wage: " << pi->m_wage << endl; /* 未做友元的情况下，无法访问，会报错。做友元输出 wage: 99999 */
}

int main(int argc, char const* argv[]) {
    PersonalInfo pi;
    visitPerInfo(&pi);
    return 0;
}

类做友元

#include <iostream>
#include <string>
using namespace std;

class PersonalInfo {
    friend class goodFriend; /* 类做友元，goodFriend可以访问PersonalInfo中的私有属性 */

   public:
    PersonalInfo() {
        m_name = "faker";
        m_wage = 99999;
    }

   public:
    string m_name; /* 名字是公共属性，大家都可以知道 */

   private:
    int m_wage; /* 工资是私有属性，一般人不给知道 */
};

class goodFriend {
   public:
    void visitPerInfo(PersonalInfo* pi);
};

void goodFriend::visitPerInfo(PersonalInfo* pi) {
    cout << "name: " << pi->m_name << endl; /* 输出: name: faker */
    cout << "wage: " << pi->m_wage << endl; /* 未做友元的情况下，无法访问，会报错。做友元输出 wage: 99999 */
}

int main(int argc, char const* argv[]) {
    PersonalInfo pi;
    goodFriend gf;
    gf.visitPerInfo(&pi);
    return 0;
}

成员函数做友元

#include <iostream>
#include <string>
using namespace std;

class PersonalInfo;
class goodFriend {
   public:
    void visitPerInfo(PersonalInfo* pi);
    void visitPerInfoDrank(PersonalInfo* pi); /* 喝过酒之后就可以问工资的事情了 */
};

class PersonalInfo {
    friend void goodFriend::visitPerInfoDrank(PersonalInfo* pi);

   public:
    PersonalInfo() {
        m_name = "faker";
        m_wage = 99999;
    }

   public:
    string m_name; /* 名字是公共属性，大家都可以知道 */

   private:
    int m_wage; /* 工资是私有属性，一般人不给知道 */
};

void goodFriend::visitPerInfo(PersonalInfo* pi) {
    cout << "name: " << pi->m_name << endl; /* 输出: name: faker */
    // cout << "wage: " << pi->m_wage << endl; /* 未做友元的情况下，无法访问，会报错*/
}

void goodFriend::visitPerInfoDrank(PersonalInfo* pi) {
    cout << "name: " << pi->m_name << endl; /* 输出: name: faker */
    cout << "wage: " << pi->m_wage << endl; /* 友元输出 wage: 99999 */
}

int main(int argc, char const* argv[]) {
    PersonalInfo pi;
    goodFriend gf;
    // gf.visitPerInfo(&pi);
    gf.visitPerInfoDrank(&pi);
    return 0;
}

 

this指针

this指针指向被调用的成员函数所属的对象，用法用途如下：

#include <iostream>
#include <string>
using namespace std;

/* 1. 如果形参和成员变量同名的时候，可以用this指针来区分
   2. 在类的非静态成员函数中返回对象本身
      2-1: 成员函数的返回值不能是值，否则就是通过拷贝构造函数构建新的对象
      2-2: 返回值类型是引用 return *this;
      2-3: 返回值类型是指针 return this;
 */

class test {
   public:
    test(int value) {
        this->value1 = value;
        this->value2 = value;
        this->value3 = value;
    }

    /* 返回值类型是值 */
    test add1(int value) {
        this->value1 += value;
        return *this;
    }

    /* 返回值类型是引用 */
    test& add2(int value) {
        this->value2 += value;
        return *this;
    }

    /* 返回值类型是指针 */
    test* add3(int value) {
        this->value3 += value;
        return this;
    }

    int value1;
    int value2;
    int value3;
};

int main(int argc, char const* argv[]) {
    test t1(10); /* value1/value2/value3的值都初始化为10 */

    /* 返回值类型是值 */
    t1.add1(10).add1(10);
    cout << "value1: " << t1.value1 << endl; /* value1 = 10 + 10 = 20，因为构建了新的对象 */

    /* 返回值类型是引用 */
    t1.add2(20).add2(20);
    cout << "value2: " << t1.value2 << endl; /* value2 = 10 + 20 + 20 = 50 */

    /* 返回值类型是指针 */
    t1.add3(30)->add3(30);
    cout << "value3: " << t1.value3 << endl; /* value3 = 10 + 30 + 30 = 70 */

    return 0;
}