关于Symbian识别移动、联通和其它运营商网络的方法

自从Symbian OS在EKA2提供了强大的CTelephony，这之后很多跟网络相关的参数都通过这个获取，像识别目前手机是注册的是移动还是联通等信息网络上传的比较多的也是通过该方法，特别是啸天兄在nokia论坛分享了代码之后，网络上大多采用其代码，当然也包括我这样的懒人在内，而且往往很多人都没有注意最关键的原理即“国际移动用户识别码（IMSI：International Mobile Subscriber Identification Number）是区别移动用户的标志，储存在SIM卡中，可用于区别移动用户的有效信息。IMSI由MCC、MNC、MSIN组成，其中MCC为移动国家号码，由3位数字组成，唯一地识别移动客户所属的国家，我国为460；MNC为网络id，由2位数字组成，用于识别移动客户所归属的移动网络，中国移动为00，中国联通为01；MSIN为移动客户识别码，采用等长11位数字构成”。具体详见http://wiki.forum.nokia.com/index.php/%E5%8C%BA%E5%88%86%E5%BD%93%E5%89%8D%E7%94%A8%E6%88%B7SIM%E5%8D%A1%E6%98%AF%E7%A7%BB%E5%8A%A8%E8%BF%98%E6%98%AF%E8%81%94%E9%80%9A

最近在使用该代码时，发现假如当手机处于离线状态下，则不论有无插SIM卡，使用啸天兄的方法，就识别不出来了，这个应该跟CTelephony的实现有关，本人试着通过其源码去了解了，但是貌似跟踪到底层没有完全公开，或者说个人看源码能力还太弱了些。由于采用啸天兄方法实现不了了，所以只能从上面的红头文件（即红体字）寻找解决方法，虽然CTelephony::GetCurrentNetworkInfo在离线模式下失效，但是CTelephony::GetSubscriberId仍然可用，为此我们就可以通过直接分析IMSI来实现对运营商网络的识别，至于MNC的信息，大家可以查询http://en.wikipedia.org/wiki/Mobile_network_code，在国内的情况如下截图：

既然知道了如上信息，我们就可以简单的对IMSI号进行分析了，小可对啸天兄的代码进行简单修改，当然该代码也是使用CTelephony，只能使用在EKA2平台上，EKA1可以采用RMobilePhone::GetSubscriberId的方法来获取IMSI，在这里也就不做展开了，具体代码如下：

头文件

/*

 * TelephonyAO.h

 *

 *  Created on: 2010-4-22

 *      Author: frank

 */

#ifndef TELEPHONYAO_H_

#define TELEPHONYAO_H_

#include <e32base.h>

#include <Etel3rdParty.h>

typedef enum

{

       ENetWorkUnKnow,

       ENetWorkCM,

       ENetWorkUN,

       ENetWorkTC,

       ENetWorkTT,

}TNetWorkType;

class CTelephonyAO : public CActive

{

public:

       static CTelephonyAO* NewL();

       TNetWorkType GetNetWorkId();

public:

       ~CTelephonyAO();

protected:

       void DoCancel();

       void RunL();

private:

       CTelephonyAO();

       void ConstructL();

       void GetNetWorkInfo();

private:

       CActiveSchedulerWait*                iActiveSchedulerWait;

       CTelephony*                        pTelephony_;

       CTelephony::TSubscriberIdV1             iSubscribId;

       CTelephony::TSubscriberIdV1Pckg     iSubscriberIdPckg;

};

#endif /* TELEPHONYAO_H_ */

实现文件

/*

 * TelephonyAO.cpp

 *

 *  Created on: 2010-4-22

 *      Author: frank

 */

#include "TelephonyAO.h"

CTelephonyAO::CTelephonyAO() : CActive(EPriorityStandard), iSubscriberIdPckg(iSubscribId)

{

}

CTelephonyAO::~CTelephonyAO()

{

       delete pTelephony_;

       pTelephony_ = NULL;

       delete iActiveSchedulerWait;

       iActiveSchedulerWait = NULL;

}

void CTelephonyAO::ConstructL()

{

       pTelephony_ = CTelephony::NewL();

       iActiveSchedulerWait = new (ELeave)CActiveSchedulerWait;

       CActiveScheduler::Add(this);

}

CTelephonyAO* CTelephonyAO::NewL()

{

       CTelephonyAO* pSelf = new(ELeave) CTelephonyAO;

       CleanupStack::PushL(pSelf);

       pSelf->ConstructL();

       CleanupStack::Pop();

       return pSelf;

}

void CTelephonyAO::RunL()

{

       if (iActiveSchedulerWait->IsStarted())

       {

              iActiveSchedulerWait->AsyncStop();

       }

}

void CTelephonyAO::DoCancel()

{

       pTelephony_->CancelAsync(CTelephony::EGetSubscriberIdCancel);

       if (iActiveSchedulerWait->IsStarted())

       {

              iActiveSchedulerWait->AsyncStop();

       }

}

void CTelephonyAO::GetNetWorkInfo()

{

       Cancel();

       pTelephony_->GetSubscriberId(iStatus, iSubscriberIdPckg);

       SetActive();

       iActiveSchedulerWait->Start();

}

TNetWorkType CTelephonyAO::GetNetWorkId()

{

       GetNetWorkInfo();

       TNetWorkType vNetWorkType = ENetWorkUnKnow;

       if(iSubscribId.iSubscriberId.Length() < 15)

       {

              vNetWorkType = ENetWorkUnKnow;

       }

       else

       {

              TBuf<6> vHeader;

              vHeader.Copy(iSubscribId.iSubscriberId.Left(5));

              TBuf<3> vPtrTemp;

              vPtrTemp.Copy(vHeader.Right(2));

              TInt vNetWorkId = 0;

              TLex vLex(vPtrTemp);

              vLex.Val(vNetWorkId);

              if((vNetWorkId == 1) ||(vNetWorkId == 6))

              {

                     vNetWorkType = ENetWorkUN;

              }

              else if((vNetWorkId == 0) ||(vNetWorkId == 2))

              {

                     vNetWorkType = ENetWorkCM;

              }

              else if((vNetWorkId == 3) ||(vNetWorkId == 5))

              {

                     vNetWorkType = ENetWorkTC;

              }

              else if(vNetWorkId == 20)

              {

                     vNetWorkType = ENetWorkTT;

              }

              else

              {

                     vNetWorkType = ENetWorkUnKnow;

              }

       }

       return vNetWorkType;

}

