关于c++的protected关键字

分类

c++基础知识

引言

做了很业务，c++基础知识却忘了很多，今天看了一个例子，唤醒了我关于c++三大特性之一----封装，尘封的记忆。。。

例子

1）错误的demo

错误发生在main函数中…

#include   
#include  // 引入智能指针的头文件  
  
using namespace std;  
  
// 操作基类  
class Operate {  
public:  
    Operate() {}  
    virtual ~Operate() {}  
      
    virtual int GetResult() = 0; // 纯虚函数，强制派生类实现  
  
protected:  
    int NumsA, NumsB;  
};  
  
// 加法操作类  
class AddOperate : public Operate {  
public:  
    int GetResult() override {  
        return NumsA + NumsB;  
    }  
};  
  
// 减法操作类  
class SubOperate : public Operate {  
public:  
    int GetResult() override {  
        return NumsA - NumsB;  
    }  
};  
  
// 乘法操作类  
class MulOperate : public Operate {  
public:  
    int GetResult() override {  
        return NumsA * NumsB;  
    }  
};  
  
// 除法操作类  
class DivOperate : public Operate {  
public:  
    int GetResult() override {  
        if (NumsB == 0) {  
            throw runtime_error("Division by zero is not allowed.");  
        }  
        return NumsA / NumsB;  
    }  
};  
  
// 操作工厂类  
class OperateFactory {  
public:  
    OperateFactory() {}  
      
    std::unique_ptr<Operate> CreateOperate(char op) {  
        switch (op) {  
            case '+': return std::make_unique<AddOperate>();  
            case '-': return std::make_unique<SubOperate>();  
            case '*': return std::make_unique<MulOperate>();  
            case '/': return std::make_unique<DivOperate>();  
            default:  
                throw runtime_error("No such operation!");  
        }  
    }  
};  
  
int main() {  
    try {  
        OperateFactory factory;  
        char op = '+';  
        int numA = 100, numB = 700;  
          
        std::unique_ptr<Operate> operate = factory.CreateOperate(op);  
        operate->NumsA = numA;  
        operate->NumsB = numB;  
          
        cout << operate->GetResult() << endl;  
    } catch (const exception& e) {  
        cout << "Error: " << e.what() << endl;  
    }  
      
    return 0;  
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

• 报错:
  
• 报错的原因:
  protected修饰的成员变量,只能是类内的成员函数可以访问,类外直接访问不了

进一步解释:NumsA和NumsB 是 protected修饰的成员变量,
只能是在Operate类内使用(他的派生类内也是可以使用的),
所以你需要再Operate 类中使用set函数将其进行封装,
这样你在类外就可以使用了(main函数就是Operate 类的类外,别的类中成员函数也是Operate的类外)
所以说,set函数就是封装.

当你下次再和面试,在和面试官进行社交的时候,讨论C++三大特性之一—封装的时候,
你就可以这么大胆的说:
c++封装就是 将一组有一定关系的变量和函数有机结合在一起.
然后假如你用protected关键字规定了一组成员变量,那么这组成员变量只能在类内的成员变量中访问,
而类外,比如main函数,或者别的类中的成员函数,都是不能直接访问的,我们需要在该类中,编写一组set函数,对protected成员变量进行封装,这样类外通过访问set函数,而不是直接访问成员变量,也是封装中比较明显的一个特征.

非常好!我要是面试官,我必定当场录取你!

2）改正的demo

从上面得知,protected修饰的成员变量是不能直接在类外访问的,只能在类内访问.
既然只能在类内访问,那我们就只在类内种访问不就ok了?
我们直接给他安排一组set函数,
然后让类外通过set函数访问就可以了!!!

#include   
#include  // 引入智能指针的头文件  

using namespace std;

// 操作基类  
class Operate {
public:
    Operate() {}
    virtual ~Operate() {}

    virtual int GetResult() = 0; // 纯虚函数，强制派生类实现  
    void  SetNumsA(int A)
    {
        NumsA = A;
    }
    void SetNumsB(int B)
    {
        NumsB = B;
    }
protected:
    int NumsA, NumsB;
};

// 加法操作类  
class AddOperate : public Operate {
public:
    int GetResult() override {
        return NumsA + NumsB;
    }
};

// 减法操作类  
class SubOperate : public Operate {
public:
    int GetResult() override {
        return NumsA - NumsB;
    }
};

// 乘法操作类  
class MulOperate : public Operate {
public:
    int GetResult() override {
        return NumsA * NumsB;
    }
};

// 除法操作类  
class DivOperate : public Operate {
public:
    int GetResult() override {
        if (NumsB == 0) {
            throw runtime_error("Division by zero is not allowed.");
        }
        return NumsA / NumsB;
    }
};

// 操作工厂类  
class OperateFactory {
public:
    OperateFactory() {}

    std::unique_ptr<Operate> CreateOperate(char op) {
        switch (op) {
        case '+': return std::make_unique<AddOperate>();
        case '-': return std::make_unique<SubOperate>();
        case '*': return std::make_unique<MulOperate>();
        case '/': return std::make_unique<DivOperate>();
        default:
            throw runtime_error("No such operation!");
        }
    }
};

int main() {
    try {
        OperateFactory factory;
        char op = 'z';
        int numA = 100, numB = 700;

        std::unique_ptr<Operate> operate = factory.CreateOperate(op);
        operate->SetNumsA(numA);
        operate->SetNumsB(numB);

        cout << operate->GetResult() << endl;
    }
    catch (const exception& e) {
        cout << "Error: " << e.what() << endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

protected在c++中的含义与作用

不多写了,多写也记不住,前言万语总结成一句话:

protected:当一个成员被定义为protected类型时，仅能在类内、友元和派类访问。

最后祝每个大佬都可以月薪过万! 加油!