c++程序结构

东南大学第5章c++程序结构

本章重点注意const   static两个关键字，也是企业面试中常见的面试题
（一）作用域
作用域：标识符的可见范围；
可见性：标识符是否可以引用的问题。
1，函数原型作用域  
    函数原型里的形参
2，块作用域 
    块中的标识符作用域在花括号之间
3，类作用域
    类X的一个成员M，在X的任何一个没有重新声明变量M的函数成员中都可以
    访问到M。
4，文件作用域
    开始于声明点，结束于文件尾

        内存中的程序
------------|
代码区      |
------------|
全局数据区  |全局变量
------------|
堆区        |先咨询后分配
------------|
栈区        |函数局部变量
------------|

可见性：从内向外看，如果看见则引用。
        外有内无某一标识符，则在内可见
        外有内也有，则内只见内。

（二）对象的生存期
1，静态生存期 与程序的运行期相同
   文件作用域
   函数内部 冠以static  静态局部变量

2，动态生存区  开始于声明点，结束与作用域结束处
   典型例题
void main()
{
   fun();
   fun();
}
void fun()
{
  static a=1;
  a++;
  cou<<a<<endl;
}

（三）数据与函数
（1）局部变量：
          函数中，auto可省，栈中分配
          只在本函数使用， 不初始化，为任意值     
#include iostream.h

int fun1();
int fun2();
void main()
{
   fun1();
   cout<<fun2()<<endl;
}
int fun1()
{
  int i=12345;
  return i;
}
int fun2()
{
  int j;
  return j;
}
？？？
（2）全局变量： 在所有函数的外部，在程序的每个函数都可见
                存放的在全局数据区，不初始化则为0
  
   实现变量的共享，每个函数都可以访问（不提倡）。

（3）数据成员：
     在类中的数据成员，类内共享，类外有权限

 

（四）静态成员
1，静态数据成员
     不用全局对象，使用类中的静态数据成员
     static声明
     所有对象维护该成员的同一拷贝，自由一个空间
统计对象个数
class Point{
  private :
    static int countP;  //不分配空间
  public :
    Point(){countP++};
    Point(Point &p);
};
Point::Point(Point &p)
{
  ...
  countP ++;  //产生一个对象就++
}
int Point::countP=0;  //在文件作用域某地使用类名限定进行定义性说明。
                      //***分配空间
源码见文末
2，静态成员函数  解决操作合法性控制问题
    作用域操作符 ::
   注意：*静态成员属于类，非静态成员属于对象
         *只能引用属于该类的静态数据成员或静态成员函数
         *不能直接引用类中的非静态成员，通过对象a.x来访问
class Point
{
  public :
    static void X(){....};
}
int main()
{
  Point :: X();
}
在基类的派生类中,可以直接访问继承而来的protected成员,但是不能访问private限制的成员.

 

(五）友元
     friend
    提供破坏数据封装和数据隐藏机制。
    将一个模板声明为另一个模板的友元。
1，普通函数
class Point{
 public:
   friend float fDist(Point &a,Point &b);//通过对象名访问
 private:
   int x; int y;
};
double fDist(Point &a,Point &b)
{
   a.x;
   a.y;
}
2，友元成员函数     
   一个类的成员函数可以说明为另一个类的友元函数
class Student; //预声明
class Teacher{
  public :
      void assign(Student &s);
};
class Student{
  public；
   friend void Teacher::assign(Student &s);
};

3，友元类
class A{
   friend class B;           
};                             
class B{                
                          
};

友元是单向的。
  不能传递。
（六）共享数据的保护

常类型：必须初始化，而且不能被更新。
1,常引用做形参
int main()
{
   double d;
   display(d);
}
void display(const double &r){
   ...//函数体中不能更新r
}
2.常对象
class A{

};
A const a(3,4);
3,常成员函数
    不更新对象的数据成员
    常对象只能调用他的常成员函数，实现重载。
class R{
   public :
      void print();
      void print() const;
};
int main()
{
    R r;
    r.print();
    const R x;
    x.print();//调用print() const
}
4,常数据成员
class A{
  public:
     A(int i);
     const int &i;
  private：
     const int a;
     static const int b;//静态常数据成员
};
const int A::b=10;   //不可变
A::A(int i):a(i),r(a){};  //*****编译的时候就赋值了
void main()
{}

常数组，常指针。

（七）编译预处理命令
1，
include 尖括号    按标准方式    （妈的，新浪不知道怎么搞的尖括号里的东西都会没了）
include""    先在当前目录搜索，后标准方式
#define
#if  #endif
#ifdef  #endif
例：
//head.h
#ifndef HEAD_H
  #define HEAD_H
  class point
  {}
#endif
...大型的程序有助于多人开发

（八）多文件结构和工程

多文件结构
类声明 file.h
类实现 file.xpp
类使用 main所在的file.cpp
使用vc++建立一个多文件工程

#include iostream.h
class Point{
  private :
  int x;
    static int countP;  //统计
  public :
 Point(int a){x=a;countP++;};
    Point(Point &p);
 int getC(){return countP;}
};
Point::Point(Point &p)
{
  x=p.x;
  countP ++;  //产生一个对象就++
}
int Point::countP=0;  //在文件作用域某地使用类名限定进行定义性说明。
                      //***分配空间
void main()
{
   Point p(3);
   Point q(p);
   cout<<q.getC()<<endl;
}