至于如何调用，就可以通过如下简单获取了，不用再自己去比较了。

       CTelephonyAO* pTelephony = CTelephonyAO::NewL();

       CleanupStack::PushL(pTelephony);

       TNetWorkType vNetWorkType = pTelephony->GetNetWorkId();

       CleanupStack::PopAndDestroy(pTelephony);

好了，暂时小结如下吧，感谢啸天兄前人植树。

调用系统的浏览器来实现网页浏览可以根据系统浏览器的状态而决定调用的方法，例如当系统浏览器正在使用的时候可以用TApaTask::SendMessage ()方法；当系统浏览器没有被使用的时候可以用RapaLsSession::StartDocument() 方法。

下面是实现代码：

TBool CinternetAppUi::ConnectL(const TDesC& addr)

{

 const TInt KBrowserUid = 0x10008D39;

 TUid id( TUid::Uid( KBrowserUid ) );

 TApaTaskList taskList( CEikonEnv::Static()->WsSession() );

 TApaTask task = taskList.FindApp( id );

 // the system browser is in use

 if ( task.Exists() )

    {

    HBufC8* param8 = HBufC8::NewLC( addr.Length() );

    param8->Des().Append( addr );

    task.SendMessage( TUid::Uid( 0 ), *param8 ); // Uid is not used

    CleanupStack::PopAndDestroy();

    }

 // the system browser is not in use

else

 {

  RApaLsSession   appArcSession;

  User::LeaveIfError(appArcSession.Connect());    // connect to AppArc server

  TThreadId id;

  appArcSession.StartDocument( addr, TUid::Uid( KBrowserUid ), id );

  appArcSession.Close();

 }

 return ETrue;

}

//其中入口参数addr的格式是“4”+” <Space>“+”<Url>”，例如“4  www.google.com”。

其中采用以上方法不仅仅可以用于开启网页，还可以用于启动安装sis/sisx，具体示例代码如下：

RApaLsSession installSession;

TThreadId threadId;

TUid uid;

uid.iUid = 0x101F875A;

installSession.Connect();

installSession.StartDocument(aFileName, uid, threadId);

installSession.Close();

该代码自己没有亲测过，但是从理论上说应该可行，而且有大牛说uid都不用传进去。

另外播放音乐文件，网上也说可以通过该方法来实现，Uid分别如下：

0x102072c3 (from S60 3rd Edition onwards)

0x6c5b9d2 (S60 2nd Edition)

RapaLsSession::StartDocument()功能还是很强大的，在这里只做摘录，以后有机会再亲测，不过用其打开网页的确可行。

为什么要引入虚拟继承？

虚拟继承在一般的应用中很少用到，所以也往往被忽视，这也主要是因为在C++中，多重继承是不推荐的，也并不常用，而一旦离开了多重继承，虚拟继承就完全失去了存在的必要（因为这样只会降低效率和占用更多的空间，关于这一点，我自己还没有太多深刻的理解，有兴趣的可以看网络上白杨的作品《RTTI、虚函数和虚基类的开销分析及使用指导》，说实话我目前还没看得很明白，高人可以指点下我）。

以下面的一个例子为例：

#include <iostream.h>

#include <memory.h>

class CA

{

    int k; //如果基类没有数据成员，则在这里多重继承编译不会出现二义性

public:

    void f() {cout << "CA::f" << endl;}

};

class CB : public CA

{

};

class CC : public CA

{

};

class CD : public CB, public CC

{

};

void main()

{

    CD d;

    d.f();

}

当编译上述代码时，我们会收到如下的错误提示：

error C2385: 'CD::f' is ambiguous

即编译器无法确定你在d.f()中要调用的函数f到底是哪一个。这里可能会让人觉得有些奇怪，命名只定义了一个CA::f，既然大家都派生自CA，那自然就是调用的CA::f，为什么还无法确定呢？

这是因为编译器在进行编译的时候，需要确定子类的函数定义，如CA::f是确定的，那么在编译CB、CC时还需要在编译器的语法树中生成CB::f，CC::f等标识，那么，在编译CD的时候，由于CB、CC都有一个函数f，此时，编译器将试图生成这两个CD::f标识，显然这时就要报错了。（当我们不使用CD::f的时候，以上标识都不会生成，所以，如果去掉d.f()一句，程序将顺利通过编译）

要解决这个问题，有两个方法：

1、重载函数f()：此时由于我们明确定义了CD::f，编译器检查到CD::f()调用时就无需再像上面一样去逐级生成CD::f标识了；

|CB(CA)|

故此时的sizeof(CD) = 8;（CB、CC各有一个元素k）

2、使用虚拟继承：虚拟继承又称作共享继承，这种共享其实也是编译期间实现的，当使用虚拟继承时，上面的程序将变成下面的形式：

#include <iostream.h>

#include <memory.h>

class CA

{

    int k;

public:

    void f() {cout << "CA::f" << endl;}

};

class CB : virtual public CA  //也有一种写法是class CB : public virtual CA

{                       //实际上这两种方法都可以

};

class CC : virtual public CA

{

};

class CD : public CB, public CC

{

};

void main()

{

    CD d;

    d.f();

}

|CB|

|CC|

同时，在CB、CC中都分别包含了一个指向CA的虚基类指针列表vbptr（virtual base table pointer），其中记录的是从CB、CC的元素到CA的元素之间的偏移量。此时，不会生成各子类的函数f标识，除非子类重载了该函数，从而达到“共享”的目的（这里的具体内存布局，可以参看钻石型继承内存布局，在白杨的那篇文章中也有）。

也正因此，此时的sizeof(CD) = 12（两个vbptr + sizoef(int)）;

另注：

