C++ 数据共享与保护

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;

									 a1.UsingCount();   // 通过普通函数成员修改静态数据成员

									 cout << a1.s_count << endl; // 通过对象访问静态数据成员

									 A a2;

									 a2.UsingCount();

									 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();   

									}