3DS MAX SDK开发学习记录

3DS MAX SDK开发学习记录 - 程序逻辑

 目 录
  1.1 基本思想
  1.2 系统管理插件的接口部分
  1.3 用户启用插件生成物体时的接口部分

1.1、基本思想
  3DS MAX SDK是一组库及相应的头文件,其中包含了3DS MAX的大部分核心代码,利用库中的函数就可与系统内核通信。3DS
MAX的插件(Plugins)就是一种动态链接库,每个插件都包含有若干个类及对象和公用函数。有一组公用函数及几个类的对象是提供给系统挂接和管理插件用的,另外一些类则实现插件本身的功能(如造型或修改)。

  插件中的每种活动都是由相应如的类对象来完成的,如系统获取插件中定义的类的描述、插件对象创建时的鼠标交互响应、用户对插件对象参数的修改等都有相应的类,系统会调用指定的公用函数取得这些对象的地址,并在适当的时候激活它们。这就是3DS
MAX的回调机制。

1.2、系统管理插件的接口部分

  

  // 定义插件对象的32位类ID。
  #define SPHERE_C_CLASSID1 8239283498
  #define SPHERE_C_CLASSID2 8239283498

  // 插件描述类对象
  SphereClassDesc sphereDesc;
  ClassDesc* GetSphereDesc() { return
&sphereDesc;}

  // 系统管理所需方法
  // 这几个方法都是dllexport型的
  LibVersion() {return VERSION_3DSMAX;}
  LibNumberClasses() {return 1;}
  LibClassDesc() {return GetSphereDesc();}
  LibDescription() {return _T("Sphere Object. Call
1-800-plig-in");}

  // 插件描述类,成员为供系统管理用的方法
  class SphereClassDesc: public ClassDesc
  {
  public:
    int      IsPublic()   {return 1;} // true可由用户选取,
                         // false由其它插件调用不与用户打交道。
    void *     Create(BOOL loading=FALSE)  {return new
SphereObject;}
    const TCHAR * ClassName()  { return _T("Sphere_c");}
    SClass_ID   SuperClassID(){ return GEOMOBJECT_CLASS_ID;}
    Class_ID    ClassID()   { return
CLASS_ID(SPHERE_C_CLASSID1,SPHERE_C_CLASS_ID2); }
    const TCHAR*  Category()   { return _T("How To");}
  }

1.3、用户启用插件生成物体时的接口部分

  

  // 创建时期的用户鼠标交互接口
  // 由一个CreateMouseCallBack衍生类的对象定义
  class SphereObjCreateCallBack: public CreateMouseCallBack
  {
    IPoint2 sp0;
    SphereObject *ob;
    Point3 p0;
  public:
  // 开发者定义的创建时期的用户交互方法
    int proc(ViewExp *vpt, int msg, int point, int flags, IPoints2
m, Matrix3 &mat);
    void SetObj(SphereObject *obj) { ob=obj;}
  }

  // 创建时对用户鼠标交互活动的响应代码
  int SphereObjCreateCallBack::proc(ViewExp *vpt,
      int msg, int point, int flags, IPoints2 m, Matrix3
&mat)
  {
    float r;
    Point3 p1,center;
    if(msg==MOUSE_POINT || msg==MOUSE_MOVE)
    {
      switch (point)
      {
        case 0:... break;
        case 1:... break;
      }
    else if(msg==MOUSE_ABORT) { return CREATE_ABORT; }
    return TRUE;
  }

  // 定义创物体创建时的回调类对象。
  static SphereObjCreateCallBack sphereCreateCB;

  // 在插件所创建的物体的类中定义获取创建回调函数地址的方法。
  CreateMouseCallBack* SphereObject::GetCreateMouseCallBack()
  {
    sphereCreateCB.SetObj(this);
    return &sphereCreateCB;
  }

  // 创建时期对用户修改物体参数的响应
  // 在用户编辑实体参数(创建时或修改时)系统将调用BeginEditParams(),该方法负责为面添加并注册滚转页
  // 在编辑完成时系统将会调用EndEditParams()。

  //BeginEditParams用来在用户进入参数编辑框时
  void SphereObject::BeginEditParams(IObjParam*ip,ULONG
flags,Animatable *prev)
  {
    SimpleObject::BeginEditParams(ip,flags,prev);
    this->ip=ip;
    if(pmapCreate&&pmapParam)
     {
      pmapCreate->SetParamBlock(this);
      pmapTypeIn->SetParamBlock(this);
      pmapParam->SetParamBlock(pblock);
    }
    else
    {
      if (flags&GEGIN_EDIT_CREATE)
      {
        pmapCreate=CreateCPParamMap(
            descCreate,
            CREATEDESC_LENGTH,
            this,
            ip,
            hInstance,
            MAKEINTRESOURCE(IDD_SPHEREPARAM1),
            _T("Creation Method"),
            0 );
        pmapTypeIn=CreateCPParamMap(
            descTypeIn,
            TYPEINDESC_LENGTH,
            this,
            ip,
            hInstace,
            MAKEINTRESOURCE(IDD_SPHEREPARAM3),
            _T("Keyboard Entry"),
            APPENDROOL_CLOSED );
      }
      pmapParam=CreateCPParamMap(
         descParam,
         PARAMDESC_LENGTH,
         pblock,
         ip,
         hInstace,
         MAKEINTRESOURCE(IDD_SPHEREPARAM2),
         _T("arameters"),
         0 );
    }
    if(pmapTypeIn)
    {
      pmapTypeIn->SetUserDlgProc(new
SphereTypeInDlgProc(this));
    }
  }

  void SphereObject::EndEditParams(IObjParam *ip,ULONG
flags,Animatable *next)
  {
    SimpleObject::EndEditParams(ip,flags,next);
    this->ip=NULL;
    if(flags&END_EDIT_REMOVEUI)
    {
      if(pmapCreate) DestroyCPParamMap(pmapCreate);
      if(pmapTypeIn)DestroyCPParamMap(pmapTypeIn);
      DestroyCPParamMap(pmapParam);
      pmapParam=NULL;
      pmapTypeIn=NULL;
      pmapCreate=NULL;
    }
    pblock->GetValue(PB_SEGS,ip->GetTime(),dlgSegments,FOREVER);

    pblock->GetValue(PB_SMOOTH,ip->GetTime(),dlgSmooth,FOREVER);

  }

  class SphereTypeInDlgProc: public ParamMapUserDlgProc
  {
  public:
    SphereObject *so;
    SphereTypeInDlgProc(SphereObject *s){so=s;}
    BOOL DlgProc(TimeValue t,IParamMap*map,HWIND hWnd,UINT
msg,WPARAM wParam,LPARAM lParam);
    void DeleteThis(){delete this;}
  };

  BOOL SphereTypeInDlgProc:lgProc(TimeValue,IParamMap *map,HWIND
hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
  {
    switch(msg)
    {
      case WM_COMMAND:
        switch(LOWORD(wParam))
        {
          case IDC_TI_CREATE:
            {
              if(so->crtRadius==0.0) return
TRUE;
              if(so->TestAFlag(A_OBJ_CREATING))

              {
                so->pblock->SetValue(PB_RADIUS,0,so->crtRadius);

              }
              Matrix3 tm(l);
              tm.SetTrans(so->crtPos);
              so->ip->NonMouseCreate(tm);

              return TRUE;
            }
            break;
        }
        return FALUSE;
    }

  目 录  2.1 基本的介绍  2.2 插件必须的函数  2.3 类描述器方法成员   3DS MAX
SDK插件是以DLL形式存在的。通常我们用Microsoft Visual C++来开发。建立一个新的工程的描述见“Creating
A New Plugin Project”开发者可以将这些DLL插件存放在任何地方,但是要想法子让3DS
MAX知道到哪里去找这些文件。这部分是在“Plug-In Directory Search
Mechanism”里讨论的。插件开发者可以为应用加上在线帮助,并使用望可在Max Help菜单里访问。细节见“Plug-In
Help
System”。有一个标准的位置供开发者保存插件所需的任何配置文件。这些可能是.ini文件,二进制配置文件或任何需要的文件。详见“Plug-In
Configuration System”。2.1、基本的介绍  2.1.1
标准DLL函数  所有的插件DLL都必须实现一套标准的函数:  DLLMain()  LibDescription()  LibNumberClasses()  LibClassDesc()  LibVersion()  这些允许3DS
MAX访问、维护在DLL内在插件并与之协同工作。这些函数的详情见“DLL, LIbrary Functions, and Class
Descriptors”。  2.1.2 重入与线程安全的插件  3DS
MAX插件必须是可重入与线程安全的。详在高级主题的“Thread Safe Plug-Ins”章节里。2.2、插件必须的函数  3DS
MAX进行DLL装入、分类、管理插件。包括DLL例程和类描述类。“Class
Descriptors”提供插件类的信息,用以实现LibClassDesc()函数。  2.2.1 DLL
functions  DllMain(HINSTANCE hinstDLL, ULONG fdwReason, LPVOID
lpvReserved)
  当DLL被装入时由windows调用。该函数也会在时间关键性操作期间被多次调用,如渲染。所以开发者在该函数内要小心谨慎。注意以下的示意代码中,在DLL第一次调用以后只有很少的语句被执行。该函数应该返回TRUE。  int
controlsInit = FALSE;  BOOL WINAPI DllMain(HINSTANCE hinstDLL,ULONG
fdwReason,LPVOID lpvReserved)  {    // Hang on to this DLL's
instance handle.    hInstance = hinstDLL;    if (!
controlsInit) {      controlsInit = TRUE;      // Initialize MAX's
custom controls      InitCustomControls(hInstance);      //
Initialize Win95
controls      InitCommonControls();    }    return(TRUE);  }  2.2.2
LibNumberClasses()  当3DS
MAX启动之后,它找到并装入这些DLLs。然后,它需要有个方法判断DLL中的插件类数目。开发者应当在本函数中提供,例如:  __declspec(dllexport)
int LibNumberClasses() { return 1; }    返回值即插件类的个数。  2.2.3
LibClassDesc(i)  插件必须向系统提供一个方法以获取插件定义的类的描述器(Class
Descriptors)。类描述器向系统提供DLL中的插件类的信息。本函数使系统可以访问类描述器,返回值应该是指向第i个类描述器的指针。(一个DLL中可以有许多个类描述器)。例如:  __declspec(dllexport)
ClassDesc *LibClassDesc(int i)  {     switch(i) {      case 0:
return &MeltCD;      case 1: return
&CrumpleCD;      default: return
0;    }  }  这里是有关必须被LibClassDesc(i)返回的类描述器的资料。类描述器(Class
Descriptors)向系统提供DLL中插件类的信息。类描述的一个方法负责分配插件类的新实例(Create)。开发者通过从ClassDesc衍生一个子类并实现若干方法成员来建立类描述器。下面是个简单的类描述器及其静态实例的例子。  class
MeltClassDesc : public ClassDesc  {  public:    int      IsPublic()
{ return TRUE; }    void *    Create(BOOL loading=FALSE) { return
new MeltMod(); }    const TCHAR * ClassName() { return _T("Melt");
}    SClass_ID   SuperClassID() { return OSM_CLASS_ID;
}    Class_ID   ClassID() { return Class_ID(0xA1C8E1D1,
0xE7AA2BE5); }    const TCHAR* Category() { return _T("");
}  };  static MeltClassDesc MeltCD;  2.2.4
LibDescription()  当包含入口(过程物体、修改器或控制器等)的MAX文件被装入且系统还没有访问它时(如DLL无效),一个消息被发给用户。当DLL不可用时,系统要求每个DLL返回一个字符串向用户说明情况。例如,假定用户有一个融化修改器,他将此融化修改器应用到场景中的某个节点上,并保存此文件。当他将这个文件给一个没有这个融化DLL的朋友,这个朋友打开这个文件时,系统将发出一条消息说明文件中的一个入口所依赖的DLL找不到,这个消息可能是“融化修改器。想要请打电话025-1234PLUG-INS”。  DLL必须实现LibDescription()才能向系统提供这个字符串。该函数返回值即为当找不到该DLL时要显示的文字。该字符串也将显示在Summary
Info/Plug-In
Info...对话框中。一旦DLL中的一个插件已经在场景中使用过,系统就会把这个字符串保存到max文件里(以便在DLL丢失时显示)。  注意:即使DLL缺席时场景仍然会被打开。3DS
MAX保留任何DLL丢失的节点(entities),这样如果文件被修改并保存然后再在有DLL的系统打开修改后的文件,这些节点仍然存在并链接进场景。不能访问其DLL的入口称为封闭入口(orphaned
entities)。  封闭入口将作为其超类(SupperClass)的通用代表导入。该代表将在场景中显示最少的信息。举个实例:如果入口是个修改器,它将在修改器清单中显示自己的名字,但不会显示任何参数。如果没有对象类型信息,那么将在场景中显示为虚物体(dummy)。它们可以被移动、旋转、缩放、链接、组合、删除……任何与节点相关的操作。丢失的控制器只提供不变的默认值,这些值是不可调的。  参考“Read
Only
Plug-Ins”部分。通过允许插件工作在只读模式,用户可以自由分发DLL,其他人除非通过了基于硬件锁ID的认证可以运行它,否则使用将受到限制直到购买自己的拷贝。以下是该函数实现的一个例子:  __declspec(
dllexport ) const TCHAR *LibDescription()  {    return _T("Melt
Modifier. Call 1-800-PLUG-INS to obtain a copy");  }  2.2.5
LibVersion()  开发者必须实现一个函数以便系统处理不同版本的3DS
MAX插件DLL。因为MAX体系与插件的关系如此之紧密,系统有时候需要阻止插件的老版本被调用。要使MAX能够完成它,DLL必须实现一个名为LibVersion()的函数。这个函数只简单的返回一个预定义的常量,这个常量表明在插件编译时系统的版本。未来版本的MAX可能更新该常量,而老的DLL总是返回以前的值。该函数使得系统可以检查任意一个DLL是否已经被装入,如果是这样则显示一条消息。  __declspec(
dllexport ) ULONG LibVersion() { return VERSION_3DSMAX;
}  注意:开发者可以用下面的全局函数获取该值。  DWORD
Get3DSMAXVersion();  返回正在运行的MAX版本被编译时“\MAXSDK\INCLUDE\PLUGAPI.H”文件中包含的VERSION_3DSMAX宏定义的状态。  总结  插件必须实现这五个函数:DLLMain()、LibNumberClasses()、LibClassDesc(i)、LibDescription()、LibVersion()。这些函数允许系统取得DLL中插件的信息。2.3、六个类描述器方法成员  下面我们来讲讲六个类描述器方法成员:IsPublic()、Create()、ClassName()、SuperClassID()、ClassID()及Category()。  2.3.1
IsPublic()  该方法返回一个布尔值。如果插件可以被用户选取和指派,正是常见的情况,返回TRUE。某些插件可能是同一DLL的实现的其它插件私有专用的,并不出现在清单供用户选择。这些插件将返回FALSE。  2.3.2
Create(BOOL loading =
FALSE)  MAX在需要得到一个指向插件类的新实例的时候调用该方法。例如,如果MAX从磁盘打开一个包含前边用过的插件的文件,它将调用插件的Create()方法。插件负责分配一个插件类的新实例。在上边的例子的是用一个“new”操作简单实现的。  Create()的可选参数是一个标识表明要创建的类是否将从一个磁盘文件中装入。如果该标识为TRUE,插件可以不必做任何初始化工作,因为装入进程将会处理它。见“Loading
and
Saving”章节。  当系统需要删除一个插件类的实例时,它会调用Animatable的DeleteThis()方法。插件开发者必须实现该方法。因为开发使用new操作分配内存,它也应该用delete操作释放之。如开发者可以如下实现DeleteThis():  void
DeleteThis() { delete this; }  进一步的细节参考“Memory
Allocation”章节。  2.3.3
ClassName()  该方法返回类的名字。这个名字将出现在MAX用户界面的插件按钮上。该方法也在调试时显示类的名字。  2.3.4
SuperClassID()  该方法返回系统预定义的常量,该常量表示插件类是从哪个类衍生来的。例如,弯曲修改器返回OSM_CLASS_ID。这个超类ID被所有对象空间修改器使用。其它的超类ID例子有:CAMERA_CLASS_ID、LIGHT_CLASS_ID、SHAPE_CLASS_ID、HELPER_CLASS_ID、SYSTEM_CLASS_ID。完整的清单见“List
of Super Class IDs”。  2.3.5 ClassID()  该方法必须为对象返回一个唯一性ID。3DS MAX
SDK中包含一个生成这种ClassID的程序。使用该程序为你的插件创建ClassID是非常重要的。如果如果你使用任何一个例子程序的源代码来建立自己的插件,必须改变已经存在Class_ID。如果不这样,将会出现冲突。如果两个ClassID冲突,系统将加载它找到的第一个(并将在试图加载第二个时显示存在Class_ID冲突)。  一个Class_ID包含两个无符号的32位整数。建构函数为每一个赋值,如Class_ID(0xA1C864D1,
0xE7AA2BE5)。参见“Class Class
ID”。  注意在MAX使用的插件样本代码将类ID第二个32位整数设为0,只有与MAX一起发售的内建插件才可以这样做。所有的插件开发者都应该同时使用两个32位整数。还有,确保你使用SDK提供程序建立类ID,这可确保两个插件类之间不会冲突。要生成一个随机的Class_ID并可选的将其拷贝至剪帖板中,单击DLL
Function and Class部分的“Generate a Class_ID”。  2.3.6
Category()  在建立面板底部下拉选单选择类别。如果设成已经存在的类别(i.e. "Standard Primitives",
"article Systems",
etc),插件将会出现在那个类别里。开发者不应该加到MAX提供的类别里(见下边的注释)。如果类别还不存在,则将被创建。如果插件不需要出现在清单中,它可以简单的返回一个null字符串_T("")。Category()也被按钮设置对话框中用于插件分类。  重要说明:MAX体系在Create分支面板里有每类12个插件的限制。为预防每个类别有太多插件的问题,开发者应该总是为自己的插件建立一个新的类别而不是使用一个MAX标准插件已经使用的类别。注意早于1.2版本的MAX在每个类别有多于12个按钮时会崩溃。
  管理过程物体创建过程并编辑其参数  这部分讨论以下方法:  GetCreateMouseCallBack()  proc()  BeginEditParams()  EndEditParams()  GetValue()  SetValue  NumSubs()  SubAnim()  SubAnimName()  当MAX用户将要建立一个新的过程物体时,系统会调用插件的一个方法接管创建阶段的用户输入活动。插件可以任意实现其用户界面,但必须向MAX提供一个途径与用户交互过程联系。插件要实现GetCreateMouseCallBack()函数以向MAX提供该途径。这个函数返回一个指向CreateMouseCallBack衍生类实例的指针。这个类有一个proc()方法,程序员在这个函数里定义物体创建阶段的用户交互活动。系统实际上需要一个函数指针,这个函数是由插件实现可以被系统调用。参考sphere_c.cpp源代码。  插件必须实现一些方法以处理用在命令面板中的输入。插件要负责实现从Animatable类继承来的两个方法,这两个方法用来处理用户在命令面板中的输入:BeginEditParams()和EndEditParams()。Begin在用户可以编辑实体参数时由系统调用(物体创建或修改已经存在的实体时都可能调用),它负责向面板里添加卷展栏并将其注册到系统中。加入卷展栏函数带有一个Dialog
Proc参数。这个对话处理过程控制用户与对话框控件的交互活动。过程球体的例子使用了参数映射机制来简化开发者与管理用户界面控制相关工作任务。参数映射被用于管理UI交互活动。见参数映射。  End方法则在用户结束编辑一个物体的参数时被调用。系统将传递一个标识给EndEditParams()以指示卷展栏是否应该删除。如果为TURE,插件必须注销卷展栏,并将其从面板中删掉。在某些情况,物体的卷展栏应该保留在命令面板里。例如如果用户已经完成一个过程球体的建立,它的EndEditParams()方法被调用。然而用户可能希望建立另一个球,这样开发者不可以立刻移走卷展栏。这样用户界面不会因为删除后立刻加回来而闪烁。  参数映射  这部分对于理解例子及简化开发相当有用,所以列入基本内容。参数映射用于最小化插件管理用户界面参数所需的编程工作。一个简单插件,如过程球体,拥有由类似微调控件(to
be continued...)。

高质量C++教程 — 第7章 内存管理

高质量C++教程 -- 第7章 内存管理
来源:www.vcworld.net 

欢迎进入内存这片雷区。伟大的Bill Gates
曾经失言:

640K ought to be enough for everybody

— Bill Gates 1981

程序员们经常编写内存管理程序,往往提心吊胆。如果不想触雷,唯一的解决办法就是发现所有潜伏的地雷并且排除它们,躲是躲不了的。本章的内容比一般教科书的要深入得多,读者需细心阅读,做到真正地通晓内存管理。

 

7.1内存分配方式

内存分配方式有三种:

(1)
从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static变量。

(2)
在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。

(3)
从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最多。

 

7.2常见的内存错误及其对策

发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误,通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状,时隐时现,增加了改错的难度。有时用户怒气冲冲地把你找来,程序却没有发生任何问题,你一走,错误又发作了。

常见的内存错误及其对策如下:

内存分配未成功,却使用了它。

编程新手常犯这种错误,因为他们没有意识到内存分配会不成功。常用解决办法是,在使用内存之前检查指针是否为NULL。如果指针p是函数的参数,那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存,应该用if(p==NULL)
或if(p!=NULL)进行防错处理。

◆内存分配虽然成功,但是尚未初始化就引用它。

犯这种错误主要有两个起因:一是没有初始化的观念;二是误以为内存的缺省初值全为零,导致引用初值错误(例如数组)。

内存的缺省初值究竟是什么并没有统一的标准,尽管有些时候为零值,我们宁可信其无不可信其有。所以无论用何种方式创建数组,都别忘了赋初值,即便是赋零值也不可省略,不要嫌麻烦。

◆内存分配成功并且已经初始化,但操作越过了内存的边界。

例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中,循环次数很容易搞错,导致数组操作越界。

◆忘记了释放内存,造成内存泄露。

含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足,你看不到错误。终有一次程序突然死掉,系统出现提示:内存耗尽。

动态内存的申请与释放必须配对,程序中malloc与free的使用次数一定要相同,否则肯定有错误(new/delete同理)。

 

◆释放了内存却继续使用它。

有三种情况:

(1)程序中的对象调用关系过于复杂,实在难以搞清楚某个对象究竟是否已经释放了内存,此时应该重新设计数据结构,从根本上解决对象管理的混乱局面。

(2)函数的return语句写错了,注意不要返回指向“栈内存”的“指针”或者“引用”,因为该内存在函数体结束时被自动销毁。

(3)使用free或delete释放了内存后,没有将指针设置为NULL。导致产生“野指针”。

 

●【规则7-2-1】用malloc或new申请内存之后,应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。

●【规则7-2-2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。

●【规则7-2-3】避免数组或指针的下标越界,特别要当心发生“多1”或者“少1”操作。

●【规则7-2-4】动态内存的申请与释放必须配对,防止内存泄漏。

●【规则7-2-5】用free或delete释放了内存之后,立即将指针设置为NULL,防止产生“野指针”。

 

7.3指针与数组的对比

C++/C程序中,指针和数组在不少地方可以相互替换着用,让人产生一种错觉,以为两者是等价的。

数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。数组名对应着(而不是指向)一块内存,其地址与容量在生命期内保持不变,只有数组的内容可以改变。

指针可以随时指向任意类型的内存块,它的特征是“可变”,所以我们常用指针来操作动态内存。指针远比数组灵活,但也更危险。

下面以字符串为例比较指针与数组的特性。

 

7.3.1 修改内容

示例7-3-1中,字符数组a的容量是6个字符,其内容为hello。a的内容可以改变,如a[0]=
‘X’。指针p指向常量字符串“world”(位于静态存储区,内容为world),常量字符串的内容是不可以被修改的。从语法上看,编译器并不觉得语句p[0]=
‘X’有什么不妥,但是该语句企图修改常量字符串的内容而导致运行错误。

char a[] = “hello”;

a[0] = ‘X’;

cout << a
<< endl;

char *p = “world”; // 注意p指向常量字符串

p[0] = ‘X’; // 编译器不能发现该错误

cout << p
<< endl;

示例7-3-1 修改数组和指针的内容

 

7.3.2 内容复制与比较

不能对数组名进行直接复制与比较。示例7-3-2中,若想把数组a的内容复制给数组b,不能用语句 b = a
,否则将产生编译错误。应该用标准库函数strcpy进行复制。同理,比较b和a的内容是否相同,不能用if(b==a)
来判断,应该用标准库函数strcmp进行比较。

语句p = a
并不能把a的内容复制指针p,而是把a的地址赋给了p。要想复制a的内容,可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存,再用strcpy进行字符串复制。同理,语句if(p==a)
比较的不是内容而是地址,应该用库函数strcmp来比较。

// 数组…

char a[] = "hello";

char b[10];

strcpy(b, a); // 不能用 b = a;

if(strcmp(b, a) == 0) // 不能用 if (b == a)

// 指针…

int len = strlen(a);

char *p = (char *)malloc(sizeof(char)*(len+1));

strcpy(p,a); // 不要用 p = a;

if(strcmp(p, a) == 0) // 不要用 if (p == a)

示例7-3-2 数组和指针的内容复制与比较

 

7.3.3 计算内存容量

用运算符sizeof可以计算出数组的容量(字节数)。示例7-3-3(a)中,sizeof(a)的值是12(注意别忘了’’)。指针p指向a,但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数,相当于sizeof(char*),而不是p所指的内存容量。C++/C语言没有办法知道指针所指的内存容量,除非在申请内存时记住它。

注意当数组作为函数的参数进行传递时,该数组自动退化为同类型的指针。示例7-3-3(b)中,不论数组a的容量是多少,sizeof(a)始终等于sizeof(char
*)。

char a[] = "hello world";

char *p = a;

cout<< sizeof(a)
<< endl; // 12字节

cout<< sizeof(p)
<< endl; // 4字节

示例7-3-3(a) 计算数组和指针的内存容量

void Func(char a[100])

{

cout<< sizeof(a)
<< endl; // 4字节而不是100字节

}

示例7-3-3(b) 数组退化为指针

 

7.4指针参数是如何传递内存的?

如果函数的参数是一个指针,不要指望用该指针去申请动态内存。示例7-4-1中,Test函数的语句GetMemory(str,
200)并没有使str获得期望的内存,str依旧是NULL,为什么?

void GetMemory(char *p, int num)

{

p = (char *)malloc(sizeof(char) * num);

}

void Test(void)

{

char *str = NULL;

GetMemory(str, 100); // str 仍然为 NULL

strcpy(str, "hello"); // 运行错误

}

示例7-4-1 试图用指针参数申请动态内存

毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本,指针参数p的副本是 _p,编译器使 _p =
p。如果函数体内的程序修改了_p的内容,就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中,_p申请了新的内存,只是把_p所指的内存地址改变了,但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上,每执行一次GetMemory就会泄露一块内存,因为没有用free释放内存。

如果非得要用指针参数去申请内存,那么应该改用“指向指针的指针”,见示例7-4-2。

void GetMemory2(char **p, int num)

{

*p = (char *)malloc(sizeof(char) * num);

}

void Test2(void)

{

char *str = NULL;

GetMemory2(&str, 100); // 注意参数是
&str,而不是str

strcpy(str, "hello");

cout<< str
<< endl;

free(str);

}

示例7-4-2用指向指针的指针申请动态内存

 

由于“指向指针的指针”这个概念不容易理解,我们可以用函数返回值来传递动态内存。这种方法更加简单,见示例7-4-3。

char *GetMemory3(int num)

{

char *p = (char *)malloc(sizeof(char) * num);

return p;

}

void Test3(void)

{

char *str = NULL;

str = GetMemory3(100);

strcpy(str, "hello");

cout<< str
<< endl;

free(str);

}

示例7-4-3 用函数返回值来传递动态内存

用函数返回值来传递动态内存这种方法虽然好用,但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针,因为该内存在函数结束时自动消亡,见示例7-4-4。

char *GetString(void)

{

char p[] = "hello world";

return p; // 编译器将提出警告

}

void Test4(void)

{

char *str = NULL;

str = GetString(); // str 的内容是垃圾

cout<< str
<< endl;

}

示例7-4-4 return语句返回指向“栈内存”的指针

用调试器逐步跟踪Test4,发现执行str =
GetString语句后str不再是NULL指针,但是str的内容不是“hello world”而是垃圾。

如果把示例7-4-4改写成示例7-4-5,会怎么样?

char *GetString2(void)

{

char *p = "hello world";

return p;

}

void Test5(void)

{

char *str = NULL;

str = GetString2();

cout<< str
<< endl;

}

示例7-4-5 return语句返回常量字符串

函数Test5运行虽然不会出错,但是函数GetString2的设计概念却是错误的。因为GetString2内的“hello
world”是常量字符串,位于静态存储区,它在程序生命期内恒定不变。无论什么时候调用GetString2,它返回的始终是同一个“只读”的内存块。

 

7.5
free和delete把指针怎么啦?

别看free和delete的名字恶狠狠的(尤其是delete),它们只是把指针所指的内存给释放掉,但并没有把指针本身干掉。

用调试器跟踪示例7-5,发现指针p被free以后其地址仍然不变(非NULL),只是该地址对应的内存是垃圾,p成了“野指针”。如果此时不把p设置为NULL,会让人误以为p是个合法的指针。

如果程序比较长,我们有时记不住p所指的内存是否已经被释放,在继续使用p之前,通常会用语句if (p !=
NULL)进行防错处理。很遗憾,此时if语句起不到防错作用,因为即便p不是NULL指针,它也不指向合法的内存块。

char *p = (char *) malloc(100);

strcpy(p, “hello”);

free(p); // p 所指的内存被释放,但是p所指的地址仍然不变

if(p != NULL) // 没有起到防错作用

{

strcpy(p, “world”); // 出错

}

示例7-5 p成为野指针

 

7.6 动态内存会被自动释放吗?

函数体内的局部变量在函数结束时自动消亡。很多人误以为示例7-6是正确的。理由是p是局部的指针变量,它消亡的时候会让它所指的动态内存一起完蛋。这是错觉!

void Func(void)

{

char *p = (char *) malloc(100); // 动态内存会自动释放吗?

}

示例7-6 试图让动态内存自动释放

我们发现指针有一些“似是而非”的特征:

(1)指针消亡了,并不表示它所指的内存会被自动释放。

(2)内存被释放了,并不表示指针会消亡或者成了NULL指针。

这表明释放内存并不是一件可以草率对待的事。也许有人不服气,一定要找出可以草率行事的理由:

如果程序终止了运行,一切指针都会消亡,动态内存会被操作系统回收。既然如此,在程序临终前,就可以不必释放内存、不必将指针设置为NULL了。终于可以偷懒而不会发生错误了吧?

想得美。如果别人把那段程序取出来用到其它地方怎么办?

 

7.7 杜绝“野指针”

“野指针”不是NULL指针,是指向“垃圾”内存的指针。人们一般不会错用NULL指针,因为用if语句很容易判断。但是“野指针”是很危险的,if语句对它不起作用。

“野指针”的成因主要有两种:

(1)指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针,它的缺省值是随机的,它会乱指一气。所以,指针变量在创建的同时应当被初始化,要么将指针设置为NULL,要么让它指向合法的内存。例如

char *p = NULL;

char *str = (char *) malloc(100);

(2)指针p被free或者delete之后,没有置为NULL,让人误以为p是个合法的指针。参见7.5节。

(3)指针操作超越了变量的作用范围。这种情况让人防不胜防,示例程序如下:

class A

{

public:

void Func(void){ cout << “Func of
class A” << endl; }

};

void Test(void)

{

A *p;

{

A a;

p = &a; // 注意 a 的生命期

}

p->Func(); // p是“野指针”

}

函数Test在执行语句p->Func()时,对象a已经消失,而p是指向a的,所以p就成了“野指针”。但奇怪的是我运行这个程序时居然没有出错,这可能与编译器有关。

 

7.8 有了malloc/free为什么还要new/delete

malloc与free是C++/C语言的标准库函数,new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言,光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数,对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符,不在编译器控制权限之内,不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new,以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

我们先看一看malloc/free和new/delete如何实现对象的动态内存管理,见示例7-8。

class Obj

{

public :

Obj(void){ cout <<
“Initialization” << endl; }

~Obj(void){ cout << “Destroy”
<< endl; }

void Initialize(void){ cout <<
“Initialization” << endl; }

void Destroy(void){ cout <<
“Destroy” << endl; }

};

void UseMallocFree(void)

{

Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存

a->Initialize(); // 初始化

//…

a->Destroy(); // 清除工作

free(a); // 释放内存

}

void UseNewDelete(void)

{

Obj *a = new Obj; // 申请动态内存并且初始化

//…

delete a; // 清除并且释放内存

}

示例7-8 用malloc/free和new/delete如何实现对象的动态内存管理

类Obj的函数Initialize模拟了构造函数的功能,函数Destroy模拟了析构函数的功能。函数UseMallocFree中,由于malloc/free不能执行构造函数与析构函数,必须调用成员函数Initialize和Destroy来完成初始化与清除工作。函数UseNewDelete则简单得多。

所以我们不要企图用malloc/free来完成动态对象的内存管理,应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程,对它们而言malloc/free和new/delete是等价的。

既然new/delete的功能完全覆盖了malloc/free,为什么C++不把malloc/free淘汰出局呢?这是因为C++程序经常要调用C函数,而C程序只能用malloc/free管理动态内存。

如果用free释放“new创建的动态对象”,那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”,理论上讲程序不会出错,但是该程序的可读性很差。所以new/delete必须配对使用,malloc/free也一样。

 

7.9 内存耗尽怎么办?

如果在申请动态内存时找不到足够大的内存块,malloc和new将返回NULL指针,宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。

(1)判断指针是否为NULL,如果是则马上用return语句终止本函数。例如:

void Func(void)

{

A *a = new A;

if(a == NULL)

{

return;

}

}

(2)判断指针是否为NULL,如果是则马上用exit(1)终止整个程序的运行。例如:

void Func(void)

{

A *a = new A;

if(a == NULL)

{

cout << “Memory Exhausted”
<< endl;

exit(1);

}

}

(3)为new和malloc设置异常处理函数。例如Visual
C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数,也可以让malloc享用与new相同的异常处理函数。详细内容请参考C++使用手册。

 

上述(1)(2)方式使用最普遍。如果一个函数内有多处需要申请动态内存,那么方式(1)就显得力不从心(释放内存很麻烦),应该用方式(2)来处理。

很多人不忍心用exit(1),问:“不编写出错处理程序,让操作系统自己解决行不行?”

不行。如果发生“内存耗尽”这样的事情,一般说来应用程序已经无药可救。如果不用exit(1)
把坏程序杀死,它可能会害死操作系统。道理如同:如果不把歹徒击毙,歹徒在老死之前会犯下更多的罪。

有一个很重要的现象要告诉大家。对于32位以上的应用程序而言,无论怎样使用malloc与new,几乎不可能导致“内存耗尽”。我在Windows
98下用Visual
C++编写了测试程序,见示例7-9。这个程序会无休止地运行下去,根本不会终止。因为32位操作系统支持“虚存”,内存用完了,自动用硬盘空间顶替。我只听到硬盘嘎吱嘎吱地响,Window
98已经累得对键盘、鼠标毫无反应。

我可以得出这么一个结论:对于32位以上的应用程序,“内存耗尽”错误处理程序毫无用处。这下可把Unix和Windows程序员们乐坏了:反正错误处理程序不起作用,我就不写了,省了很多麻烦。

我不想误导读者,必须强调:不加错误处理将导致程序的质量很差,千万不可因小失大。

void main(void)

{

float *p = NULL;

while(TRUE)

{

p = new float[1000000];

cout << “eat memory”
<< endl;

if(p==NULL)

exit(1);

}

}

示例7-9试图耗尽操作系统的内存

 

7.10 malloc/free
的使用要点

函数malloc的原型如下:

void * malloc(size_t size);

用malloc申请一块长度为length的整数类型的内存,程序如下:

int *p = (int *) malloc(sizeof(int) * length);

我们应当把注意力集中在两个要素上:“类型转换”和“sizeof”。

◆malloc返回值的类型是void *,所以在调用malloc时要显式地进行类型转换,将void *
转换成所需要的指针类型。

◆malloc函数本身并不识别要申请的内存是什么类型,它只关心内存的总字节数。我们通常记不住int,
float等数据类型的变量的确切字节数。例如int变量在16位系统下是2个字节,在32位下是4个字节;而float变量在16位系统下是4个字节,在32位下也是4个字节。最好用以下程序作一次测试:

cout << sizeof(char)
<< endl;

cout << sizeof(int)
<< endl;

cout << sizeof(unsigned int)
<< endl;

cout << sizeof(long)
<< endl;

cout << sizeof(unsigned long)
<< endl;

cout << sizeof(float)
<< endl;

cout << sizeof(double)
<< endl;

cout << sizeof(void *)
<< endl;

在malloc的“()”中使用sizeof运算符是良好的风格,但要当心有时我们会昏了头,写出 p =
malloc(sizeof(p))这样的程序来。

◆函数free的原型如下:

void free( void * memblock );

为什么free函数不象malloc函数那样复杂呢?这是因为指针p的类型以及它所指的内存的容量事先都是知道的,语句free(p)能正确地释放内存。如果p是NULL指针,那么free对p无论操作多少次都不会出问题。如果p不是NULL指针,那么free对p连续操作两次就会导致程序运行错误。

 

7.11 new/delete 的使用要点

运算符new使用起来要比函数malloc简单得多,例如:

int *p1 = (int *)malloc(sizeof(int) * length);

int *p2 = new int[length];

这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言,new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数,那么new的语句也可以有多种形式。例如

class Obj

{

public :

Obj(void); // 无参数的构造函数

Obj(int x); // 带一个参数的构造函数

}

void Test(void)

{

Obj *a = new Obj;

Obj *b = new Obj(1); // 初值为1

delete a;

delete b;

}

如果用new创建对象数组,那么只能使用对象的无参数构造函数。例如

Obj *objects = new Obj[100]; // 创建100个动态对象

不能写成

Obj *objects = new Obj[100](1);// 创建100个动态对象的同时赋初值1

在用delete释放对象数组时,留意不要丢了符号‘[]’。例如

delete []objects; // 正确的用法

delete objects; // 错误的用法

后者相当于delete objects[0],漏掉了另外99个对象。

 

7.12 一些心得体会

我认识不少技术不错的C++/C程序员,很少有人能拍拍胸脯说通晓指针与内存管理(包括我自己)。我最初学习C语言时特别怕指针,导致我开发第一个应用软件(约1万行C代码)时没有使用一个指针,全用数组来顶替指针,实在蠢笨得过分。躲避指针不是办法,后来我改写了这个软件,代码量缩小到原先的一半。

我的经验教训是:

(1)越是怕指针,就越要使用指针。不会正确使用指针,肯定算不上是合格的程序员。

(2)必须养成“使用调试器逐步跟踪程序”的习惯,只有这样才能发现问题的本质。

高质量C++教程 — 第2章 程序的版式

高质量C++教程 -- 第2章 程序的版式
来源:www.vcworld.net 

版式虽然不会影响程序的功能,但会影响可读性。程序的版式追求清晰、美观,是程序风格的重要构成因素。

可以把程序的版式比喻为“书法”。好的“书法”可让人对程序一目了然,看得兴致勃勃。差的程序“书法”如螃蟹爬行,让人看得索然无味,更令维护者烦恼有加。请程序员们学习程序的“书法”,弥补大学计算机教育的漏洞,实在很有必要。

 

2.1 空行

空行起着分隔程序段落的作用。空行得体(不过多也不过少)将使程序的布局更加清晰。空行不会浪费内存,虽然打印含有空行的程序是会多消耗一些纸张,但是值得。所以不要舍不得用空行。

 

●【规则2-1-1】在每个类声明之后、每个函数定义结束之后都要加空行。参见示例2-1(a)

●【规则2-1-2】在一个函数体内,逻揖上密切相关的语句之间不加空行,其它地方应加空行分隔。参见示例2-1(b )

// 空行

void Function1(…)

{

}

// 空行

void Function2(…)

{

}

// 空行

void Function3(…)

{

}

// 空行

while (condition)

{

statement1;

// 空行

if (condition)

{

statement2;

}

else

{

statement3;

}

// 空行

statement4;

}

示例2-1(a)
函数之间的空行      
示例2-1(b) 函数内部的空行

 

2.2 代码行

●【规则2-2-1】一行代码只做一件事情,如只定义一个变量,或只写一条语句。这样的代码容易阅读,并且方便于写注释。

●【规则2-2-2】if、for、while、do等语句自占一行,执行语句不得紧跟其后。不论执行语句有多少都要加{}。这样可以防止书写失误。

int width; // 宽度

int height; // 高度

int depth; // 深度

int width, height, depth; // 宽度高度深度

x = a + b;

y = c + d;

z = e + f;

X = a + b; y = c + d; z = e + f;

if (width < height)

{

dosomething();

}

if (width < height) dosomething();

for (initialization; condition; update)

{

dosomething();

}

// 空行

other();

for (initialization; condition; update)

dosomething();

other();

示例2-2(a)
风格良好的代码行        
示例2-2(b) 风格不良的代码行

 

●【建议2-2-1】尽可能在定义变量的同时初始化该变量(就近原则)

如果变量的引用处和其定义处相隔比较远,变量的初始化很容易被忘记。如果引用了未被初始化的变量,可能会导致程序错误。本建议可以减少隐患。例如

int width = 10; // 定义并初绐化width

int height = 10; // 定义并初绐化height

int depth = 10; // 定义并初绐化depth

 

 

2.3 代码行内的空格

●【规则2-3-1】关键字之后要留空格。象const、virtual、inline、case
等关键字之后至少要留一个空格,否则无法辨析关键字。象if、for、while等关键字之后应留一个空格再跟左括号‘(’,以突出关键字。

●【规则2-3-2】函数名之后不要留空格,紧跟左括号‘(’,以与关键字区别。

●【规则2-3-3】‘(’向后紧跟,‘)’、‘,’、‘;’向前紧跟,紧跟处不留空格。

●【规则2-3-4】‘,’之后要留空格,如Function(x, y,
z)。如果‘;’不是一行的结束符号,其后要留空格,如for (initialization; condition;
update)。

●【规则2-3-5】赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符,如“=”、“+=”
“>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”,“^”等二元操作符的前后应当加空格。

●【规则2-3-6】一元操作符如“!”、“~”、“++”、“--”、“&”(地址运算符)等前后不加空格。

●【规则2-3-7】象“[]”、“.”、“->”这类操作符前后不加空格。

●【建议2-3-1】对于表达式比较长的for语句和if语句,为了紧凑起见可以适当地去掉一些空格,如for (i=0;
i<10; i++)和if ((a<=b)
&& (c<=d))

void Func1(int x, int y, int z); // 良好的风格

void Func1 (int x,int y,int z); // 不良的风格

if (year >= 2000) // 良好的风格

if(year>=2000) // 不良的风格

if ((a>=b) &&
(c<=d)) // 良好的风格

if(a>=b&&c<=d)
// 不良的风格

for (i=0; i<10; i++) // 良好的风格

for(i=0;i<10;i++) // 不良的风格

for (i = 0; I < 10; i ++) // 过多的空格

x = a < b ? a : b; // 良好的风格

x=a
<>

int *x = &y; // 良好的风格

int * x = & y; // 不良的风格

array[5] = 0; // 不要写成 array [ 5 ] = 0;

a.Function(); // 不要写成 a . Function();

b->Function(); // 不要写成 b ->
Function();

示例2-3 代码行内的空格

 

2.4 对齐

●【规则2-4-1】程序的分界符‘{’和‘}’应独占一行并且位于同一列,同时与引用它们的语句左对齐。

●【规则2-4-2】{ }之内的代码块在‘{’右边数格处左对齐。

void Function(int x)

{

… // program code

}

void Function(int x){

… // program code

}

if (condition)

{

… // program code

}

else

{

… // program code

}

if (condition){

… // program code

}

else {

… // program code

}

for (initialization; condition; update)

{

… // program code

}

for (initialization; condition; update){

… // program code

}

While (condition)

{

… // program code

}

while (condition){

… // program code

}

如果出现嵌套的{},则使用缩进对齐,如:

{

    …

    {

        …

    }

    …

}

 

示例2-4(a)
风格良好的对齐        
示例2-4(b) 风格不良的对齐

 

2.5 长行拆分

●【规则2-5-1】代码行最大长度宜控制在70至80个字符以内。代码行不要过长,否则眼睛看不过来,也不便于打印。

●【规则2-5-2】长表达式要在低优先级操作符处拆分成新行,操作符放在新行之首(以便突出操作符)。拆分出的新行要进行适当的缩进,使排版整齐,语句可读。

if ((very_longer_variable1 >=
very_longer_variable12)

     &&
(very_longer_variable3 <=
very_longer_variable14)

     &&
(very_longer_variable5 <=
very_longer_variable16))

{

     dosomething();

}

virtual CMatrix CMultiplyMatrix (CMatrix leftMatrix,

                                 CMatrix
rightMatrix);

for (very_longer_initialization;

     very_longer_condition;

     very_longer_update)

{

     dosomething();

}

示例2-5 长行的拆分

 

2.6 修饰符的位置

修饰符 * 和 & 应该靠近数据类型还是该靠近变量名,是个有争议的活题。

若将修饰符 * 靠近数据类型,例如:int* x; 从语义上讲此写法比较直观,即x是int 类型的指针。

上述写法的弊端是容易引起误解,例如:int* x, y;
此处y容易被误解为指针变量。虽然将x和y分行定义可以避免误解,但并不是人人都愿意这样做。

 

●【规则2-6-1】应当将修饰符 * 和 & 紧靠变量名

例如:

char *name;

int *x, y; // 此处y不会被误解为指针

 

2.7 注释

C语言的注释符为“”。C++语言中,程序块的注释常采用“”,行注释一般采用“//…”。注释通常用于:

(1)版本、版权声明;

(2)函数接口说明;

(3)重要的代码行或段落提示。

虽然注释有助于理解代码,但注意不可过多地使用注释。参见示例2-6。

 

●【规则2-7-1】注释是对代码的“提示”,而不是文档。程序中的注释不可喧宾夺主,注释太多了会让人眼花缭乱。注释的花样要少。

●【规则2-7-2】如果代码本来就是清楚的,则不必加注释。否则多此一举,令人厌烦。例如

i++; // i 加 1,多余的注释

●【规则2-7-3】边写代码边注释,修改代码同时修改相应的注释,以保证注释与代码的一致性。不再有用的注释要删除。

●【规则2-7-4】注释应当准确、易懂,防止注释有二义性。错误的注释不但无益反而有害。

●【规则2-7-5】尽量避免在注释中使用缩写,特别是不常用缩写。

●【规则2-7-6】注释的位置应与被描述的代码相邻,可以放在代码的上方或右方,不可放在下方。

●【规则2-7-8】当代码比较长,特别是有多重嵌套时,应当在一些段落的结束处加注释,便于阅读。

 

void Function(float x, float y, float z)

{

    …

}

if (…)

{

    …

    while
(…)

    {

        …

    }
// end of while

    …

} // end of if

示例2-6 程序的注释

 

2.8 类的版式

类可以将数据和函数封装在一起,其中函数表示了类的行为(或称服务)。类提供关键字public、protected和private,分别用于声明哪些数据和函数是公有的、受保护的或者是私有的。这样可以达到信息隐藏的目的,即让类仅仅公开必须要让外界知道的内容,而隐藏其它一切内容。我们不可以滥用类的封装功能,不要把它当成火锅,什么东西都往里扔。

类的版式主要有两种方式:

(1)将private类型的数据写在前面,而将public类型的函数写在后面,如示例8-3(a)。采用这种版式的程序员主张类的设计“以数据为中心”,重点关注类的内部结构。

(2)将public类型的函数写在前面,而将private类型的数据写在后面,如示例8.3(b)采用这种版式的程序员主张类的设计“以行为为中心”,重点关注的是类应该提供什么样的接口(或服务)。

很多C++教课书受到Biarne
Stroustrup第一本著作的影响,不知不觉地采用了“以数据为中心”的书写方式,并不见得有多少道理。

我建议读者采用“以行为为中心”的书写方式,即首先考虑类应该提供什么样的函数。这是很多人的经验——“这样做不仅让自己在设计类时思路清晰,而且方便别人阅读。因为用户最关心的是接口,谁愿意先看到一堆私有数据成员!”

class A

{

private:

int i, j;

float x, y;

public:

void Func1(void);

void Func2(void);

}

class A

{

public:

void Func1(void);

void Func2(void);

private:

int i, j;

float x, y;

}

示例8.3(a) 以数据为中心版式
       示例8.3(b)
以行为为中心的版式

链表应用

#include "stdio.h"  
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
#define M 50 
typedef struct
{
   char name[20];
   char
units[30]; 
   char
tele[10]; 
}ADDRESS;

int enter(ADDRESS t[]);
void list(ADDRESS t[],int n);
void search(ADDRESS t[],int n);
int delete(ADDRESS t[],int n);
int  add(ADDRESS t[],int n);
void save(ADDRESS t[],int n);
int load(ADDRESS t[]); 
void display(ADDRESS t[]);
void sort(ADDRESS t[],int n);
void qseek(ADDRESS t[],int n);
void copy(); 
void print(ADDRESS temp);
int find(ADDRESS t[],int n,char *s) ;
int menu_select(); 

main()
{
   int i;
   ADDRESS
adr[M]; 
   int
length; 
  
clrscr(); 
   for(;;)
   {
     
switch(menu_select())  
     
{
    
case 0:length=enter(adr);break;
    
case 1:list(adr,length);break;
    
case 2:search(adr,length);break;
    
case 3:length=delete(adr,length);break;
    
case 4:length=add(adr,length); 
break;  
    
case 5:save(adr,length);break;
    
case 6:length=load(adr); break;
    
case 7:display(adr);break; 
    
case 8:sort(adr,length);break;
    
case 9:qseek(adr,length);break;
    
case 10:copy();break;
    
case 11:exit(0);
     
}
   }
}

menu_select()
{
   char s[80];
   int c;
   gotoxy(1,25);
   printf("press any key enter
menu......\n");
   getch();
   clrscr();
   gotoxy(1,1);
  
printf("********************MENU*********************\n\n");
  
printf("    
0. Enter record\n");
  
printf("    
1. List the file\n");
  
printf("    
2. Search record on name\n");
  
printf("    
3. Delete a record\n");
  
printf("    
4. add record \n");
  
printf("    
5. Save the file\n");
  
printf("    
6. Load the file\n");
  
printf("    
7. display record on order\n");
  
printf("        
8. sort to make new file\n");
  
printf("        
9. Quick seek record\n");
  
printf("    
10. copy the file to new file\n");
  
printf("        
11. Quit\n");
  
printf("***********************************************\n");
   do{
     
printf("\n    
Enter you choice(0~11):");
     
scanf("%s",s);
     
c=atoi(s);
  
}while(c<0||c>11);
   return c;
}

int  enter(ADDRESS t[])
{
   int i,n;
   char *s;
   clrscr();
   printf("\nplease input num
\n");
  
scanf("%d",&n);
   printf("please input record
\n");
  
printf("name            
unit                    
telephone\n");
  
printf("------------------------------------------------\n");
  
for(i=0;i<n;i++)
   {
     
scanf("%s%s%s",t[i].name,t[i].units,t[i].tele); 

     
printf("----------------------------------------------\n");
   }
   return
n; 
}

void list(ADDRESS t[],int n)
{
   int i;
   clrscr();
  
printf("\n\n*******************ADDRESS******************\n");
  
printf("name              
unit                    
telephone\n");
  
printf("------------------------------------------------\n");
  
for(i=0;i<n;i++)
  
printf("%-20s%-30s%-10s\n",t[i].name,t[i].units,t[i].tele);
  
if((i+1)%10==0)  
   {
     
printf("Press any key continue...\n");
     
getch(); 
   }
  
printf("************************end*******************\n");
}

void search(ADDRESS t[],int n)
{
   char
s[20];  
   int
i;  
  
clrscr();  
   printf("please search
name\n");
   scanf("%s",s);
   i=find(t,n,s);
  
if(i>n-1) 
     
printf("not found\n");
   else
     
print(t[i]); 
}

void print(ADDRESS temp)
{
   clrscr();
  
printf("\n\n********************************************\n");
  
printf("name               
unit                     
telephone\n");
  
printf("------------------------------------------------\n");
  
printf("%-20s%-30s%-10s\n",temp.name,temp.units,temp.tele);
  
printf("**********************end***********************\n");
}

int find(ADDRESS t[],int n,char *s)
{
   int i;
  
for(i=0;i<n;i++)
   {
     
if(strcmp(s,t[i].name)==0) 
     
return i;  
   }
   return
i; 
}

int delete(ADDRESS t[],int n)
{
   char
s[20]; 
   int ch=0;
   int i,j;
   printf("please deleted
name\n");
   scanf("%s",s);
   i=find(t,n,s);
  
if(i>n-1) 
     
printf("no found not deleted\n");
   else
   {
     
print(t[i]);
     
printf("Are you sure delete it(1/0)\n"); 
     
scanf("%d",&ch); 
     
if(ch==1) 
     
{
    
for(j=i+1;j<n;j++) 
    
{
       
strcpy(t[j-1].name,t[j].name);
       
strcpy(t[j-1].units,t[j].units);
       
strcpy(t[j-1].tele,t[j].tele);
    
}
    
n--; 
     
}
   }
   return
n; 
}

int add(ADDRESS t[],int n)
{
   ADDRESS
temp; 
   int i,j;
   char s[20];
   printf("please input
record\n");
  
printf("************************************************\n");
  
printf("name               
unit                     
telephone\n");
  
printf("--------------------------------------------------\n");

  
scanf("%s%s%s",temp.name,temp.units,temp.tele);
  
printf("------------------------------------------------\n");
   printf("please input locate
name \n");
   scanf("%s",s);
  
i=find(t,n,s); 
  
for(j=n-1;j>=i;j--)  

   {
     
strcpy(t[j+1].name,t[j].name);
     
strcpy(t[j+1].units,t[j].units);
     
strcpy(t[j+1].tele,t[j].tele);
   }
  
strcpy(t[i].name,temp.name);
  
strcpy(t[i].units,temp.units);
  
strcpy(t[i].tele,temp.tele);
  
n++;  
   return n;
}

void save(ADDRESS t[],int n)
{
   int i;
   FILE
*fp; 
  
if((fp=fopen("record.txt","wb"))==NULL) 
   {
     
printf("can not open file\n");
     
exit(1); 
   }
   printf("\nSaving
file\n");
  
fprintf(fp,"%d",n); 
  
fprintf(fp,"\r\n"); 
  
for(i=0;i<n;i++)
   {
     
fprintf(fp,"%-20s%-30s%-10s",t[i].name,t[i].units,t[i].tele);
     
fprintf(fp,"\r\n");
   }
   fclose(fp);
   printf("****save
success***\n");
}

int load(ADDRESS t[])
{
   int i,n;
   FILE *fp;
  
if((fp=fopen("record.txt","rb"))==NULL)
   {
     
printf("can not open file\n"); 
     
exit(1); 
   }
  
fscanf(fp,"%d",&n);
  
for(i=0;i<n;i++)
     
fscanf(fp,"%20s%30s%10s",t[i].name,t[i].units,t[i].tele);
  
fclose(fp); 
   printf("You have success read
data from file!!!\n");
   return n;
}

void display(ADDRESS t[])
{
   int id,n;
   FILE *fp;
  
if((fp=fopen("record.txt","rb"))==NULL)
   {
     
printf("can not open file\n");
     
exit(1); 
   }
   printf("Enter order
number...\n");
  
scanf("%d",&id); 
  
fscanf(fp,"%d",&n);
  
if(id>=0&&id<n)

   {
     
fseek(fp,(id-1)*sizeof(ADDRESS),1);
     
print(t[id]);
     
printf("\r\n");
   }
   else
     
printf("no %d number record!!!\n ",id);
  
fclose(fp); 
}

void sort(ADDRESS t[],int n)
{
   int i,j,flag;
   ADDRESS temp;
  
for(i=0;i<n;i++)
   {
     
flag=0; 
     
for(j=0;j<n-1;j++)
     
if((strcmp(t[j].name,t[j+1].name))>0)
     
{
    
flag=1;
    
strcpy(temp.name,t[j].name); 
    
strcpy(temp.units,t[j].units);
    
strcpy(temp.tele,t[j].tele);
    
strcpy(t[j].name,t[j+1].name);
    
strcpy(t[j].units,t[j+1].units);
    
strcpy(t[j].tele,t[j+1].tele);
    
strcpy(t[j+1].name,temp.name);
    
strcpy(t[j+1].units,temp.units);
    
strcpy(t[j+1].tele,temp.tele);
     
}
     
if(flag==0)break; 
   }
   printf("sort
sucess!!!\n");
}

void qseek(ADDRESS t[],int n)
{
   char s[20];
   int l,r,m;
  
printf("\nPlease  sort before qseek!\n");
   printf("please
enter  name for qseek\n");
   scanf("%s",s);
  
l=0;r=n-1; 
  
while(l<=r)
   {
     
m=(l+r)/2;
     
if(strcmp(t[m].name,s)==0)
     
{
    
print(t[m]);
    
return ;
     
}
     
if(strcmp(t[m].name,s)<0) 
    
l=m+1; 
     
else
    
r=m-1;
   }
  
if(l>r)  
     
printf("not found\n");
}

void copy()
{
   char outfile[20];
   int i,n;
   ADDRESS
temp[M]; 
   FILE *sfp,*tfp;
   clrscr();
  
if((sfp=fopen("record.txt","rb"))==NULL)
   {
     
printf("can not open file\n");
     
exit(1);
   }
   printf("Enter outfile name,for
example c:\\f1\\te.txt:\n");
   scanf("%s",outfile);
  
if((tfp=fopen(outfile,"wb"))==NULL)
   {
     
printf("can not open file\n");
     
exit(1);
   }
  
fscanf(sfp,"%d",&n);
   fprintf(tfp,"%d",n);
   fprintf(tfp,"\r\n");
  
for(i=0;i<n;i++)
   {
     
fscanf(sfp,"%20s%30s%10s\n",temp[i].name,temp[i].units,
   
temp[i].tele);
     
fprintf(tfp,"%-20s%-30s%-10s\n",temp[i].name,
   
temp[i].units,temp[i].tele);
     
fprintf(tfp,"\r\n");
   }
   fclose(sfp);
   fclose(tfp);
   printf("you have success
copy  file!!!\n");
}