如果CB，CC中各定义一个int型变量，则sizeof(CD)就变成20(两个vbptr + 3个sizoef(int)

如果CA中添加一个virtual void f1(){}，sizeof(CD) = 16（两个vbptr + sizoef(int)+vptr）;

再添加virtual void f2(){}，sizeof(CD) = 16不变。原因如下所示：带有虚函数的类，其内存布局上包含一个指向虚函数列表的指针（vptr），这跟有几个虚函数无关。

以上内容涉及到类对象内存布局问题，本人还难以做过多展开，先贴这么多，本篇文章只是考虑对于虚拟继承进行入门，至于效率、应用等未作展开。本文在网上文章基础上修改了下而得此篇，原文载于http://blog.csdn.net/billdavid/archive/2004/06/23/24317.aspx

另外关于虚继承和虚基类的讨论，博客园有篇文章《虚继承与虚基类的本质》，总结得更为详细一点。

如何在C++中调用C的代码

以前曾经总结过一篇(http://www.cppblog.com/franksunny/archive/2007/11/29/37510.html)，关于在C中如何调用C++的代码，当时并未做完全的展开，只是简单的做了下调试，最近看到一个题目要求实现C和C++中代码的互相调用，其结果虽然都是通过extern “C”来实现，但是具体还是有些差别的。

先对C中调用C++代码作个简单回顾：

1、              对于C++中非类的成员函数，可以简单的在函数声明前面加extern “C”，通常函数声明位于头文件中，当然也可以将声明和函数定义一起放在cpp中，在没有声明的情况下，直接在定义前添加extern “C”也可

2、              对于C++类的成员函数，则需要另外做一个cpp文件，将需要调用的函数进行包装。

以上两项的实例参看前面C中如何调用C++代码的文章。

要实现C++中调用C的代码，具体操作：

对于C中的函数代码，要么将C代码的头文件进行修改，在其被含入C++代码时在声明中加入extern “C”或者在C++代码中重新声明一下C函数，重新声明时添加上extern “C”头。

通过以上的说明，我明白一点，那就是加extern “C”头一定是加在C++的代码文件中才能起作用的。

下面分析一下这个现象的实质原因：

C编译器编译函数时不带函数的类型信息，只包含函数符号名字，如C编译器把函数int a(float x)编译成类似_a这样的符号，C连接器只要找到了调用函数的符号，就可以连接成功，它假设参数类型信息是正确的，这是C编译连接器的缺点。而C++编译器为了实现函数重载，编译时会带上函数的类型信息，如他把上面的a函数可能编译成_a_float这样的符号为了实现重载，注意它还是没有带返回值得信息，这也是为什么C++不支持采用函数返回值来区别函数重载的原因之一，当然，函数的使用者对函数返回值的处理方式（如忽略）也是重要原因。

基于以上，C调用C++，首先需要用封装函数把对C++的类等的调用封装成C函数以便C调用，于是extern "C"的作用是：让编译器知道这件事，然后以C语言的方式编译和连接封装函数（通常是把封装函数用C++编译器按C++方式编译，用了extern "C" 后，编译器便依C的方式编译封装接口，当然接口函数里面的C++语法还是按C++方式编译；对于C语言部分--调用者，还是按C语言编译；分别对C++接口部分和C部分编译后，再连接就可以实现C调用C++了）。相反,C++调用C函数，extern "C" 的作用是：让C++连接器找调用函数的符号时采用C的方式，即使用_a而不是_a_float来找调用函数。

具体示例请见http://www.cppblog.com/Files/franksunny/CCallCpp.rar

注：如果你用VC6.0编译附件时遇到类似“fatal error C1010: unexpected end of file while looking for precompiled header directive”报错的话，请将bb.c文件做如下处理右键点击项目工程中的该文件，选择setting，在c/c++栏，选择PreCompiled headers，然后设置第一选项，选择不使用预编译头。

今天接到电话面试，被问到几个问题，汗颜之余，小结一下

1、      多态是如何实现绑定的

多态的绑定可以分为运行是多态和编译时多态

● 编译时的多态性

编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。

● 运行时的多态性

运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。

编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。

今天才正式弄清楚原来虚函数是可以实现运行时多态的，以前只知道虚函数可以使得基类对象的的方法调用派生类的方法。

2、      析构函数是虚函数的优点是什么

用C++开发的时候，用来做基类的类的析构函数一般都是虚函数。可是，为什么要这样做呢？下面用一个小例子来说明：

有下面的两个类：

class ClxBase

{

public:

    ClxBase() {};

    virtual ~ClxBase() {};

    virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };

};

class ClxDerived : public ClxBase

{

public:

    ClxDerived() {};

    ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };

    void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };

};

代码

ClxBase *pTest = new ClxDerived;

pTest->DoSomething();

delete pTest;

输出结果是：

Do something in class ClxDerived!

Output from the destructor of class ClxDerived!

这个很简单，非常好理解。

但是，如果把类ClxBase析构函数前的virtual去掉，那输出结果就是下面的样子了：

Do something in class ClxDerived!

也就是说，类ClxDerived的析构函数根本没有被调用！一般情况下类的析构函数里面都是释放内存资源，而析构函数不被调用的话就会造成内存泄漏。我想所有的C++程序员都知道这样的危险性。当然，如果在析构函数中做了其他工作的话，那你的所有努力也都是白费力气。

所以，文章开头的那个问题的答案就是－－这样做是为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。

当然，并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。所以，只有当一个类被用来作为基类的时候，才把析构函数写成虚函数。

说实话，这个也是今天才深刻认识到的。

当然还问到很多数据结构和算法方面（空间复杂度和时间复杂度之类的东东，说真的也是基础性的）的问题，至于那些东西，自己说实话抛开没用他们已经很长时间了，真可以说忘的差不多了，考这种真的很怕，也怪平时没怎么用到。不知道大家用的多不？

好久没有正式参加过面试了，今天突然来一次觉得自己基础还是不够扎实。

C中如何调用C++函数?

前阵子被问及一个在C中如何调用C++函数的问题，当时简单回答是将函数用extern "C"声明，当被问及如何将类内成员函数声明时，一时语塞，后来网上查了下，网上有一翻译C++之父的文章可以作为解答，遂拿来Mark一下。

将 C++ 函数声明为``extern "C"''（在你的 C++ 代码里做这个声明），然后调用它（在你的 C 或者 C++ 代码里调用）。例如：

// C++ code:

extern "C" void f(int);

void f(int i)

{

     // ...

}

然后，你可以这样使用 f()：

/* C code: */

void f(int);

void cc(int i)

{

    f(i);

   /* ... */

    }

