数据的共享与保护

**1.作用域：**标识符的有效范围，一个标识符在程序正文中有效的区域。

c语言中的作用域我们有学过：全局变量（全局作用域），局部变量（局部作用域）

c++中标识符的作用域：

a.函数原型作用域：在函数原型声明时形参的作用范围
如：double area(double radius);//函数声明

标识符radius的作用范围在函数area形参列表的左右括号之间，在程序的其他地方不能引用这个标识符。
注意：由于在函数原型的形参列表中起作用的只是形参类型，标识符并不起作用，因此是允许省去的。但是考虑到程序的可读性，通常还是要在函数原声明时给出形参标识符。

b.局部作用域（块作用域）：函数形参列表中形参的作用域，从形参列表中的声明处开始，到整个函数体结束。
函数体内声明的变量，其作用域从声明处开始，一直到声明所在的块结束的大括号为止。
具有局部作用域的变量也称为局部变量。

c.类作用域：类中的所有成员函数可以访问类的所有数据成员（共享类中的数据成员）。在类外，类的对象可以访问类的公有成员(公有成员，在类外也不能直接使用，必须通过类的对象来访问)

d.命名空间作用域：
命名空间产生于命名危机
一般形式：
namespace 命名空间名
{
命名空间内的各种声明（函数声明、类声明、变量声明……）
}
一个命名空间确定了一个命名空间作用域，凡是在该命名空间之内声明的、不属于前面所述各种作用域的标识符，都属于该命名空间作用域。在该命名空间内部可以直接引用当前命名空间中声明的标识符（前提是标识符的声明在引用之前）。

    引用其他命名空间的标识符：命名空间名::标识符名
    
    当两个命名空间中有相同的标示符，并且都使用的using namespace命令，那么在引用标示符时，必须采用“命名空间名::标识符名”引用来加以区分。否则编译时报二义性错误。     

命名空间可以嵌套。命名空间分为全局命名空间和匿名命名空间。全局命名空间是默认的命名空间，在显示声明的命名空间之外声明的标识符都在一个全局命名空间中（如：在显示声明的命名空间之外声明的全局变量、全局函数、全局类……）。匿名命名空间是一个需要显示声明的没有名字的命名空间。在一个源文件中没有办法访问其他源文件的匿名命名空间，但可以直接引用本源文件中的所有匿名空间中的所有标示符（前提是命名空间的定义在引用之前）。具有命名空间作用域的变量也称为全局变量。
注：在一个文件中，全局命名空间和匿名命名空间中可以定义同名的标示符。但是如果直接使用同名的标示符，编译时会报二义性错误

2.可见性
作用域可见性一般规则：
a.标识符要声明在前，引用在后。
b.在同一作用域内，不能声明同名的标识符。
c.在没有互相包含关系的不同作用域中声明的同名标识符，互不影响。
d.如果在两个或多个具有包含关系的作用域中声明了同名标识符，则外层标识符在内层不可见。

3.对象生存期：分为静态生存期和动态生存期

a.静态生存期（静态成员变量，全局变量，静态局部变量）：对象的生存期与程序的运行期相同。
1>在命名空间作用域中声明的对象都具有静态生存期。
2>如果要在函数内部的局部作用域中声明具有静态生存期的对象，则要使用static关键字。
3>局部作用域中静态变量特点：它不会随着函数调用而产生一个副本，也不会随着函数返回而失效
4>定义时未指定初值的基本类型静态变生存期量，会被赋予0值初始化

b.动态生存期：除上述情况其余对象都具有动态生存期，局部生存期对象诞生于声明点，结束于声明所在的块执行完毕之时。

提示：类的成员对象也有各自的生存期。不用static修饰的成员对象，其生存期都与它们所属对象的生存期保持一致。

注：在c++中如何判断是静态局部变量还是动态局部变量？
变量和对象如果是全局的和局部的前面有static修饰的都是静态生存期；
对象成员有static修饰的就是静态生存期；
其他的都是动态。

3.类的静态成员：解决同一个类的不同对象之间数据和函数的共享问题
函数是结构化程序设计中程序模块的基本单位，模块间对内存中的数据共享通过函数与函数见的数据共享来实现，主要途径：参数传递，全局变量。

4.静态数据成员（静态成员变量，在main函数访问之前构造出来）
属性：
a."类的属性是描述类的所有对象的共同特征的数据项，对于任何对象实例，它的属性值是相同的。
b. 静态数据成员具有静态生存期，可以通过“类名::静态数据成员名”来访问。
c. 在类的定义中仅仅对静态数据成员进行引用性声明，必须在命名空间作用域的某个地方使用类名限定定义性声明，这时也可以进行初始化。
d.静态函数成员既可以在类定义中实现，也可以先在类中声明，再在类定义外实现，但static关键字只能写在类定义中，否则编译出错。

