C++的数据共享与保护的介绍_F11 - 专业站长和开发者的学习网站

1.作用域

作用域是一个标识符在程序正文中有效的区域

作用域关系从大到小为：

命名空间作用域 > 类作用域 > 局部作用域

标识符的有效范围就是标识符的可见性，可见性的一般规则为：

标识符声明在前，使用在后
在同一作用域中，不能声明同名的标识符
在没有包含关系的不同的作用域中声明的同名标识符，互不影响
如果在多个作用域中定义了同名标识符，则外层标识符在内层不可见

2.对象生存期

如果对象生存期与程序的运行期相同，则它具有静态生存期

局部生存期对象诞生于声明点，结束于声明所在块执行完毕之时

命名空间作用域中声明的对象都具有静态生存期
定义时未指定初值的基本类型静态生存期变量，会被赋予0值初始化
如果要在函数内部的局部作用域中声明具有静态生存期的对象，则要使用关键字static

void f()

{

static int m=0; //m仅在f中能访问

m++;

cout<<m<<endl;

}

静态数据成员

如果某个属性为整个类所共有，可以采用static关键字来声明为静态成员。

静态成员在每个类中只有一个副本，由该类的所有对象共同维护和使用
在类中不能对static静态数据成员进行初始化，要初始化必须在类外进行定义

class A{

public:

static int m;

};

int A::m=20; //在类外进行初始化

int main(){

A a,b;

a.m=10; //可以赋值

cout<<a.m<<endl;

cout<<b.m<<endl; //两者的值相同

}

静态成员函数

静态成员函数可以通过类名或对象名来进行调用，非静态成员函数只能通过对象名来调用
静态成员函数可以直接访问该类的静态数据和函数成员，而访问非静态成员，必须通过对象名

class A{

public:

static void f(A a);

static void g(){

cout<<"hello"<<endl;

}

void fun(){

cout<<"world"<<endl;

}

private:

int x;

static int y;

};

int A::y=10;

void A::f(A a){

cout<<a.x<<endl; //必须通过对象名访问

cout<<y<<endl; //直接访问该类的静态数据成员

g(); //直接访问该类的静态成员函数

}

int main(){

A a;

A::f(a); //直接通过类名调用

return 0;

}

3.类的友元

友元关系是一种数据共享机制，通过友元关系，一个普通函数或者类中的成员函数可以访问封装于另外一个类中的数据

为了确保数据的完整性和封闭性，建议尽量少地使用友元

友元函数

友元函数是类中用关键字friend修饰的非成员函数，在它的函数体中可以通过对象名访问类的private和protected成员

class A{

public:

friend int main();

private:

int x;

};

int main(){

A a;

a.x=5; //访问 private对象

}

友元类

若B类为A类的友元类，则B类的所有成员函数都是A类的友元函数，都可以访问A类的private和protected成员

class A{

public:

friend class B;

private:

int x,y;

void f(){

cout<<x<<endl;

}

};

class B{

public:

void print(){

a.x=5;

a.y=10;

cout<<a.y<<endl;//可以访问A类对象的私有成员

a.f(); //可以访问A类对象的私有函数

}

private:

A a;

};

注意（！！！）

1.友元关系是单向的。

B类是A类的友元，B能访问A的私有数据，但A不能访问B的私有数据

2.友元关系不能传递。B是A的友元，C是B的友元，C和A之间如果没有声明就不存在友元关系

3.友元关系不能被继承。

4.共享数据的保护

常对象

数据成员值在对象的整个生存期间不能被修改的对象叫做常对象，一般用const进行修饰

常对象必须进行初始化，而且不能被更新

声明常对象的语法形式为：

const 类型说明符对象名；

class A{

public:

A(int i,int j):x(i),y(j){···}

private:

int x,y;

};

int main(){

const A a(3,4); //a为常对象，不能被更新

}

常成员函数

使用const关键字修饰的函数为常成员函数

语法：

类型说明符函数名（参数表）const；

如果将一个对象说明为常对象，通过该常对象只能调用它的常成员函数，不能调用其他函数（常对象唯一的对外接口方式）

class A{

public:

A(int i,int j):x(i),y(j){···}

void print(){

cout<<x<<" "<<y<<endl;

}

void print() const{

//常成员函数

cout<<x<<" const "<<y<<endl;

}

private:

int x,y;

};

int main(){

A a(1,2);

a.print(); //调用 void print()

const A b(3,4);

b.print(); //调用 void print() const

}

使用const说明的数据成员为常数据成员

类中说明了常数据成员，任何函数不能对它赋值，构造函数对它进行初始化只能通过初始化列表

class A{

public:

//常数据成员只能通过构造函数的初始化列表来获得初值

A(int i):a(i){···}

private:

const int a; //常数据成员

static const int b;//静态常数据成员

};

const int A::b=10; //静态常数据成员在类外初始化

常引用

如果在声明引用时用const修饰，被声明的引用就是常引用，常引用所引用的对象不能被更新

常引用的声明形式：

const 类型说明符 & 引用名;

一个常引用，无论是绑定到一个普通对象，还是一个常对象，通过该引用访问该对象时，都只能把该对象当做常对象

class Point{

public:

Point(int x,int y):x(x),y(y){}

friend float dist(const Point &p1,const Point &p2);

private:

int x,y;

};

float dist(const Point &p1,const Point &p2){ //常引用作形参

double x=p1.x-p2.x;

double y=p1.y-p2.y;

return sqrt(x*x+y*y);

}

int main(){

const Point m1(1,1),m2(4,5);

cout<<dist(m1,m2)<<endl; //两点间距离

}

Tips

include书写方式
- include <文件名>，按照标准方式搜索嵌入文件，文件位于编译环境include子目录下。示例：include <iostream>
- include “文件名”，在当前目录下搜索嵌入文件，如果搜不到则转为标准搜索。示例：include "point.h"
外部变量
- 如果一个变量可以在本文件和其他文件中使用，称为外部变量，用 extern 关键字说明