当然，这招只适用于非成员函数。如果你想要在 C 里调用成员函数（包括虚函数），则需要提供一个简单的包装（wrapper）。例如：

// C++ code:

class C

{

       // ...

       virtual double f(int);

};

extern "C" double call_C_f(C* p, int i) // wrapper function

{

       return p->f(i);

}

然后，你就可以这样调用 C::f()：

/* C code: */

double call_C_f(struct C* p, int i);

void ccc(struct C* p, int i)

{

       double d = call_C_f(p,i);

       /* ... */

}

如果你想在 C 里调用重载函数，则必须提供不同名字的包装，这样才能被 C 代码调用。例如：

// C++ code:

void f(int);

void f(double);

extern "C" void f_i(int i) { f(i); }

extern "C" void f_d(double d) { f(d); }

然后，你可以这样使用每个重载的 f()：

/* C code: */

void f_i(int);

void f_d(double);

void cccc(int i,double d)

{

       f_i(i);

       f_d(d);

       /* ... */

}

注意，这些技巧也适用于在 C 里调用 C++ 类库，即使你不能（或者不想）修改 C++ 头文件。

 该翻译的文档Bjarne Stroustrup的原文链接地址是

http://www.research.att.com/~bs/bs_faq2.html#callCpp

本来贴出来以后受到很多C/C++朋友的关注，非常荣幸，在“梦在天涯”的提醒下，本人后来又完成了一个Demo工程，发现和BJ说的有点出入，希望有高手指点，Demo工程下载链接如下：http://www.cppblog.com/Files/franksunny/cCallCppDemo.rar

//根据结果也就是说，无符号符号数据是可以存储在有符号型变量内存中的,
//而且有例子在内存块长度一样时，不用强转，直接赋给无符号变量时也可行
//上述事实可以解释为内存块不变，采用不同的解码方式解出不同的数据
//但是读出来的时候要注意，如果有符号转无符号一定要强转
//之所以上例unsigned int输出-1，我并不是很清楚

Code

可重入函数与不可重入函数

主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误；而不可重入的函数由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的。

也可以这样理解，重入即表示重复进入，首先它意味着这个函数可以被中断，其次意味着它除了使用自己栈上的变量以外不依赖于任何环境（包括static），这样的函数就是purecode（纯代码）可重入，可以允许有该函数的多个副本在运行，由于它们使用的是分离的栈，所以不会互相干扰。如果确实需要访问全局变量（包括static），一定要注意实施互斥手段。可重入函数在并行运行环境中非常重要，但是一般要为访问全局变量付出一些性能代价。

编写可重入函数时，若使用全局变量，则应通过关中断、信号量（即P、V操作）等手段对其加以保护。

 说明：若对所使用的全局变量不加以保护，则此函数就不具有可重入性，即当多个进程调用此函数时，很有可能使有关全局变量变为不可知状态。

示例：假设Exam是int型全局变量，函数Squre_Exam返回Exam平方值。那么如下函数不具有可重入性。

unsigned int example( int para )

{

    unsigned int temp;
        Exam = para; // （**）
        temp = Square_Exam( );
        return temp;
    }
    此函数若被多个进程调用的话，其结果可能是未知的，因为当（**）语句刚执行完后，另外一个使用本函数的进程可能正好被激活，那么当新激活的进程执行到此函数时，将使Exam赋与另一个不同的para值，所以当控制重新回到“temp = Square_Exam( )”后，计算出的temp很可能不是预想中的结果。此函数应如下改进。

    unsigned int example( int para ) {
        unsigned int temp;
        [申请信号量操作] //(1)
        Exam = para;
        temp = Square_Exam( );
        [释放信号量操作]
        return temp;
    }
    (1)若申请不到“信号量”，说明另外的进程正处于给Exam赋值并计算其平方过程中（即正在使用此信号）,本进程必须等待其释放信号后，才可继续执行。若申请到信号，则可继续执行，但其它进程必须等待本进程释放信号量后，才能再使用本信号。

    保证函数的可重入性的方法：
    在写函数时候尽量使用局部变量（例如寄存器、堆栈中的变量），对于要使用的全局变量要加以保护（如采取关中断、信号量等方法），这样构成的函数就一定是一个可重入的函数。
    VxWorks中采取的可重入的技术有：
    * 动态堆栈变量（各子函数有自己独立的堆栈空间）
    * 受保护的全局变量和静态变量
    * 任务变量


--------------------------------------------------
    在实时系统的设计中，经常会出现多个任务调用同一个函数的情况。如果这个函数不幸被设计成为不可重入的函数的话，那么不同任务调用这个函数时可能修改其他任务调用这个函数的数据，从而导致不可预料的后果。那么什么是可重入函数呢？所谓可重入函数是指一个可以被多个任务调用的过程，任务在调用时不必担心数据是否会出错。不可重入函数在实时系统设计中被视为不安全函数。满足下列条件的函数多数是不可重入的：
    1) 函数体内使用了静态的数据结构；
    2) 函数体内调用了malloc()或者free()函数；
    3) 函数体内调用了标准I/O函数。

    下面举例加以说明。
    A. 可重入函数
    void strcpy(char *lpszDest, char *lpszSrc)

 {
        while(*lpszDest++=*lpszSrc++);
        *dest=0;
    }

    B. 不可重入函数1
    charcTemp;//全局变量
    void SwapChar1(char *lpcX, char *lpcY)

 {
        cTemp=*lpcX;
        *lpcX=*lpcY;
        lpcY=cTemp;//访问了全局变量
    }

    C. 不可重入函数2
    void SwapChar2(char *lpcX,char *lpcY)

 {
        static char cTemp;//静态局部变量
        cTemp=*lpcX;
        *lpcX=*lpcY;
        lpcY=cTemp;//使用了静态局部变量
    }

    问题1，如何编写可重入的函数？
    答：在函数体内不访问那些全局变量，不使用静态局部变量，坚持只使用局部变量，写出的函数就将是可重入的。如果必须访问全局变量，记住利用互斥信号量来保护全局变量。

    问题2，如何将一个不可重入的函数改写成可重入的函数？
    答：把一个不可重入函数变成可重入的唯一方法是用可重入规则来重写它。其实很简单，只要遵守了几条很容易理解的规则，那么写出来的函数就是可重入的。
    1) 不要使用全局变量。因为别的代码很可能覆盖这些变量值。
    2) 在和硬件发生交互的时候，切记执行类似disinterrupt()之类的操作，就是关闭硬件中断。完成交互记得打开中断，在有些系列上，这叫做“进入/退出核心”。
    3) 不能调用其它任何不可重入的函数。
    4) 谨慎使用堆栈。最好先在使用前先OS_ENTER_KERNAL。

    堆栈操作涉及内存分配，稍不留神就会造成益出导致覆盖其他任务的数据，所以，请谨慎使用堆栈！最好别用！很多黑客程序就利用了这一点以便系统执行非法代码从而轻松获得系统控制权。还有一些规则，总之，时刻记住一句话：保证中断是安全的！

    实例问题：曾经设计过如下一个函数，在代码检视的时候被提醒有bug，因为这个函数是不可重入的，为什么？
    unsigned int sum_int( unsigned int base )