提示：之所以类的静态数据成员需要在类定义之外再加以定义，是因为需要以这种方式专门为它们分配空间。非静态数据成员无须以此方式定义，因为它们的空间是与它们所属对象的空间同时分配的。类内声明，类外定义。类内写变量名，类外写类名：：变量名

5.静态函数成员（static关键字声明的函数成员）
1> 静态成员函数可以通过类名和对象名来调用，而非静态成员函数只能通过对象名来调用。习惯：虽然静态成员函数可以通过类名和对象名两种方式调用，但一般习惯于通过类名调用。因为即使通过对象名来调用，起作用的也只是对象的类型信息，与所使用的具体对象毫无关系。
2>静态函数成员可以直接访问该类的静态数据和函数成员。而访问非静态成员，必须通过对象名。例如下面的程序段：

class A
{
public:
        static void f(A a);
private:
        int  x;
);
void A:: f(A a){   
    cout<<x;              //对x的引用是错误的
    cout<<a.x;          //正确    

提示：之所以在静态成员函数中访问类的非静态成员需要指明对象，是因为对静态成员函数的调用是没有目的对象的（本质是没有this指针）。
静态成员函数没有this指针，非静态成员函数有this指针。在静态成员函数中无法对本类中的非静态成员进行默认访问。

**在静态成员函数中只能访问静态成员，但是在非静态成员函数中可以访问静态成员。静态数据成员可以定义为const，但静态成员函数不能定义为const，否则编译出错。在对类的静态数据成员（包括公有数据成员和私有数据成员）初始化的同时，还可以引用类的其他私有成员。

如：

class Point

{

public:

         staticint getP1()               //通过静态成员函数访问静态数据成员p1，返回其属性x

         {

                   returnp1->x;             //p1是指针，通过"->"来访问

         }

 

         staticint getP2()               //通过静态成员函数访问静态数据成员p2，返回其属性x

         {

                   returnp2.x;              //p2是对象，通过"."来访问

         }

        

         staticvoid Destroy()

         {

                   if(p1!= NULL)

                   {

                            deletep1;

                            p1= NULL;

                   }

         }

 

//析构函数（初始化时，除了通过new调用构造函数外，只要通过其他方式调用了构造函数，析构函数就必须是公有的。）

         virtual~Point()                           

         {

                   cout<< "析构函数" << endl; 

         }

 

private:

         Point(intx = 0):x(x){cout << "构造函数" << endl;}           //私有构造函数

        

         intx;                                     //数据成员x

//静态数据成员p1，类的所有对象共享一份（sizeof(Point)值为8,虚函数和x各占4个字节）

         staticPoint *p1;      

         staticPoint p2;                 //静态数据成员p2，类的所有对象共享一份

};

 

Point *Point::p1 = new Point(6);               //引用私有构造函数，对其进行初始化

Point Point::p2 = Point(8);                         //引用私有构造函数，对其进行初始化

 

int main()

{

         cout<< Point::getP1() << endl;//6

         cout<< Point::getP2() << endl;//8

         Point::Destroy();//显示的释放p1的空间

         cout<< sizeof(Point) << endl;//8

         return0;

}

 

单例模式

一个类在任何时刻，只能创建一个实例。

class Point

{

public:

         staticPoint* Create(int x, int y)                //通过静态成员函数给静态数据成员分配空间

         {

                   if(NULL== m_p)                 //只有当m_p为NULL的时候，才创建对象。保证在任意时刻只能有一个对象

                   {

                            m_p= new Point(x, y);              //new 调用构造函数，并给对象分配空间，返回对象的指针

                   }

 

                   if(NULL== m_p)                 //判断空间是否申请成功

                   {             

                            cout<< "Create()   error!"<< endl;      //错误输出

                   }

 

                   returnm_p;               //返回对象指针，便于在类外使用

         }

 

         staticvoid Destroy()//通过静态成员函数释放静态数据成员的空间

         {

                   if(m_p!= NULL)                 //当m_p不为NULL时，释放空间

                   {

                            deletem_p;               //delete 调用析构函数，并释放对象指针空间

                            m_p= NULL;             //将数据成员置为NULL，保证下次还能创建对象

                   }

         }

 

         intGetX()          //返回x

         {

                   returnx;

         }

 

         intGetY()          //返回y

         {

                   returny;

         }

 

private:

 

         Point(intx = 4, int y = 5):x(x), y(y)              //私有构造函数

         {

                   cout<< "构造函数" << endl;

         }

 

         ~Point()             //私有析构函数

         {

                   cout<< "析构函数" << endl;

         }

 

         intx;                   //非静态数据成员

         inty;                   //非静态数据成员

         staticPoint *m_p;            //静态数据成员

};

 

Point *Point::m_p = NULL;//静态数据成员必须在类定义之外再定义（分配空间）。初始化为NULL

 

int main()

{

         Point*p = Point::Create(6, 8);

         cout<< "(" << p->GetX() << ", " <<p->GetY() << ")" << endl;

         Point::Destroy();

         p= NULL;          //避免野指针

 

         p= Point::Create(12, 45);

         cout<< "(" << p->GetX() << ", " <<p->GetY() << ")" << endl;

         Point::Destroy();

         p= NULL;         //避免野指针

         return0;

}

6.类的友元：提供了不同类或对象的成员函数间，类的成员函数与一般函数之间进行数据共享的机制。
1）友元函数
a.优点：既实现了数据的共享又实现了数据的隐藏。
b.不足：对数据隐藏和封装造成了一定程度上的破坏

1>友元函数：是在类中用关键字friend修饰的非成员函数。
2>友元函数可以是一个普通函数，也可以是其他类的成员函数
3>友元函数不是本类的成员函数，但是在它的函数体中可以通过对象名访问类的私有和保护成员

2）友元类：若A类为B类的友元类，则A类的所有成员函数都是B类的友元函数，都可以访问B类的私有和保护成员。
一般形式：

class B
{
           ```// B类的成员声明
           eiend  class A;    //声明A为B的友元类
           ```
 };

注意：
1> 友元函数是不能传递的。
2>友元函数是单项的。
3>友元关系是不被继承的。

7.共享数据的保护

1. 常对象
   a.它的数据成员值在对象的整个生存期间内不能被改变（常对象必须进行初始化，而且不能被更新）。
   注意：在定义一个变量或常量时为它指定初值叫做初始化，而在定义一个变量或常量以后使用赋值运算符修改它的值叫做赋值，请勿将初始化与赋值混淆。
   b.一般形式：const + 类型说明符 + 对象名
   细节：在声明常对象时，把const关键字放在类型名后面也是允许的。

2）用const修饰的类成员

1> 常成员函数 ：使用const关键字修饰的函数为常成员函数
2>一般形式： 类型说明符 + 函数名（参数表）+const；
注意：
a. const是函数类型的一个组成部分，因此在函数的定义部分也要带const关键字。
b. 如果将一个对象说明为常量，则通过该常对象只能调用它的常成员函数，而不能调用其他成员函数（这就是C++从语法机制上对常对象的保护，也是常对象唯一的对外接口方式）。
c. 无论是通过常对象还是普通对象调用常成员函数，在常成员函数调用期间，目的对象都被视为常对象，因此常成员函数不能更新目的对象的数据成员(只能使用数据成员的值)，也不能针对目的对象调用该类中没有用const关键字修饰的成员函数。（这就保证了在常成员函数中不会更改目的对象的数据成员的值）

例如：  int i=98;
              const int *p=&i;
              int *q=&i;
              p=q;   //正确   （非常属性可给常属性）权利在移交的过程中只会减少，不会增加
              q=p;  //错误

d. const关键字可以用于对重载函数的区分。例如：void print (); void print() const;这是对print的有效重载。

提示：如果仅以const关键字区分成员函数的重载，那么通过非const的对象调用该函数，调用不带const关键字的函数；通过const的对象调用该函数，调用带const关键字的函数。如没有不带const关键字的函数，那么都将调用带const关键字的函数。如没有带const关键字的函数，则当通过const的对象调用该函数时，编译出错。

3）常数据成员 ：使用const说明的数据成员为常数据成员。

1>如果一个类中说明了常数据成员， 那么任何函数都不能对该成员赋值
2>构造函数对该成员初始化， 只能通过初始化列表 eg： A : : A ( int i ) : a(i){} A：类 a : 常数据成员
3>类的静态常量如果具有整数类型或枚举类型，那么可以直接在类的定义中为它指定常量值 eg： static const int b = 10; b : 静态常量

细节：类的静态变量和静态常量都应当在类定义之外加以定义（分配空间）和初始化，但C++标准有一个例外：类的静态常量如果具有整数类型或枚举类型，那么可以直接在类定义中为它指定常量值。 例如：static const int b=10；

4）常引用：若在声明引用时用const修饰，被声明的引用就是常引用。

a. 作用：常引用所引用的对象不能被更新（如果用常引用用作形参，便不会意外的发生对实参的更改）
b. 一般形式：const 类型说明符 &引用名；
c.对于基本类型的常引用，则不能为数据赋值
d. 对于类类型的常引用，则不能修改它的数据成员，也不能调用它的非const的成员函数
e. 常引用适用情况：
在函数中无需改变其值的参数（避免常对象无法被传入：因为普通引用不能绑定到常对象，常引用才能绑定到常对象）；
对于大对象来说，传值耗时较多，因此传递常引用为宜；
复制构造函数的参数一般也宜采用常引用传递。

8.多文件结构和编译器预处理命令
1）c++程序的组织结构：

1>.通常一个项目至少划分为3个文件： 类定义文件（.h文件）、类实现文件（.cpp 文件）、类的使用文件（* . cpp 主函数文件） 这样组织结构的好处：可以对不同的文件进行单独编写、编译，最后再连接，同时可以充分利用类的封装特性
2>.决定一个声明放在源文件还是头文件的一般原则:
将需要分配空间的定义放在源文件中： 例如 函数的定义（需要为函数代码分配空间）、命名空间作用域中变量的定义（需要为变量分配空间）等；
而将不需要分配空间的声明放在头文件中 例如 类声明、外部函数的原形声明、外部变量的声明、基本数据类型的常量的声明等。

注意： 内联函数 若被多个编译单元调用，它的代码应该被各个编译单元可见，这些内联函数的定义应当出现在头文件中

2）外部变量与外部函数：

a. 外部变量：

1.命名空间作用域定义的变量，默认情况下都是外部变量，但在其他文件中如果需要使用这一变量，需要用 extern 关键字加以声明
2.外部变量是可以为多个源文件所共享的全局变量
3.外部变量可以有多处声明，但是对变量的定义性声明只能是唯一的

b.外部函数：

1> 所有类之外声明的函数（也就是非成员函数），都是具有命名空间作用域的， 如果没有特殊说明；
2> 如果没有特殊说明，这样的函数都可以在不同的编译单元中被调用，只要在调用之前进行引用性声明（即声明函数原型）即可
3>也可以在声明函数原型和定义函数时用extern修饰，其效果与不加修饰的默认状态是一样的

重要！：通常情况下，变量和函数的定义都放在源文件中， 而对外部变量和外部函数的引用性声明则放在头文件中

将变量和函数限制在编译单元内：

4>.static 关键字用来修饰命名空间作用域的变量或函数时，和extern关键字起相反的作用
5>.static 关键字修饰的变量和函数无法被其他编译单元引用
6>3种用法：
1》：局部作用域（函数调用或返回不会对其重新赋值）
2》：类作用域（实现类中成员共享数据）
3》：命名空间作用域（限制使用权限在编译单元中）
共同点：凡是被static修饰的变量，都具有静态生存期
7>. 匿名的命名空间：匿名的命名空间中定义的变量和函数都不会暴露给其他编译单元
9.标准C++库

标准C++库与组件在逻辑上分为六种类型：

输入输出类

容器类与ADT

存储管理类

算法

错误处理

运行环境支持

提示:包含这些头文件的目的是在当前编译单元中引入所需的引用性声明，而它们的定义则以目标代码的形式存在于系统的运行库中。

习惯：通常情况下，using namespace语句不宜放在头文件中，因为这会使一个命名空间不被察觉的对一个源文件开放。

10.编译预处理

1.#include 命令 （可嵌套使用）
1）# include<文件名>
按标准方式搜索，文件位于系统目录的include子目录下；

2）# include“文件名”
首先在当前目录中搜索，若没有，再按标准方式搜索；

2… #define 和 #undef
C 语言中， # define PI 3.14

C++，虽然扔可以这样定义符号常量，但最好的方法是在类型说明语句中用const 进行修饰

C语言中， #define 定义参数宏

C++中被内联函数取代

   #define  可以定义空符号，例如：

      #define MYHEAD_H

      定义它的目的，仅仅是表示“MYHEAD_H已经定义过“这样一种状态。将该符号配合条件编译指令一起使用，可以起到一些特殊作用，这是#define 在C++中的最常用之处

 #undef 的作用是删除由 # define 定义的宏，使之不再起作用

3.条件编译指令：

限定某些内容要在满足一定条件的情况下才参与编译：

平时最常用的:  eg:  # ifndef  标识符
                            程序段1
                            #endif

有好多种种形式，这里不一一列举
4. defined 操作符
是一个预处理操作符，而不是指令，因此不要以 # 开头

如果”标识符“在此前经 #define 定义过，并且未经 #undef 删除，则上述表达式为非0，否则上述表达式为0

好处：由于文件包含指令可以嵌套使用，在设计程序时，要避免多次重复包含一个头文件，否则会引起变量及类的重复定义