C++数据共享与保护

C++数据共享与保护
⽬录
1.作⽤域
2.可见性
3.对象的⽣存期
4.类数据的共享
5.类共享数据的保护
1.作⽤域
作⽤域：⼀个标识符在程序正⽂中有效的区域。

函数原型（函数声明）作⽤域
例如函数原型void Print(int a);，变量a的作⽤域为括号左右之间。

局部作⽤域
例如如下函数定义，变量a的作⽤域为⼤括号之间。

void Print(){
int a = 0;
std::cout << a << std::endl;
}
类作⽤域
X类的成员m具有类作⽤域（设其⼀个实例对象为x），以下是在不同环境下对m的访问⽅法：
1.类内访问：
直接通过标识符m访问。

2.类外访问：
普通成员通过x.m
类成员通过X::m
对象指针通过ptr->m
命名空间作⽤域
在XX命名空间中声明的对象m，其作⽤域在命名空间之内。

命名空间外想访问该对象要以XX::m的⽅式进⾏。

namespace XX{ // 命名空间中声明
void Print();
}
XX::Print(){ // 命名空间外定义
//Print函数的定义
}
XX::Print() // 命名空间外使⽤
using语句可以简化对命名空间内对象的访问：
1.使⽤using XX::Print;语句后，其后只需要通过Print就可以调⽤该函数对象。

2.使⽤using namespace XX;语句后，其后只需要通过函数名就可以调⽤XX命名空间下的对象。

2.可见性
可见性：程序运⾏到某⼀点，能够引⽤到的标识符，称该标识符为可见的。

可见性隐藏规则：在多个具有包含关系的作⽤域声明的同名标识符，外层标识符在内层不可见。

全局变量：可以被本程序所有对象或函数引⽤。

在默认（全局）命名空间内声明的对象为全局变量，默认本编译单元内可以引⽤。

通过关键词extern声明引⽤的全局变量为其他编译单元中已经定义的全局变量。

通过关键词static声明的全局变量只能在本编译单元中使⽤，不能在其他编译单元⽤extern声明引⽤。

局部变量：只能在内部作⽤域内被引⽤
3.对象的⽣存期
⽣存期：从对象内存空间被分配到被释放的期间。

静态⽣存期：对象的⽣存期与程序的运⾏期相同。

1.在命名空间内声明的对象都具有静态⽣存期。

2.在局部作⽤域中⽤static关键词声明的对象具有静态⽣存期，在对应局部作⽤域中具有可见性。

动态⽣存期：对象的⽣存期为声明点到声明点所在作⽤域的结束点之间。

4.类数据的共享
⾯向结构编程：
程序模块：函数
数据共享⽅式：参数传递、全局变量
⾯向对象编程：
程序模块：类
数据共享⽅式：类的静态成员（类内数据共享）、类的友元（类外数据共享）
类的静态数据成员（类属性）：类变量由该类所有实例对象共享，⽤static修饰。

设X类的静态成员为m，类的⼀个实例对象为x：
类的静态变量必须类内声明，类外定义。

在类的第⼀个实例对象初始化前初始化，在内存上只有⼀份副本。

类外定义时通过X::m进⾏引⽤，定义后可以通过实例对象进⾏引⽤，如x.m。

类的静态函数成员（类⽅法）：主要是处理类属性或者处理该类下多个实例对象的⽅法，⽤static修饰。

设X类的静态函数为func，类的⼀个实例对象为x：
可以直接访问该类的静态数据和函数成员，不能访问⾮静态成员。

可以在类的第⼀个实例对象初始化前通过X::func进⾏调⽤。

在实例对象初始化可以通过x.func调⽤，但是为了代码的可读性，不推荐这样使⽤。

// 静态成员案例
#include<iostream>
using namespace std;
class A {
public:
static int s_count; // 私有静态数据成员声明
static void set_count(int i) { // 静态⽅法定义
s_count = i;
}
void UsingCount(){
s_count++;
}
};
int A::s_count = 0; // 私有静态数据成员类外定义（注意要在前⾯加上数据的类型说明符）
int main() {
A::s_count; // 通过类名调⽤
A::set_count(11); // 对象初始化前通过静态函数成员访问
A a1;
ingCount(); // 通过普通函数成员修改静态数据成员
cout << a1.s_count << endl; // 通过对象访问静态数据成员
A a2;
ingCount();
cout << a2.s_count << endl; // 如果输出结果是13，则证明静态数据成员是共享的
}
输出结果：
12
13
友元关系：⼀个类主动声明其他类或函数是他的友元，进⽽给他们提供本类的访问特许，⽤friend修饰。

友元函数：被⼀个类声明为友元的函数，在他的函数体内可以通过对象名访问类的私有和保护成员。

友元类：被⼀个类A声明为友元的另⼀个类B，类B内所有成员函数都是类A的友元函数。

//友元数据共享案例
#include<iostream>
using namespace std;
class A {
private:
int m_nums = 10; // 私有数据成员
friend class B; // 友元类声明
};
class B { // 友元类
public:
void Print(A& a) { // 友元函数
cout << a.m_nums << endl; // 通过对象名访问私有成员
}
};
int main() {
A a;
B b;
b.Print(a); // 访问私有数据成员
}
结果输出：
10
1
5.类共享数据的保护
常对象：常对象的数据成员值在对象整个⽣存期间不能被更改。

设A类的常对象为a，常函数成员为func,常数据成员为m：
1. 声明语法：const A a;
2. 常对象必须进⾏初始化，⽽且不能被更新（不能赋值或者调⽤普通成员函数）。

3. 常对象只能调⽤常函数成员。

常函数成员：能被常对象调⽤访问常数据成员。

1. 常函数成员声明语法：返回值类型 func(参数表)const;
2. 常函数成员定义部分时要带上const。

3. 常函数调⽤期间，因为⽬标对象视为常对象，所以只能调⽤常函数。

4. const可以⽤于函数重载，通过⾮const对象调⽤重载函数优先调⽤⾮const的重载函数。

常数据成员：值在初始化后不能被更新。

1. 常数据成员声明语法：const 数据类型m;。

2. 常数据成员不能被赋值，构造函数只能通过初始化列表进⾏初始化。

3. 静态常数据成员在类外进⾏定义。

//常成员案例
#include<iostream>
using namespace std;
class A {
public:
void Print()const { // 不修改对象数据成员值的函数应该设为常函数
cout << a << ',' << b << ',' << s << endl;
}
A(int i) :b(i) {}; // 初始化列表初始化
private:
const int a = 1; // 已初始化的常数据成员
const int b; // 未初始化的常数据成员
const static int s; // 常静态数据成员
};
const int A::s = 3; // 类外定义
int main() {
A a(2);
a.Print();
}
结果输出：
1,2,3
1
常引⽤：常引⽤所引⽤的对象被视为常对象。

1. 常引⽤声明语法：const 数据类型 &引⽤名。

2.⾮const的引⽤只能绑定到普通对象。

3. 对于⽆需修改值的参数（复制构造函数），尽量使⽤const进⾏应⽤
到此这篇关于C++ 数据共享与保护的⽂章就介绍到这了,更多相关C++ 数据共享与保护内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。