{
        unsigned int index;
        static unsigned int sum = 0; // 注意，是static类型
        for (index = 1; index <= base; index++)
            sum += index;
        return sum;
    }

    分析：所谓的函数是可重入的（也可以说是可预测的），即只要输入数据相同就应产生相同的输出。这个函数之所以是不可预测的，就是因为函数中使用了static变量，因为static变量的特征，这样的函数被称为：带“内部存储器”功能的的函数。因此如果需要一个可重入的函数，一定要避免函数中使用static变量，这种函数中的static变量，使用原则是，能不用尽量不用。
    将上面的函数修改为可重入的函数，只要将声明sum变量中的static关键字去掉，变量sum即变为一个auto类型的变量，函数即变为一个可重入的函数。
    当然，有些时候，在函数中是必须要使用static变量的，比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

最近转去搞低层些的单片机程序编程，在一块msp430上要增加一个国际标准时间，由于以前在VC中都是拿来用的，没遇到问题，也就不会去深究。在单片机上想用标准C里面的time（time_t*）函数求得系统时间，最后结果出不来。后来才知道原来以前是取得的是操作系统的时间，汗死，单片机没系统的啊，希望能够尽早让我搞嵌入式啊，呵呵。

后来自己弄明白了，设个时间值，然后用单片机晶振累加计数，还是可以用time.h轻松实现标准时间计时的，而且方便不用考虑自己去写时间转换函数，以下是具体的time,h的讲解，我就不再展开了。

time.h从头学

本文从介绍基础概念入手，探讨了在C/C++中对日期和时间操作所用到的数据结构和函数，并对计时、时间的获取、时间的计算和显示格式等方面进行了阐述。本文还通过大量的实例向你展示了time.h头文件中声明的各种函数和数据结构的详细使用方法。  

关键字：UTC（世界标准时间），Calendar Time（日历时间），epoch（时间点），clock tick（时钟计时单元）  

1．  概念  

在C/C++中，对字符串的操作有很多值得注意的问题，同样，C/C++对时间的操作也有许多值得大家注意的地方。最近，在技术群中有很多网友也多次问到过C++语言中对时间的操作、获取和显示等等的问题。下面，在这篇文章中，笔者将主要介绍在C/C++中时间和日期的使用方法.  

通过学习许多C/C++库，你可以有很多操作、使用时间的方法。但在这之前你需要了解一些“时间”和“日期”的概念，主要有以下几个：  

Coordinated Universal Time（UTC）：协调世界时，又称为世界标准时间，也就是大家所熟知的格林威治标准时间（Greenwich Mean Time，GMT）。比如，中国内地的时间与UTC的时差为+8，也就是UTC+8。美国是UTC-5。 

Calendar Time：日历时间，是用“从一个标准时间点到此时的时间经过的秒数”来表示的时间。这个标准时间点对不同的编译器来说会有所不同，但对一个编译系统来说，这个标准时间点是不变的，该编译系统中的时间对应的日历时间都通过该标准时间点来衡量，所以可以说日历时间是“相对时间”，但是无论你在哪一个时区，在同一时刻对同一个标准时间点来说，日历时间都是一样的。

epoch：时间点。时间点在标准C/C++中是一个整数，它用此时的时间和标准时间点相差的秒数（即日历时间）来表示。

clock tick：时钟计时单元（而不把它叫做时钟滴答次数），一个时钟计时单元的时间长短是由CPU控制的。一个clock tick不是CPU的一个时钟周期，而是C/C++的一个基本计时单位。

我们可以使用ANSI标准库中的time.h头文件。这个头文件中定义的时间和日期所使用的方法，无论是在结构定义，还是命名，都具有明显的C语言风格。下面，我将说明在C/C++中怎样使用日期的时间功能。  

2． 计时  

C/C++中的计时函数是clock()，而与其相关的数据类型是clock_t。在MSDN中，查得对clock函数定义如下：  

clock_t clock( void );  

这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wal-clock）。其中clock_t是用来保存时间的数据类型，在time.h文件中，我们可以找到对它的定义：  

#ifndef _CLOCK_T_DEFINED  
typedef long clock_t;  
#define _CLOCK_T_DEFINED  
#endif  

很明显，clock_t是一个长整形数。在time.h文件中，还定义了一个常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元，其定义如下：

#define CLOCKS_PER_SEC ((clock_t)1000)

可以看到每过千分之一秒（1毫秒），调用clock（）函数返回的值就加1。下面举个例子，你可以使用公式clock()/CLOCKS_PER_SEC来计算一个进程自身的运行时间：

void elapsed_time()  
{  
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);  
}  

当然，你也可以用clock函数来计算你的机器运行一个循环或者处理其它事件到底花了多少时间：  

#include “stdio.h”  
#include “stdlib.h”  
#include “time.h”  

int main( void )  
{  
long i = 10000000L;  
clock_t start, finish;  
double duration;  
/* 测量一个事件持续的时间*/  
printf( "Time to do %ld empty loops is ", i );  
start = clock();  
while( i-- ) ;  
finish = clock();  
duration = (double)(finish - start) / CLOCKS_PER_SEC;  
printf( "%f seconds\n", duration );
system("pause");  
}  

在笔者的机器上，运行结果如下：

Time to do 10000000 empty loops is 0.03000 seconds

