C + + shared data protection mechanism

Time:2022-5-13

The following essay explains the C + + shared data protection mechanism.

Protection of shared data

Data that needs to be shared and prevented from changing should be declared as constant type (decorated with const).

Member functions that do not change the state of the object should be declared constant.

(1) Constant type

① Constant object: must be initialized and cannot be updated.

Const class name object name

② Regular member

Class members decorated with const: constant data members and constant function members

③ Constant reference: the referenced object cannot be updated.

Const # type specifier & reference name

④ Constant group: array elements cannot be updated (see Chapter 6 for details).

Type specifier const array name [size]

⑤ Constant pointer: pointer to constant (see Chapter 6 for details).

(2) Constant object

Object decorated with const

1 case:
 2 
 3 class A
 4 
 5 {
 6 
 7   public:
 8 
 9     A(int i,int j) {x=i; y=j;}
10 
11                      ...
12 
13   private:
14 
15     int x,y;
16 
17 };
18 
19 A const a(3,4); // A is a constant object and cannot be updated

(3) Regular member

Object members decorated with const

① Constant member function

Functions described with const keyword.

Constant member functions do not update the data members of an object.

Constant member function description format:

Type specifier: function name (parameter table) const;

Here, const is an integral part of the function type, so the const keyword should also be carried in the implementation part.

Const keyword can be used to distinguish overloaded functions

Through a constant object, only its constant member functions can be called.

② Constant data member

The data member described using const.

1 // examples of constant member functions
 2 
 3 #include
 4 
 5 using namespace std;
 6 
 7 class R {
 8 
 9 public:
10 
11   R(int r1, int r2) : r1(r1), r2(r2) { }
12 
13   void print();
14 
15   void print() const;
16 
17 private:
18 
19   int r1, r2;
20 
21 };
22 
23  
24 
25 void R::print() {
26 
27   cout << r1 << ":" << r2 << endl;
28 
29 }
30 
31 void R::print() const {
32 
33   cout << r1 << ";" << r2 << endl;
34 
35 }
36 
37 int main() {
38 
39   R a(5,4);
40 
41   a.print(); // Call void print()
42 
43   const R b(20,52); 
44 
45   b.print(); // Call void print() const
46 
47        return 0;
48 
49 }
1 // examples of constant data members
 2 
 3 #include 
 4 
 5 using namespace std;
 6 
 7 class A {
 8 
 9 public:
10 
11        A(int i);
12 
13        void print();
14 
15 private:
16 
17        const int a;
18 
19        static const int b;  // Static constant data member
20 
21 };
22 
23  
24 
25 const int A::b=10;
26 
27 A::A(int i) : a(i) { }
28 
29 void A::print() {
30 
31   cout << a << ":" << b <

(4) Often cited

If you use const when declaring a reference, the declared reference is a constant reference.

Objects referenced by frequent references cannot be updated.

If you use constant references as formal parameters, you won’t accidentally change the arguments. The frequently cited declaration forms are as follows:

Const , type specifier & reference name;

1 // often referenced as formal parameters
 2 
 3 #include 
 4 
 5 #include 
 6 
 7 using namespace std;
 8 
 9 class point {// point class definition
10 
11 public: / external interface
12 
13        Point(int x = 0, int y = 0)
14 
15     : x(x), y(y) { }
16 
17        int getX() { return x; }
18 
19        int getY() { return y; }
20 
21        friend float dist(const Point &p1,const Point &p2);
22 
23 private: / private data member
24 
25        int x, y;
26 
27 };
28 
29  
30 
31 float dist(const Point &p1, const Point &p2) {
32 
33        double x = p1.x - p2.x; 
34 
35        double y = p1.y - p2.y;
36 
37        return static_cast(sqrt(x*x+y*y));
38 
39 }
40 
41  
42 
43 int main() {// main function
44 
45        const Point myp1(1, 1), myp2(4, 5);    
46 
47        cout << "The distance is: ";
48 
49        cout << dist(myp1, myp2) << endl;
50 
51        return 0;
52 
53 }

 

Recommended Today

HTTP network protocol package

Network protocol package: 1. All information transmitted in the network exists in binary 2. The first thing the receiver [browser / server] should do after receiving the information That is to compile [binary data] [text, picture, video, command] 3. It is often difficult for the receiver to obtain a large amount of binary data For […]