数据的共享与保护

标志符的作用域和可见性

作用域

• 函数原型作用域：函数形参表括号
• 局部作用域（块作用域）：函数体或大括号，函数的形参
• 类作用域：类体和成员函数体
• 文件作用域：开始于声明点，结束于文件尾
• 命名空间作用域

#include <iostream>
using namespace std;

int i = 0; //全局变量，文件作用域 

int main(){
    i= 5;
    {
        int i;  //局部变量，局部作用域
        i = 7;
        cout << i << endl; 
    } 
    cout << i << endl;
    return 0;
}

对象的生存周期

• 静态生存期：整个程序运行期间都存在，static修饰，未初始化默认为0
• 动态生存期：结束于作用域尾

#include <iostream>
using namespace std;

int i = 0; //全局变量，文件作用域 
void other(){
    static int a = 1;  //静态局部变量 
    int c = 10;       //局部变量，动态生存期
    a += 2;
    i +=32;
    c +=5; 
    cout << "i: " << i << " a: " << a << " c: " << c << endl;
}

int main(){
    other();
    other();
    return 0;
}

类的静态成员

类的静态数据成员

• static修饰，为该类的所有对象共享，具有静态生存期
• 必须在类外定义和初始化，用 :: 来指明所属的类

类的静态函数成员

• 一般只用于处理类的静态数据成员，不处理具体某个对象的数据。

#include <iostream>
using namespace std;

class Point{
    public:
        Point(int x=0, int y=0):x(x), y(y){
            count++;
        }
        Point(const Point& p){  //复制构造函数 
            x = p.x; y = p.y; count++; 
        }
        ~Point(){       //析构函数 
            count--;
        }
        int getX(){return x;}
        int getY(){return y;} 
        static void showCount(){    //静态函数成员 
            cout << "Object count: " << count << endl;
        }
    private:
        int x, y;
        static int count;   //静态数据成员声明 
};

int Point::count = 0;   //静态数据成员定义和初始化，使用类名限定 

int main(){
    Point::showCount(); //可以直接调用，不需要通过对象调用 
    Point a(4, 5);
    cout << a.getX() << a.getY() << endl;
    a.showCount();     //也可以通过对象调用

    Point b(a);
    cout << b.getX() << b.getY() << endl;
    Point::showCount();
    return 0;
}

友元

• 友元模块可以访问到另一个模块中被隐藏的信息
• 关键字 friend 修饰，可以访问private 和 protected成员
• 在封装和快速性达到平衡

友元函数

#include <iostream>
#include <cmath>
using namespace std;

class Point{
    public:
        Point(int x=0, int y=0):x(x), y(y){
        }
        int getX(){return x;}
        int getY(){return y;} 
        friend double dist(const Point& a, const Point& b){   //友元函数 
            double x = a.x - b.x;  
            double y = a.y - b.y;
            return static_cast<float>(sqrt(x*x+y*y));
        } 
    private:
        int x, y;
}; 

int main(){
    Point p1(1, 5), p2(1,2);
    cout << dist(p1, p2) << endl;
    return 0;
}

友元类

• 若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员
• 友元关系是单向的

共享数据的保护

• 关键字 const 修饰

常对象

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

常成员函数

• 返回类型 函数名（参数表） const

• 不更新对象的数据成员

• 通过常对象只能调用它的常成员函数，非常对象也可以调用它的常成员函数

• 可以用来区分重载函数

#include <iostream>
#include <cmath>
using namespace std;

class Point{
    public:
        Point(int x=0, int y=0):x(x), y(y){
        }
        int getX(){return x;}
        int getY(){return y;} 
        void print();
        void print() const; //常成员函数 
    private:
        int x, y;
}; 

void Point::print(){
    cout << x << y << endl;
}

void Point::print() const{
    cout << x << y << endl;
}

int main(){
    Point p1(1, 5);
    p1.print();  //调用void print() 

    const Point p2(2, 4);
    p2.print();  //调用void print() const 
    return 0;
}

常数据成员

• 只能在初始化的时候赋值，其他时候不可以改变其值

#include <iostream>
#include <cmath>
using namespace std;

class A{
    public:
        A(int i);
        void print();
    private:
        const int a;    // 常数据成员的声明 
        static const int b;  //静态常数据成员的声明 
};

const int A::b = 10;  // 静态常数据成员初始化 
A::A(int i):a(i){}   //常数据成员通过列表初始化，不能通过函数体初始化 

void A::print(){
    cout << a << b << endl;
}

int main(){
    A a1(100), a2(0);
    a1.print();
    a2.print(); 
    return 0;
}

常引用

• 不能通过常引用修改原来的值
• 非常安全

多文件结构与预编译命令

多文件结构

• 类声明文件（.h文件）
• 类实现文件（.cpp文件）
• 类的使用文件（main所在的.cpp文件）

编译与链接

//类的定义
class Point{
    public:
        Point(int x=0, int y=0):x(x), y(y){
            count++;
        }
        Point(const Point& p); //复制构造函数
        ~Point(){       //析构函数 
            count--;
        }
        int getX() const{return x;}
        int getY() const{return y;} 
        static void showCount();  //静态函数成员
    private:
        int x, y;
        static int count;   //静态数据成员声明 
};

//类的实现
#include "point.h"
#include <iostream>
using namespace std;

int Point::count = 0;  //初始化静态数据成员

Point::Point(const Point& p):x(p.x), y(p.y){
    count++;
} 

void Point::showCount(){
    cout << "Object count: " << count << endl;
}

//主函数文件
#include <iostream>
#include "point.h" 
using namespace std;

int main(){
    Point a(4, 5);
    cout << a.getX() << a.getY() << endl;
    Point::showCount();

    Point b(a);
    cout << b.getX() << b.getY() << endl;
    b.showCount();
    return 0;
}

外部变量与函数

• 外部变量：文件作用域中定义的变量，默认情况下为外部变量；若需在其他文件中使用，则使用extern关键字修饰

• 外部函数：类定义之外的函数具有文件作用域，若需在其他文件使用只需extern声明一下即可

• 在匿名空间中定义的变量和函数不会暴露给其他单元

  namespace {
      int n;
      void f(){
          n++;
      }
  }
  
  

编译预处理命令

• include：将一个源文件插入到当前源文件中该点处

  • 自定义的.h文件在include时用 " "，会现在当前工作目录找，然后再到系统目录找；而系统.h文件使用 < >，直接到系统目录找

• define：宏定义指令

  • 定义符号常量，可以用const取代
  • 定义带参数宏，可以用内联函数取代

• undef：删除#define定义的宏

• if 和 #endif：选择编译

  #if 常量表达式
      程序正文1   //当常量表达式非零时编译
  #else
      程序正文2
  #endif
  
  

• ifdef 和ifndef：选择编译，一般在头文件中使用；避免多次编译

  #ifdef 标志符
      程序段1   //当标识符未被定义过则编译
  #else
      程序段2
  #endif#