上面我们看到时钟计时单元的长度为1毫秒，那么计时的精度也为1毫秒，那么我们可不可以通过改变CLOCKS_PER_SEC的定义，通过把它定义的大一些，从而使计时精度更高呢？通过尝试，你会发现这样是不行的。在标准C/C++中，最小的计时单位是一毫秒。

3．与日期和时间相关的数据结构  

在标准C/C++中，我们可通过tm结构来获得日期和时间，tm结构在time.h中的定义如下：  

#ifndef _TM_DEFINED  
struct tm {  
int tm_sec; /* 秒 – 取值区间为[0,59] */  
int tm_min; /* 分 - 取值区间为[0,59] */  
int tm_hour; /* 时 - 取值区间为[0,23] */  
int tm_mday; /* 一个月中的日期 - 取值区间为[1,31] */  
int tm_mon; /* 月份（从一月开始，0代表一月） - 取值区间为[0,11] */  
int tm_year; /* 年份，其值等于实际年份减去1900 */  
int tm_wday; /* 星期 – 取值区间为[0,6]，其中0代表星期天，1代表星期一，以此类推 */  
int tm_yday; /* 从每年的1月1日开始的天数 – 取值区间为[0,365]，其中0代表1月1日，1代表1月2日，以此类推 */  
int tm_isdst; /* 夏令时标识符，实行夏令时的时候，tm_isdst为正。不实行夏令时的进候，tm_isdst为0；不了解情况时，tm_isdst()为负。*/  
};  
#define _TM_DEFINED  
#endif  

ANSI C标准称使用tm结构的这种时间表示为分解时间(broken-down time)。

而日历时间（Calendar Time）是通过time_t数据类型来表示的，用time_t表示的时间（日历时间）是从一个时间点（例如：1970年1月1日0时0分0秒）到此时的秒数。在time.h中，我们也可以看到time_t是一个长整型数：  

#ifndef _TIME_T_DEFINED  
typedef long time_t; /* 时间值 */  
#define _TIME_T_DEFINED /* 避免重复定义 time_t */  
#endif  

大家可能会产生疑问：既然time_t实际上是长整型，到未来的某一天，从一个时间点（一般是1970年1月1日0时0分0秒）到那时的秒数（即日历时间）超出了长整形所能表示的数的范围怎么办？对time_t数据类型的值来说，它所表示的时间不能晚于2038年1月18日19时14分07秒。为了能够表示更久远的时间，一些编译器厂商引入了64位甚至更长的整形数来保存日历时间。比如微软在Visual C++中采用了__time64_t数据类型来保存日历时间，并通过_time64()函数来获得日历时间（而不是通过使用32位字的time()函数），这样就可以通过该数据类型保存3001年1月1日0时0分0秒（不包括该时间点）之前的时间。  

在time.h头文件中，我们还可以看到一些函数，它们都是以time_t为参数类型或返回值类型的函数：

double difftime(time_t time1, time_t time0);  

time_t mktime(struct tm * timeptr); 

time_t time(time_t * timer); 

char * asctime(const struct tm * timeptr);

char * ctime(const time_t *timer); 

此外，time.h还提供了两种不同的函数将日历时间（一个用time_t表示的整数）转换为我们平时看到的把年月日时分秒分开显示的时间格式tm：

struct tm * gmtime(const time_t *timer); struct tm * localtime(const time_t * timer);

通过查阅MSDN，我们可以知道Microsoft C/C++ 7.0中时间点的值（time_t对象的值）是从1899年12月31日0时0分0秒到该时间点所经过的秒数，而其它各种版本的Microsoft C/C++和所有不同版本的Visual C++都是计算的从1970年1月1日0时0分0秒到该时间点所经过的秒数。  

4．与日期和时间相关的函数及应用

在本节，我将向大家展示怎样利用time.h中声明的函数对时间进行操作。这些操作包括取当前时间、计算时间间隔、以不同的形式显示时间等内容。  

4.1 获得日历时间

我们可以通过time()函数来获得日历时间（Calendar Time），其原型为：

time_t time(time_t * timer);

如果你已经声明了参数timer，你可以从参数timer返回现在的日历时间，同时也可以通过返回值返回现在的日历时间，即从一个时间点（例如：1970年1月1日0时0分0秒）到现在此时的秒数。如果参数为空（NUL），函数将只通过返回值返回现在的日历时间，比如下面这个例子用来显示当前的日历时间：

#include "time.h"  
#include "stdio.h"  
int main(void)  
{  
struct tm *ptr;  
time_t lt;  
lt =time(NUL);  
printf("The Calendar Time now is %d\n",lt);  
return 0;  
}  

运行的结果与当时的时间有关，我当时运行的结果是：  

The Calendar Time now is 1122707619  

其中1122707619就是我运行程序时的日历时间。即从1970年1月1日0时0分0秒到此时的秒数。  

4.2 获得日期和时间  

这里说的日期和时间就是我们平时所说的年、月、日、时、分、秒等信息。从第2节我们已经知道这些信息都保存在一个名为tm的结构体中，那么如何将一个日历时间保存为一个tm结构的对象呢？  

其中可以使用的函数是gmtime()和localtime()，这两个函数的原型为：  

struct tm * gmtime(const time_t *timer);  
struct tm * localtime(const time_t * timer);  

其中gmtime()函数是将日历时间转化为世界标准时间（即格林尼治时间），并返回一个tm结构体来保存这个时间，而localtime()函数是将日历时间转化为本地时间。比如现在用gmtime()函数获得的世界标准时间是2005年7月30日7点18分20秒，那么我用localtime()函数在中国地区获得的本地时间会比世界标准时间晚8个小时，即2005年7月30日15点18分20秒。下面是个例子：  

#include "time.h"  
#include "stdio.h"  
int main(void)  
{  
struct tm *local;  
time_t t;  
t=time(NUL);  
local=localtime(&t);  
printf("Local hour is: %d\n",local->tm_hour);  
local=gmtime(&t);  
printf("UTC hour is: %d\n",local->tm_hour);  
return 0;  
}  

运行结果是：  

Local hour is: 15  
UTC hour is: 7  

4.3 固定的时间格式  

我们可以通过asctime()函数和ctime()函数将时间以固定的格式显示出来，两者的返回值都是char*型的字符串。返回的时间格式为：  

星期几 月份日期 时:分:秒 年\n\0  
例如：Wed Jan 02 02:03:55 1980\n\0  

其中\n是一个换行符，\0是一个空字符，表示字符串结束。下面是两个函数的原型：  

char * asctime(const struct tm * timeptr);  
char * ctime(const time_t *timer);  

其中asctime()函数是通过tm结构来生成具有固定格式的保存时间信息的字符串，而ctime()是通过日历时间来生成时间字符串。这样的话，asctime（）函数只是把tm结构对象中的各个域填到时间字符串的相应位置就行了，而ctime（）函数需要先参照本地的时间设置，把日历时间转化为本地时间，然后再生成格式化后的字符串。在下面，如果t是一个非空的time_t变量的话，那么：  

printf(ctime(&t));  

等价于：  

struct tm *ptr;  
ptr=localtime(&t);  
printf(asctime(ptr));  

那么，下面这个程序的两条printf语句输出的结果就是不同的了（除非你将本地时区设为世界标准时间所在的时区）：  

#include "time.h"  
#include "stdio.h"  
int main(void)  
{  
struct tm *ptr;  
time_t lt;  
lt =time(NUL);  
ptr=gmtime(<);  
printf(asctime(ptr));  
printf(ctime(<));  
return 0;  
}  

运行结果：  

Sat Jul 30 08:43:03 2005  
Sat Jul 30 16:43:03 2005  

4.4 自定义时间格式  

我们可以使用strftime（）函数将时间格式化为我们想要的格式。它的原型如下：  

size_t strftime(  
char *strDest,  
size_t maxsize,  
const char *format,  
const struct tm *timeptr  
);
我们可以根据format指向字符串中格式命令把timeptr中保存的时间信息放在strDest指向的字符串中，最多向strDest中存放maxsize个字符。该函数返回向strDest指向的字符串中放置的字符数。  

函数strftime()的操作有些类似于sprintf()：识别以百分号(%)开始的格式命令集合，格式化输出结果放在一个字符串中。格式化命令说明串strDest中各种日期和时间信息的确切表示方法。格式串中的其他字符原样放进串中。格式命令列在下面，它们是区分大小写的。  

%a 星期几的简写  
%A 星期几的全称  
%b 月分的简写  
%B 月份的全称  
%c 标准的日期的时间串  
%C 年份的后两位数字  
%d 十进制表示的每月的第几天  
%D 月/天/年  
%e 在两字符域中，十进制表示的每月的第几天  
%F 年-月-日  
%g 年份的后两位数字，使用基于周的年  
%G 年分，使用基于周的年  
%h 简写的月份名  
%H 24小时制的小时  
%I 12小时制的小时  
%j 十进制表示的每年的第几天  
%m 十进制表示的月份  
%M 十时制表示的分钟数  
%n 新行符  
%p 本地的AM或PM的等价显示  
%r 12小时的时间  
%R 显示小时和分钟：hh:mm  
%S 十进制的秒数  
%t 水平制表符  
%T 显示时分秒：hh:mm:ss  
%u 每周的第几天，星期一为第一天 （值从0到6，星期一为0）  
%U 第年的第几周，把星期日做为第一天（值从0到53）  
%V 每年的第几周，使用基于周的年  
%w 十进制表示的星期几（值从0到6，星期天为0）  
%W 每年的第几周，把星期一做为第一天（值从0到53）  
%x 标准的日期串  
%X 标准的时间串  
%y 不带世纪的十进制年份（值从0到99）  
%Y 带世纪部分的十进制年份  
%z，%Z 时区名称，如果不能得到时区名称则返回空字符。  
%% 百分号  

如果想显示现在是几点了，并以12小时制显示，就象下面这段程序：  

#include “time.h”  
#include “stdio.h”  
int main(void)  
{  
struct tm *ptr;  
time_t lt;  
char str[80];  
lt=time(NUL);  
ptr=localtime(<);  
strftime(str,100,"It is now %I %p",ptr);  
printf(str);  
return 0;  
}  

其运行结果为：  
It is now 4PM  

而下面的程序则显示当前的完整日期：  

#include <stdio.h>  
#include <time.h>  

void main( void )  
{  
struct tm *newtime;  
char tmpbuf[128];  
time_t lt1;  
time( <1 );  
newtime=localtime(<1);  
strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);  
printf(tmpbuf);  
}  

运行结果：  

Today is Saturday, day 30 of July in the year 2005.  

4.5 计算持续时间的长度  

有时候在实际应用中要计算一个事件持续的时间长度，比如计算打字速度。在第1节计时部分中，我已经用clock函数举了一个例子。Clock()函数可以精确到毫秒级。同时，我们也可以使用difftime()函数，但它只能精确到秒。该函数的定义如下：  

double difftime(time_t time1, time_t time0);  

虽然该函数返回的以秒计算的时间间隔是double类型的，但这并不说明该时间具有同double一样的精确度，这是由它的参数觉得的（time_t是以秒为单位计算的）。比如下面一段程序：  

#include "time.h"  
#include "stdio.h"  
#include "stdlib.h"  
int main(void)  
{  
time_t start,end;  
start = time(NUL);  
system("pause");  
end = time(NUL);  
printf("The pause used %f seconds.\n",difftime(end,start));//<-  
system("pause");  
return 0;  
}  

运行结果为：  
请按任意键继续. . .  
The pause used 2.000000 seconds.  
请按任意键继续. . .  

可以想像，暂停的时间并不那么巧是整整2秒钟。其实，你将上面程序的带有“//<-”注释的一行用下面的一行代码替换：  

printf("The pause used %f seconds.\n",end-start);  

其运行结果是一样的。  

4.6 分解时间转化为日历时间  

这里说的分解时间就是以年、月、日、时、分、秒等分量保存的时间结构，在C/C++中是tm结构。我们可以使用mktime（）函数将用tm结构表示的时间转化为日历时间。其函数原型如下：  

time_t mktime(struct tm * timeptr);  

其返回值就是转化后的日历时间。这样我们就可以先制定一个分解时间，然后对这个时间进行操作了，下面的例子可以计算出1997年7月1日是星期几：  

#include "time.h"  
#include "stdio.h"  
#include "stdlib.h"  
int main(void)  
{  
struct tm t;  
time_t t_of_day;  
t.tm_year=1997-1900;  
t.tm_mon=6;  
t.tm_mday=1;  
t.tm_hour=0;  
t.tm_min=0;  
t.tm_sec=1;  
t.tm_isdst=0;  
t_of_day=mktime(&t);  
printf(ctime(&t_of_day));  
return 0;  
}  
运行结果：  
Tue Jul 01 00:00:01 1997  
现在注意了，有了mktime()函数，是不是我们可以操作现在之前的任何时间呢？你可以通过这种办法算出1945年8月15号是星期几吗？答案是否定的。因为这个时间在1970年1月1日之前，所以在大多数编译器中，这样的程序虽然可以编译通过，但运行时会异常终止。

由switch选择结构理解局部变量

函数体内部自定义变量，称为局部变量，存储于栈（stack）中，由编译器自动分配和释放，局部变量的生存期（或者说作用域）是当前函数内部，使用时必须初始化，否则其值将不定。以前对局部变量的定义也就是这么多，而且也就那么在用。近期碰到如下一个问题：

void func( void )

{

   int x = 2;

   switch ( x )

   {

         int m =0;       //initialization skipped by case0,case1,case2,default

   case 0 :

         int i = 0;        //initialization skipped by case1,case2,default

         { int j = 1; }   // OK, initialized in enclosing block

         break;

   case 1 :

         break;

   case 2:

         break;

   default:

         int k = 1;              // OK, initialization not skipped

   }

}

遇到这个问题，网上的解答很多，很多人觉得switch内不能定义局部变量，这个明显是不对的。因为我把代码改成以下形式后就完全可以用了。

void func( void )

{

   int x = 2;

   switch ( x )

   {

         int m;

         m = 0;                   //without execute;

   case 0:

         int i;

         i = 0;

         { int j = 1; }   // OK, initialized in enclosing block

         printf("%d    %d\n", m, i);

         break;

   case 1:

         i = 1;

         printf("%d    %d\n", m, i);

         break;

   case 2:

         i = 2;

         printf("%d    %d\n", m, i);

         break;

   default:

         int k = 1;              // OK, initialization not skipped

   }

}

编译时有一个warning，即“local variable 'm' used without having been initialized”，执行结果为：-858993460       2

因此switch内不但可以定义变量，而且也不用像很多人所说的在case内遇到要用变量时一定要用{}括起来，不过严格的说不用{}扩起来的变量是是属于整个switch块结构的，为此编程一定要将新增变量作用域限定在case内就必须要用{}。

通过switch···case结构，对局部变量的声明、定义以及初始化等概念可以有一个比较清晰的认识。我的理解就是：声明语句不管是放在哪里，其编译时都是将其置顶到块的头部，如int k虽然在default中，但是这个变量的声明就在switch的{}内，其生存期与变量m等同，只是由于前面没有声明，所以default之前不能用。

昨天去网讯（杭州）笔试了，做了下笔试题，感觉题目都不难，但是自己做的的确不怎么样，估计是没机会去了，不过暂时还是先把几道自己还记得的题目，写出来，总结下，以做复习。

1、  要求自己实现 String 类，给出了 String 类的以下头文件类声明

class String

{

public:

       String(const char *m_char = NULL);

       String(const String & Str);

       String& operator = (const String &Str);

       ~String();

private:

       char * m_Data;

};

关于 String 类的笔试题，以前看林锐的随笔时听说他在微软面试时曾碰到那么一道题目，我自己也没有真的下笔去做过，平常都是拿来就用的，这次自己碰到，才知道会死得那么惨，反正编得不堪入目（我就不拿出来献丑了），下面是我回来后，自己重新写的答案。

String::String(const char* m_char)

{

       int m_nLength = strlen(m_char) + 1;

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }// 以上判断是否必要 ??

       m_Data = new char[m_nLength];

       memcpy(m_Data, m_char, m_nLength);

}

String::String(const String &Str)

{

       int m_nLength = strlen(Str.m_Data) + 1;// 以前真的不知道，原来对象的私有变量

// 在类的实现代码中也是可以访问的

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }// 以上判断是否必要 ??

       m_Data = new char[m_nLength];

       memcpy(m_Data, Str.m_Data, m_nLength);

}

String& String::operator = (const String& Str) 

{

       if(this == &Str)

              return *this;

       int m_nLength = strlen(Str.m_Data) + 1;

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }// 以上判断是否必要 ??

       m_Data = new char[m_nLength];

       memcpy(m_Data, Str.m_Data, m_nLength);

       return *this;

}

String::~String()

{

       if (m_Data != NULL)

       {

              delete [] m_Data;

              m_Data = NULL;

       }

}

2、  关于内存分配

这个题目很简单，就给了一个函数，然后问函数内的局部变量存放在哪里，我也不知道为什么当时会选择 heap( 堆 ) ，下面再把几个概念罗列出来：

1.            堆区（ heap ）：由程序员申请分配和释放，属动态内存分配方式，若程序员不释放，程序结束时可能会由 OS 回收。不过这个内存分配很容易引起问题，如果申请的内存不释放就会造成内存泄漏；如果释放的不是所要释放的内存，则轻者引起程序运行结果出错，重者系统崩溃。

2.            栈区（ stack ）：编译器自动分配释放，存放函数的形参值、局部变量的值，也是属于动态内存分配方式，它由系统分配，所以执行效率也高，不过自由度小，声明时就得决定其具体大小。

3.            全局区（静态区）（ static ）：全局变量和静态变量的存储是放在一块的，而且初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放，所以也不会造成内存问题。

除了以上的变量外，还有两类存放位置，文字常量区和程序代码区，两者都是由系统分配和释放，且文字常量区和前面三区合成为程序数据区，与程序代码区相对应。

3、  关于类继承的构造和析构函数

class Base

{

public:

       Base(){cout<< "Base" <<endl;};

       ~Base(){cout<<"~Base"<<endl;};

protected:

private:

};

class First:public Base

{

public:

       First(){cout << "First" << endl;};

       ~First(){cout << "~First" <<endl;};

};

int main()

{

       Base *a = new First;

       delete a;

}

问程序的输出会是什么？

结果很简单，也就是 Base

                               First

                   ~Base

其它还有一个关于 & 的题目，把我搞的云里雾里的，还要再看些东西才知道怎么来解释。