水草

mac osx 使用goagent，在chrome下访问google，不是私密连接的问题

2014-12-27T00:00:00+00:00

解决办法

确认已经安装好goagent

确认 chrome 39

访问 google 网站会出现提示不是私密连接的问题。

解决办法: 1.删除goagent local目录下的 CA.crt 文件，和 certs 文件夹。 2.启动goagent，CA.crt文件会从新生成。 3.打开钥匙串访问.app -> 左侧钥匙串中选择`系统` -> 文件 -> 导入项目 -> 选择刚刚生成的CA.crt ->全部信任 4.要输入两次管理员密码 5.`点击导入的证书 -> 右键显示简介 -> 信任 -> 全部选择始终信任` 6.输入管理员密码 7.重启浏览器完成

第五步是最重要的。导入证书后，必须在简介中，再次设置信任，才能生效。巨坑

2014.12.27

奇怪的梦-2

2013-11-03T00:00:00+00:00

梦见洪水

给一个手工作坊小店的主人建议，自己统计雨量，在雨多的时候，多制作自己的产品（木雕？忘了是什么了，和雨有关）。

在一个大厦里面工作，四个角有四部很大的电梯。

忘记什么原因，知道某天会是世界末日。全世界会被淹没。只有几个人相信我的话。

一直在准备怎么度过难关。和前面的小店也有关系。当天，我和几个同事准备好了，但是有个人一直在阻挠我们，很讨厌，但是我劝过他要加入一起。他没有听，一直在捣乱。洪水真的来了。我们要从写字楼里面逃出去。但是当时好像有问题，一楼出不去了，要从二楼出去。这种情况，那个人还在继续阻挠。好像是为了工作…很奇怪，所有人都在逃跑，但是却只和我们过不去。好像是他想自己跑，然后害死我们。可是一个很巧合的事情，导致他出不去了，却把我们从二楼安全的送了出去。

滔天的巨浪向我们扑来。目测大概有1-2千米高的浪。每个人都钻进事先准备好的东西（好像是前面小店卖的商品）。躲过一劫。过了很久，水退散了。我肚子游走，寻找活着的人。有些幸存者,走出了避难地。我们约好，幸存下来就去清华大学，组织学习，建设新的城市。

路上我来到了小店，小店的主人也回来了。在小店里面还有几个幸存者。我对他说，你的产品要火了。他说，因为他统计雨量，所以警告了很多人要注意洪水，但是没人听他的。

2013.11.03

博客主题做成了主题包，可以直接pull下来

2012-11-08T00:00:00+00:00

在github上添加了个jekyll 的主题 aquatic

在~/yourblog目录下，使用命令来下载

rake theme:install git="https://github.com/ericwang/aquatic.git"

此命令会将主题文件下载到~/yourblog/_theme_packages目录下。最后会提示是否切换到新主题，可以直接切换。如果不想切换，可以使用下面的命令切换。

rake theme:switch name="aquatic"

主题安装后，输入一下命令

jekyll --server

在浏览器中输入http://localhost:4000/就可以预览了。

不喜欢可以再切换回去，主题名字就是~/yourblog/_includes/themes里面的目录名。可以使用上面的命令随时切换。也可以手工切换，在_layout/default.html中，修改name后面的值。

---
theme :
  name : theme_name
---

删除很简单，只要删除~/yourblog/_includes/themes里面的aquatic目录，和~/yourblog/assets/themes里的aquatic目录即可。

lala~~~

2012-11-06T00:00:00+00:00

test title

#lala~~

灯泡广告…

2011-12-29T00:00:00+00:00

</embed>

FlashPlayer不弹出错误信息的问题

2011-10-01T00:00:00+00:00

首先，要安装debug版的flahsplayer http://www.adobe.com/support/flashplayer/downloads.html

然后找到flashplayer的配置文件，位置如下：

Windows C:\Documents and Settings\username\mm.cfg OSX /Library/Application Support/Macromedia/mm.cfg Linux home/username/mm.cfg

然后删掉所有的配置项

具体配置选项的项目请参看 http://jpauclair.net/mm-cfg-secrets/

在Unity3D的网络游戏中实现资源动态加载

2011-09-17T00:00:00+00:00

用Unity3D制作基于web的网络游戏，不可避免的会用到一个技术-资源动态加载。比如想加载一个大场景的资源，不应该在游戏的开始让用户长时间等待全部资源的加载完毕。应该优先加载用户附近的场景资源，在游戏的过程中，不影响操作的情况下，后台加载剩余的资源，直到所有加载完毕。

本文包含一些代码片段讲述实现这个技术的一种方法。本方法不一定是最好的，希望能抛砖引玉。代码是C#写的，用到了Json，还有C#的事件机制。

在讲述代码之前，先想象这样一个网络游戏的开发流程。首先美工制作场景资源的3D建模，游戏设计人员把3D建模导进Unity3D，托托拽拽编辑场景，完成后把每个gameobject导出成XXX.unity3d格式的资源文件（参看BuildPipeline），并且把整个场景的信息生成一个配置文件，xml或者Json格式（本文使用Json）。最后还要把资源文件和场景配置文件上传到服务器，最好使用CMS管理。客户端运行游戏时，先读取服务器的场景配置文件，再根据玩家的位置从服务器下载相应的资源文件并加载，然后开始游戏，注意这里并不是下载所有的场景资源。在游戏的过程中，后台继续加载资源直到所有加载完毕。

一个简单的场景配置文件的例子： MyDemoSence.txt Json代码

{  
    "AssetList" : [{  
        "Name" : "Chair 1",  
        "Source" : "Prefabs/Chair001.unity3d",  
        "Position" : [2,0,-5],  
        "Rotation" : [0.0,60.0,0.0]  
    },  
    {  
        "Name" : "Chair 2",  
        "Source" : "Prefabs/Chair001.unity3d",  
        "Position" : [1,0,-5],  
        "Rotation" : [0.0,0.0,0.0]  
    },  
    {  
        "Name" : "Vanity",  
        "Source" : "Prefabs/vanity001.unity3d",  
        "Position" : [0,0,-4],  
        "Rotation" : [0.0,0.0,0.0]  
    },  
    {  
        "Name" : "Writing Table",  
        "Source" : "Prefabs/writingTable001.unity3d",  
        "Position" : [0,0,-7],  
        "Rotation" : [0.0,0.0,0.0],  
        "AssetList" : [{  
            "Name" : "Lamp",  
            "Source" : "Prefabs/lamp001.unity3d",  
            "Position" : [-0.5,0.7,-7],  
            "Rotation" : [0.0,0.0,0.0]  
        }]  
    }]  
}

AssetList：场景中资源的列表，每一个资源都对应一个unity3D的gameobject Name：gameobject的名字，一个场景中不应该重名 Source：资源的物理路径及文件名 Position：gameobject的坐标 Rotation：gameobject的旋转角度你会注意到Writing Table里面包含了Lamp，这两个对象是父子的关系。配置文件应该是由程序生成的，手工也可以修改。另外在游戏上线后，客户端接收到的配置文件应该是加密并压缩过的。

主程序： C#代码 …

public class MainMonoBehavior : MonoBehaviour {  
  
    public delegate void MainEventHandler(GameObject dispatcher);  
  
    public event MainEventHandler StartEvent;  
    public event MainEventHandler UpdateEvent;  
  
    public void Start() {  
        ResourceManager.getInstance().LoadSence("Scenes/MyDemoSence.txt");  
  
        if(StartEvent != null){  
            StartEvent(this.gameObject);  
        }  
    }  
  
    public void Update() {  
        if (UpdateEvent != null) {  
            UpdateEvent(this.gameObject);  
        }  
    }  
}
...

这里面用到了C#的事件机制，大家可以看看我以前翻译过的国外一个牛人的文章。C# 事件和Unity3D 在start方法里调用ResourceManager，先加载配置文件。每一次调用update方法，MainMonoBehavior会把update事件分发给ResourceManager，因为ResourceManager注册了MainMonoBehavior的update事件。

ResourceManager.cs C#代码

private MainMonoBehavior mainMonoBehavior;  
private string mResourcePath;  
private Scene mScene;  
private Asset mSceneAsset;  
  
private ResourceManager() {  
    mainMonoBehavior = GameObject.Find("Main Camera").GetComponent<MainMonoBehavior>();  
    mResourcePath = PathUtil.getResourcePath();  
}  
  
public void LoadSence(string fileName) {  
    mSceneAsset = new Asset();  
    mSceneAsset.Type = Asset.TYPE_JSON;  
    mSceneAsset.Source = fileName;  
  
    mainMonoBehavior.UpdateEvent += OnUpdate;  
}

在LoadSence方法里先创建一个Asset的对象，这个对象是对应于配置文件的，设置type是Json，source是传进来的“Scenes/MyDemoSence.txt”。然后注册MainMonoBehavior的update事件。 C#代码

public void OnUpdate(GameObject dispatcher) {  
    if (mSceneAsset != null) {  
        LoadAsset(mSceneAsset);  
        if (!mSceneAsset.isLoadFinished) {  
            return;  
        }  
  
        //clear mScene and mSceneAsset for next LoadSence call  
        mScene = null;  
        mSceneAsset = null;  
    }
    mainMonoBehavior.UpdateEvent -= OnUpdate;  
}

OnUpdate方法里调用LoadAsset加载配置文件对象及所有资源对象。每一帧都要判断是否加载结束，如果结束清空mScene和mSceneAsset对象为下一次加载做准备，并且取消update事件的注册。

最核心的LoadAsset方法： C#代码

private Asset LoadAsset(Asset asset) {  
    string fullFileName = mResourcePath + "/" + asset.Source;  
      
    //if www resource is new, set into www cache  
    if (!wwwCacheMap.ContainsKey(fullFileName)) {  
        if (asset.www == null) {  
            asset.www = new WWW(fullFileName);  
            return null;  
        }  
  
        if (!asset.www.isDone) {  
            return null;  
        }  
        wwwCacheMap.Add(fullFileName, asset.www);  
    }
...
}

传进来的是要加载的资源对象，先得到它的物理地址，mResourcePath是个全局变量保存资源服务器的网址，得到fullFileName类似http://www.mydemogame.com/asset/Prefabs/xxx.unity3d。然后通过wwwCacheMap判断资源是否已经加载完毕，如果加载完毕把加载好的www对象放到Map里缓存起来。看看前面Json配置文件，Chair 1和Chair 2用到了同一个资源Chair001.unity3d，加载Chair 2的时候就不需要下载了。如果当前帧没有加载完毕，返回null等到下一帧再做判断。这就是WWW类的特点，刚开始用WWW下载资源的时候是不能马上使用的，要等待诺干帧下载完成以后才可以使用。可以用yield返回www，这样代码简单，但是C#要求调用yield的方法返回IEnumerator类型，这样限制太多不灵活。

继续LoadAsset方法： C#代码

    if (asset.Type == Asset.TYPE_JSON) { //Json  
        if (mScene == null) {  
            string jsonTxt = mSceneAsset.www.text;  
            mScene = JsonMapper.ToObject<Scene>(jsonTxt);  
        }  
          
        //load scene  
        foreach (Asset sceneAsset in mScene.AssetList) {  
            if (sceneAsset.isLoadFinished) {  
                continue;  
            } else {  
                LoadAsset(sceneAsset);  
                if (!sceneAsset.isLoadFinished) {  
                    return null;  
                }  
            }  
        }  
    }   
...

代码能够运行到这里，说明资源都已经下载完毕了。现在开始加载处理资源了。第一次肯定是先加载配置文件，因为是Json格式，用JsonMapper类把它转换成C#对象，我用的是LitJson开源类库。然后循环递归处理场景中的每一个资源。如果没有完成，返回null，等待下一帧处理。

继续LoadAsset方法： C#代码

...
    else if (asset.Type == Asset.TYPE_GAMEOBJECT) { //Gameobject  
        if (asset.gameObject == null) {  
            wwwCacheMap[fullFileName].assetBundle.LoadAll();  
            GameObject go = (GameObject)GameObject.Instantiate(wwwCacheMap[fullFileName].assetBundle.mainAsset);  
            UpdateGameObject(go, asset);  
            asset.gameObject = go;  
        }  
  
        if (asset.AssetList != null) {  
            foreach (Asset assetChild in asset.AssetList) {  
                if (assetChild.isLoadFinished) {  
                    continue;  
                } else {  
                    Asset assetRet = LoadAsset(assetChild);  
                    if (assetRet != null) {  
                        assetRet.gameObject.transform.parent = asset.gameObject.transform;  
                    } else {  
                        return null;  
                    }  
                }  
            }  
        }  
    }  
  
    asset.isLoadFinished = true;  
    return asset;  
}

终于开始处理真正的资源了，从缓存中找到www对象，调用Instantiate方法实例化成Unity3D的gameobject。UpdateGameObject方法设置gameobject各个属性，如位置和旋转角度。然后又是一个循环递归为了加载子对象，处理gameobject的父子关系。注意如果LoadAsset返回null，说明www没有下载完毕，等到下一帧处理。最后设置加载完成标志返回asset对象。

UpdateGameObject方法： C#代码

private void UpdateGameObject(GameObject go, Asset asset) {  
    //name  
    go.name = asset.Name;  
  
    //position  
    Vector3 vector3 = new Vector3((float)asset.Position[0], (float)asset.Position[1], (float)asset.Position[2]);  
    go.transform.position = vector3;  
  
    //rotation  
    vector3 = new Vector3((float)asset.Rotation[0], (float)asset.Rotation[1], (float)asset.Rotation[2]);  
    go.transform.eulerAngles = vector3;  
}

这里只设置了gameobject的3个属性，眼力好的同学一定会发现这些对象都是“死的”，因为少了脚本属性，它们不会和玩家交互。设置脚本属性要复杂的多，编译好的脚本随着主程序下载到本地，它们也应该通过配置文件加载，再通过C#的反射创建脚本对象，赋给相应的gameobject。

最后是Scene和asset代码： C#代码

public class Scene {  
    public List<Asset> AssetList {  
        get;  
        set;  
    }  
}
  
public class Asset {  
  
    public const byte TYPE_JSON = 1;  
    public const byte TYPE_GAMEOBJECT = 2;  
  
    public Asset() {  
        //default type is gameobject for json load  
        Type = TYPE_GAMEOBJECT;  
    }  
  
    public byte Type {  
        get;  
        set;  
    }  
  
    public string Name {  
        get;  
        set;  
    }  
  
    public string Source {  
        get;  
        set;  
    }  
  
    public double[] Bounds {  
        get;  
        set;  
    }  
      
    public double[] Position {  
        get;  
        set;  
    }  
  
    public double[] Rotation {  
        get;  
        set;  
    }  
  
    public List<Asset> AssetList {  
        get;  
        set;  
    }  
  
    public bool isLoadFinished {  
        get;  
        set;  
    }  
  
    public WWW www {  
        get;  
        set;  
    }  
  
    public GameObject gameObject {  
        get;  
        set;  
    }  
}

代码就讲完了，在我实际测试中，会看到gameobject一个个加载并显示在屏幕中，并不会影响到游戏操作。代码还需要进一步完善适合更多的资源类型，如动画资源，文本，字体，图片和声音资源。

动态加载资源除了网络游戏必需，对于大公司的游戏开发也是必须的。它可以让游戏策划（负责场景设计），美工和程序3个角色独立出来，极大提高开发效率。试想如果策划改变了什么NPC的位置，美工改变了某个动画，或者改变了某个程序，大家都要重新倒入一遍资源是多么低效和麻烦的一件事。

Liquid Extensions

2011-09-17T00:00:00+00:00

介绍jeykll的Highlight code, include other files, and transform text with Liquid Extensions.

https://github.com/mojombo/jekyll/wiki/liquid-extensions https://github.com/shopify/liquid/wiki/liquid-for-designers

highlight支持的语言的shortname http://pygments.org/docs/lexers/

3个服务端(游戏)

2011-09-17T00:00:00+00:00

Electrotank Universe Platform Photon Socket Server Smartfox Server

使用typeid和RTTI C++获取对象运行时类名称【转】

2011-09-16T00:00:00+00:00

观点有一些值得商榷的地方

关于typeid和RTTI的问答问：在c++里怎么能知道一个变量的具体类型，如：c#里的typeof.还有我怎么知道一个变量的类型是某个类型的子类，也就是实现关键字IS

答： 1。运行时获知变量类型名称，可以使用 typeid(变量).name，需要注意不是所有编译器都输出”int”、”float”等之类的名称，对于这类的编译器可以这样使用：float f = 1.1f; if( typeid(f) typeid(0.0f) ) …… 2。对于多态类实例，想得到实际的类名称，需要使用到RTTI，这需要在编译的时候加上参数”/GR”。 3。对于普通变量，既然是自己写的，那当然也就应该知道它的类型，其实用不着运行时获知；对于多态类实例，既然需要运行时获知实际类型，那么就说明这里不具有多态性，既然没有多态性就不应该抽象它，这属于设计错误，总之，我认为RTTI是多余的。 4。对于多态类实例，使用 typeid(value) typeid(value)来判断，不如使用 dynamic_cast 来判断，它们的原理是一样的。

示例代码：

#include 
using namespace std;
int main( void )
{
// sample 1
    cout << typeid(1.1f).name() << endl;
// sample 2
    class Base1
    {
    };
    class Derive1 : public Base1
    {
    };
    Derive1 d1;
    Base1& b1 = d1;
    cout << typeid(b1).name() << endl; // 输出"class Base1",因为Derive1和Base1之间没有多态性
// sample 3, 编译时需要加参数 /GR
    class Base2
    {
        virtual void fun( void ) {}
    };
    class Derive2 : public Base2
    {
    };
    Derive2 d2;
    Base2& b2 = d2;
    cout << typeid(b2).name() << endl; // 输出"class Derive2",因为Derive1和Base1之间有了多态性
// sample 4
    class Derive22 : public Base2
    {
    };
    // 指针强制转化失败后可以比较指针是否为零，而引用却没办法，所以引用制转化失败后抛出异常
    Derive2* pb1 = dynamic_cast(&b2);
    cout << boolalpha << (0!=pb1) << endl; // 输出"true",因为b2本身就确实是Derive2
    Derive22* pb2 = dynamic_cast(&b2);
    cout << boolalpha << (0!=pb2) << endl; // 输出"true",因为b2本身不是Derive2
    try {
        Derive2& rb1 = dynamic_cast(b2);
        cout << "true" << endl;
    } catch( bad_cast )
    {
        cout << "false" << endl;
    }
    try {
        Derive22& rb2 = dynamic_cast(b2);
        cout << "true" << endl;
    } catch( ... ) // 应该是 bad_cast,但不知道为什么在VC++6.0中却不行
    {
        cout << "false" << endl;
    }
    return 0;
}

/////////////////////////////////////////////

MFC六大关键技术之运行时类型识别运行时类型识别（RTTI）即是程序执行过程中知道某个对象属于某个类，我们平时用C++编程接触的RTTI一般是编译器的RTTI

运行时类型识别（RTTI）即是程序执行过程中知道某个对象属于某个类，我们平时用C+编程接触的RTTI一般是编译器的RTTI，即是在新版本的VC编译器里面选用“使能RTTI”，然后载入typeinfo.h文件，就可以使用一个叫typeid（）的运算子，它的地位与在C+编程中的sizeof()运算子类似的地方（包含一个头文件，然后就有一个熟悉好用的函数）。typdid()关键的地方是可以接受两个类型的参数：一个是类名称，一个是对象指针。所以我们判别一个对象是否属于某个类就可以象下面那样：

if （typeid (ClassName)== typeid（*ObjectName））{ ((ClassName*)ObjectName)->Fun(); }

　　象上面所说的那样，一个typeid（）运算子就可以轻松地识别一个对象是否属于某一个类，但MFC并不是用typeid（）的运算子来进行动态类型识别，而是用一大堆令人费解的宏。很多学员在这里很疑惑，好象MFC在大部分地方都是故作神秘。使们大家编程时很迷惘，只知道在这里加入一组宏，又在那儿加入一个映射，而不知道我们为什么要加入这些东东。

　　其实，早期的MFC并没有typeid（）运算子，所以只能沿用一个老办法。我们甚至可以想象一下，如果MFC早期就有template（模板）的概念，可能更容易解决RTTI问题。

　　所以，我们要回到“古老”的年代，想象一下，要完成RTTI要做些什么事情。就好像我们在一个新型（新型到我们还不认识）电器公司里面，我们要识别哪个是电饭锅，哪个是电磁炉等等，我们要查看登记的各电器一系列的信息，我们才可以比较、鉴别，那个东西是什么！要登记一系列的消息并不是一件简单的事情，大家可能首先想到用数组登记对象。但如果用数组，我们要定义多大的数组才好呢，大了浪费空间，小了更加不行。所以我们要用另一种数据结构——链表。因为链表理论上可大可小，可以无限扩展。

　　链表是一种常用的数据结构，简单地说，它是在一个对象里面保存了指向下一个同类型对象的指针。我们大体可以这样设计我们的类：

struct CRuntimeClass { ……类的名称等一切信息…… CRuntimeClass * m_pNextClass;//指向链表中下一CRuntimeClass对象的指针 };

　　链表还应该有一个表头和一个表尾，这样我们在查链表中各对象元素的信息的时候才知道从哪里查起，到哪儿结束。我们还要注明本身是由哪能个类派生。所以我们的链表类要这样设计：

struct CRuntimeClass { ……类的名称等一切信息…… CRuntimeClass * m_pBaseClass;//指向所属的基类。 CRuntimeClass * m_pNextClass;//定义表尾的时候只要定义此指针为空就可以了。 static CRuntimeClass* pFirstClass;//这里表头指针属于静态变量，因为我们知道static变量在内存中只初始化一次，就可以为各对象所用！保证了各对象只有一个表头。 };

　　有了CRuntimeClass结构后，我们就可以定义链表了：

static CRuntimeClass classCObject={NULL,NULL};//这里定义了一个CRuntimeClass对象，

　　因为classCObject无基类，所以m_pBaseClass为NULL。因为目前只有一个元素（即目前没有下一元素），所以m_pNextClass为NULL（表尾）。

　　至于pFirstClass（表头），大家可能有点想不通，它到什么地方去了。因为我们这里并不想把classCObject作为链表表头，我们还要在前面插入很多的CRuntimeClass对象，并且因为pFirstClass为static指针，即是说它不是属于某个对象，所以我们在用它之前要先初始化：

CRuntimeClass* CRuntimeClass：：pFirstClass=NULL;

　　现在我们可以在前面插入一个CRuntimeClass对象，插入之前我得重要申明一下：如果单纯为了运行时类型识别，我们未必用到m_pNextClass指针（更多是在运行时创建时用），我们关心的是类本身和它的基类。这样，查找一个对象是否属于一个类时，主要关心的是类本身及它的基类：

CRuntimeClass classCCmdTarget={ &classCObject, NULL}; CRuntimeClass classCWnd={ &classCCmdTarget ,NULL }; CRuntimeClass classCView={ &classCWnd , NULL };

　　好了，上面只是仅仅为一个指针m_pBaseClass赋值（MFC中真正CRuntimeClass有多个成员变量和方法），就连接成了链表。假设我们现在已全部构造完成自己需要的CRuntimeClass对象，那么，这时候应该定义表头。即要用pFirstClass指针指向我们最后构造的CRuntimeClass对象——classCView。

CRuntimeClass：：pFirstClass=&classCView;

　　现在链表有了，表头表尾都完善了，问题又出现了，我们应该怎样访问每一个CRuntimeClass对象？要判断一个对象属于某类，我们要从表头开始，一直向表尾查找到表尾，然后才能比较得出结果吗。肯定不是这样！

　　大家可以这样想一下，我们构造这个链表的目的，就是构造完之后，能够按主观地拿一个CRuntimeClass对象和链表中的元素作比较，看看其中一个对象中否属于你指定的类。这样，我们需要有一个函数，一个能返回自身类型名的函数GetRuntimeClass()。

　　上面简单地说一下链表的过程，但单纯有这个链表是没有任何意义。回到MFC中来，我们要实现的是在每个需要有RTTI能力的类中构造一个CRuntimeClass对象，比较一个类是否属于某个对象的时候，实际上只是比较CRuntimeClass对象。

　　如何在各个类之中插入CRuntimeClass对象，并且指定CRuntimeClass对象的内容及CRuntimeClass对象的链接，这里起码有十行的代码才能完成。在每个需要有RTTI能力的类设计中都要重复那十多行代码是一件乏味的事情，也容易出错，所以MFC用了两个宏代替这些工作，即DECLARE_DYNAMIC(类名)和IMPLEMENT_DYNAMIC(类名，基类名)。从这两个宏我们可以看出在MFC名类中的CRuntimeClass对象构造连接只有类名及基类名的不同！

　　到此，可能会有朋友问：为什么要用两个宏，用一个宏不可以代换CRuntimeClass对象构造连接吗？个人认为肯定可以，因为宏只是文字代换的游戏而已。但我们在编程之中，头文件与源文件是分开的，我们要在头文件头声明变量及方法，在源文件里实具体实现。即是说我们要在头文件中声明：

public: static CRuntimeClass classXXX //XXX为类名 virtual CRuntime* GetRuntimeClass() const;

　　然后在源文件里实现：

CRuntimeClass* XXX：：classXXX={……}； CRuntime* GetRuntimeClass() const; { return &XXX:: classXXX;}//这里不能直接返回&classXXX，因为static变量是类拥有而不是对象拥有。

　　我们一眼可以看出MFC中的DECLARE_DYNAMIC(类名)宏应该这样定义：

#define DECLARE_DYNAMIC(class_name) public: static CRuntimeClass class##class_name; virtual CRuntimeClass* GetRuntimeClass() const;

　　其中##为连接符，可以让我们传入的类名前面加上class，否则跟原类同名，大家会知道产生什么后果。

　　有了上面的DECLARE_DYNAMIC(类名)宏之后，我们在头文件里写上一句：

DECLARE_DYNAMIC(XXX)

　　宏展开后就有了我们想要的：

public: static CRuntimeClass classXXX //XXX为类名 virtual CRuntime* GetRuntimeClass() const;

　　对于IMPLEMENT_DYNAMIC(类名，基类名)，看来也不值得在这里代换文字了，大家知道它是知道回事，宏展开后为我们做了什么，再深究真是一点意义都没有！

　　有了此链表之后，就像有了一张存放各类型的网，我们可以轻而易举地RTTI。CObject有一个函数BOOL IsKindOf(const CRuntimeClass* pClass) const;，被它以下所有派生员继承。

　　此函数实现如下：

BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const { CRuntimeClass* pClassThis=GetRuntimeClass();//获得自己的CRuntimeClass对象指针。 while(pClassThis!=NULL) { if(pClassThis==pClass) return TRUE; pClassThis=pClassThis->m_pBaseClass;//这句最关键，指向自己基类，再回头比较，一直到尽头m_pBaseClass为NULL结束。 } return FALSE; }

　　说到这里，运行时类型识别（RTTI）算是完成了。写这篇文章的时候，我一直重感冒。我曾一度在想，究竟写这东西是为了什么。因为如果我把这些时间用在别的地方（甚至帮别人打打字），应该有数百元的报酬。

　　是什么让“嗜财如命”的我继续写下去？我想，无非是想交几个计算机的朋友而已。计算机是大家公认高科技的东西，但学习它的朋友大多只能默默无闻，外界的朋友也不知道怎么去认识你。程序员更不是“潮流”的东西，更加得不到别人的认可。

　　有一件个人认为很典型的事情，有一天，我跟一个朋友到一个单位里面。里面有一个女打字员。朋友看着她熟练的指法，心悦诚服地说：“她的电脑水平比你的又高了一个很高的层次！”，那个女的打字高手亦自豪地说：“我靠电脑为生，电脑水平肯定比你（指笔者）的好一点！换着是你，如果以电脑为生，我也不敢说好过你！”。虽然我想声明我是计算机专业的，但我知道没有理解，所以我只得客气地点头。

　　选择电脑“潮流”的东西实际是选择了平凡，而选择做程序员就是选择了孤独！幸好我不是一个专门的程序员，但即使如此，我愿意做你们的朋友，因为我爱你们！

http://www.yesky.com/SoftChannel/72342371928702976/20050228/1915827.shtml

/////////////////////////////// 首先，很不好意思的说明，我还正在看C** language programming，但还没有看到关于RTTI的章节。另外，我也很少使用C** RTTI的特性。所以对RTTI的理解仅限于自己的摸索和思考。如果不正确，请大家指正。

RTTI特性是C+语言加入较晚的特性之一。和其他语言（比如JAVA）相比，C的RTTI能力算是非常差的。这与C的设计要求应该有重要的关系：性能。没错，性能的因素使得C的很多地方不能称的上完美，但是也正因为如此，在高级通用语言里面，只有C能和C+的性能可以相提并论。

1：typeid的研究

在C++中，似乎与RTTI相关的只有一个东西，就是dynamic_cast，本来我认为typeid是RTTI的一部分，但是我的实验表明，并非如此。typeid的操作是在编译时期就已经决定的了。下面的代码可以证明：

#include 
#include
class A
{
};
class B:public A
{
};
int main()
{
   A *pa;
   B b,*pb;
   pb = &b;
   pa = pb;
   std::cout<<"Name1:"
        << (typeid(pa).name())
        <<"\tName2:"
        <<(typeid(pb).name())
        <<:endl;< p="">
   std::cout<<"pa == pb:"<< (typeid(pa) == typeid(pb))<<:endl;
   return 0;
}

typeid根本不能判别pa实际上是一个B*。换句话说，typeid是以字面意思去解释类型，不要指望它能认出一个void*实际上是int*(这个连人也做不到:P）。实际上实用价值不大。

当然，在某些特殊地方，也是能够有些效用的，比如模板。

template 
void test(T t)
{
 if(typeid(t) == typeid(char *))
 {
   // 对char *特殊处理
 }
 //...
}

如果编译器优化的好的话，并不会产生废代码，因为typeid编译时期就可以决定了。

2：dynamic_cast

抱歉现在才讲到正题，我对dynamic_cast第一印象就是，它究竟是怎么实现的呢？经过一些思考，我认为最简单的方案就是将信息保存在vtable里，它会占用一个vtalbe表的项目。实验和书籍也证明了这一点。但是就会有一个问题，没有vtable的类怎么办？内建类型怎么办？其实，没有vtable的类，它不需要多态，它根本就不需要RTTI，内建类型也一样。这就是说，dynamic_cast只支持有虚函数的类。而且， dynamic_cast不能进行non_base_class 到 class T*的转换，比如void –> class T *，因为它无法去正确获得vtable。

这样，dynamic_cast的意义和使用方法就很清楚了，它是为了支持多态而存在的。它用于实现从基类到派生类的安全转换。同时它也在绝大多数情况下避免了使用static_cast－－不安全的类型转换。

3:结论

C** 的RTTI机制虽然简单，或者说简陋，但是它使得静态类型转换变得无用了。这也是C+的一个不可缺少的机制。在未来，如果C+能够提供可选的更强的RTTI机制，就像JAVA里的那样，这种语言可以变得更加强大。当然，到时如何提供不损失性能的 RTTI机制，更是一个值得深入研究的话题了。

用GDB调试程序[转]

2011-09-16T00:00:00+00:00

GDB概述 ———— GDB是GNU开源组织发布的一个强大的UNIX下的程序调试工具。或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在UNIX平台下做软件，你会发现GDB这个调试工具有比VC、BCB的图形化调试器更强大的功能。所谓“寸有所长，尺有所短”就是这个道理。一般来说，GDB主要帮忙你完成下面四个方面的功能： 1、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。 2、可让被调试的程序在你所指定的调置的断点处停住。（断点可以是条件表达式） 3、当程序被停住时，可以检查此时你的程序中所发生的事。 4、动态的改变你程序的执行环境。从上面看来，GDB和一般的调试工具没有什么两样，基本上也是完成这些功能，不过在细节上，你会发现GDB这个调试工具的强大，大家可能比较习惯了图形化的调试工具，但有时候，命令行的调试工具却有着图形化工具所不能完成的功能。让我们一一看来。

一个调试示例 —————— 源程序：tst.c

#include <stdio.h>
int func(int n)
{
	int sum=0,i;
	for(i=0; i<n; i++)
	{
			sum+=i;
	}
	return sum;
}
main()
{
	int i;
	long result = 0;
	for(i=1; i<=100; i++)
	{
		result += i;
	}
	printf("result[1-100] = %d \n", result );
	printf("result[1-250] = %d \n", func(250) );
}

编译生成执行文件：（Linux下） hchen/test> cc -g tst.c -o tst

使用GDB调试：

hchen/test> gdb tst <———- 启动GDB GNU gdb 5.1.1 Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type “show copying” to see the conditions. There is absolutely no warranty for GDB. Type “show warranty” for details. This GDB was configured as “i386-suse-linux”… (gdb) l <——————– l命令相当于list，从第一行开始例出原码。 1 #include <stdio.h> 2 3 int func(int n) 4 { 5 int sum=0,i; 6 for(i=0; i<n; i++) 7 { 8 sum+=i; 9 } 10 return sum; (gdb) <——————– 直接回车表示，重复上一次命令 11 } 12 13 14 main() 15 { 16 int i; 17 long result = 0; 18 for(i=1; i<=100; i++) 19 { 20 result += i;
(gdb) break 16 <——————– 设置断点，在源程序第16行处。 Breakpoint 1 at 0x8048496: file tst.c, line 16. (gdb) break func <——————– 设置断点，在函数func()入口处。 Breakpoint 2 at 0x8048456: file tst.c, line 5. (gdb) info break <——————– 查看断点信息。 Num Type Disp Enb Address What 1 breakpoint keep y 0x08048496 in main at tst.c:16 2 breakpoint keep y 0x08048456 in func at tst.c:5 (gdb) r <——————— 运行程序，run命令简写 Starting program: /home/hchen/test/tst Breakpoint 1, main () at tst.c:17 <———- 在断点处停住。 17 long result = 0; (gdb) n <——————— 单条语句执行，next命令简写。 18 for(i=1; i<=100; i++) (gdb) n 20 result += i; (gdb) n 18 for(i=1; i<=100; i++) (gdb) n 20 result += i; (gdb) c <——————— 继续运行程序，continue命令简写。 Continuing. result[1-100] = 5050 <———-程序输出。 Breakpoint 2, func (n=250) at tst.c:5 5 int sum=0,i; (gdb) n 6 for(i=1; i<=n; i++) (gdb) p i <——————— 打印变量i的值，print命令简写。 $1 = 134513808 (gdb) n 8 sum+=i; (gdb) n 6 for(i=1; i<=n; i++) (gdb) p sum $2 = 1 (gdb) n 8 sum+=i; (gdb) p i $3 = 2 (gdb) n 6 for(i=1; i<=n; i++) (gdb) p sum $4 = 3 (gdb) bt <——————— 查看函数堆栈。 #0 func (n=250) at tst.c:5 #1 0x080484e4 in main () at tst.c:24 #2 0x400409ed in __libc_start_main () from /lib/libc.so.6 (gdb) finish <——————— 退出函数。 Run till exit from #0 func (n=250) at tst.c:5 0x080484e4 in main () at tst.c:24 24 printf(“result[1-250] = %d \n”, func(250) ); Value returned is $6 = 31375 (gdb) c <——————— 继续运行。 Continuing. result[1-250] = 31375 <———-程序输出。 Program exited with code 027. <——–程序退出，调试结束。 (gdb) q <——————— 退出gdb。 hchen/test>

好了，有了以上的感性认识，还是让我们来系统地认识一下gdb吧。

使用GDB ———— 一般来说GDB主要调试的是C/C+的程序。要调试C/C的程序，首先在编译时，我们必须要把调试信息加到可执行文件中。使用编译器（cc/gcc/g+）的 -g 参数可以做到这一点。如： > cc -g hello.c -o hello > g** -g hello.cpp -o hello 如果没有-g，你将看不见程序的函数名、变量名，所代替的全是运行时的内存地址。当你用-g把调试信息加入之后，并成功编译目标代码以后，让我们来看看如何用gdb来调试他。启动GDB的方法有以下几种： 1、gdb program也就是你的执行文件，一般在当然目录下。 2、gdb core 用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。 3、gdb 如果你的程序是一个服务程序，那么你可以指定这个服务程序运行时的进程ID。gdb会自动attach上去，并调试他。program应该在PATH环境变量中搜索得到。

GDB启动时，可以加上一些GDB的启动开关，详细的开关可以用gdb -help查看。我在下面只例举一些比较常用的参数： -symbols -s 从指定文件中读取符号表。 -se file 从指定文件中读取符号表信息，并把他用在可执行文件中。 -core -c 调试时core dump的core文件。 -directory -d 加入一个源文件的搜索路径。默认搜索路径是环境变量中PATH所定义的路径。 GDB的命令概貌 ——————— 启动gdb后，就你被带入gdb的调试环境中，就可以使用gdb的命令开始调试程序了，gdb的命令可以使用help命令来查看，如下所示： /home/hchen> gdb GNU gdb 5.1.1 Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i386-suse-linux". (gdb) help List of classes of commands: aliases -- Aliases of other commands breakpoints -- Making program stop at certain points data -- Examining data files -- Specifying and examining files internals -- Maintenance commands obscure -- Obscure features running -- Running the program stack -- Examining the stack status -- Status inquiries support -- Support facilities tracepoints -- Tracing of program execution without stopping the program user-defined -- User-defined commands Type "help" followed by a class name for a list of commands in that class. Type "help" followed by command name for full documentation. Command name abbreviations are allowed if unambiguous. (gdb) gdb的命令很多，gdb把之分成许多个种类。help命令只是例出gdb的命令种类，如果要看种类中的命令，可以使用help 命令，如：help breakpoints，查看设置断点的所有命令。也可以直接help 来查看命令的帮助。

gdb中，输入命令时，可以不用打全命令，只用打命令的前几个字符就可以了，当然，命令的前几个字符应该要标志着一个唯一的命令，在Linux下，你可以敲击两次TAB键来补齐命令的全称，如果有重复的，那么gdb会把其例出来。

示例一：在进入函数func时，设置一个断点。可以敲入break func，或是直接就是b func (gdb) b func Breakpoint 1 at 0x8048458: file hello.c, line 10.

示例二：敲入b按两次TAB键，你会看到所有b打头的命令： (gdb) b backtrace break bt (gdb) 示例三：只记得函数的前缀，可以这样： (gdb) b make_ <按TAB键> （再按下一次TAB键，你会看到:） make\_a\_section\_from\_file make\_environ make\_abs\_section make\_function\_type make\_blockvector make\_pointer\_type make\_cleanup make\_reference\_type make\_command make\_symbol\_completion\_list (gdb) b make\_ GDB把所有make开头的函数全部例出来给你查看。示例四：调试C++的程序时，有可以函数名一样。如： (gdb) b 'bubble( M-? bubble(double,double) bubble(int,int) (gdb) b 'bubble( 你可以查看到C++中的所有的重载函数及参数。（注：M-?和“按两次TAB键”是一个意思）要退出gdb时，只用发quit或命令简称q就行了。

GDB中运行UNIX的shell程序 ———————————— 在gdb环境中，你可以执行UNIX的shell的命令，使用gdb的shell命令来完成： shell 调用UNIX的shell来执行，环境变量SHELL中定义的UNIX的shell将会被用来执行，如果SHELL没有定义，那就使用UNIX的标准shell：/bin/sh。（在Windows中使用Command.com或cmd.exe）还有一个gdb命令是make： make 可以在gdb中执行make命令来重新build自己的程序。这个命令等价于“shell make ”。

在GDB中运行程序 ———————— 当以gdb 方式启动gdb后，gdb会在PATH路径和当前目录中搜索的源文件。如要确认gdb是否读到源文件，可使用l或list命令，看看gdb是否能列出源代码。在gdb中，运行程序使用r或是run命令。程序的运行，你有可能需要设置下面四方面的事。 1、程序运行参数。 set args 可指定运行时参数。（如：set args 10 20 30 40 50） show args 命令可以查看设置好的运行参数。 2、运行环境。 path

可设定程序的运行路径。 show paths 查看程序的运行路径。 set environment varname \[=value\] 设置环境变量。如：set env USER=hchen show environment \[varname\] 查看环境变量。 3、工作目录。 cd 相当于shell的cd命令。 pwd 显示当前的所在目录。 4、程序的输入输出。 info terminal 显示你程序用到的终端的模式。使用重定向控制程序输出。如：run > outfile tty命令可以指写输入输出的终端设备。如：tty /dev/ttyb 调试已运行的程序 ———————— 两种方法： 1、在UNIX下用ps查看正在运行的程序的PID（进程ID），然后用gdb PID格式挂接正在运行的程序。 2、先用gdb 关联上源代码，并进行gdb，在gdb中用attach命令来挂接进程的PID。并用detach来取消挂接的进程。暂停 / 恢复程序运行 ————————— 调试程序中，暂停程序运行是必须的，GDB可以方便地暂停程序的运行。你可以设置程序的在哪行停住，在什么条件下停住，在收到什么信号时停往等等。以便于你查看运行时的变量，以及运行时的流程。当进程被gdb停住时，你可以使用info program 来查看程序的是否在运行，进程号，被暂停的原因。在gdb中，我们可以有以下几种暂停方式：断点（BreakPoint）、观察点（WatchPoint）、捕捉点（CatchPoint）、信号（Signals）、线程停止（Thread Stops）。如果要恢复程序运行，可以使用c或是continue命令。一、设置断点（BreakPoint）我们用break命令来设置断点。正面有几点设置断点的方法： break 在进入指定函数时停住。C++中可以使用class::function或function(type,type)格式来指定函数名。 break 在指定行号停住。 break +offset break -offset 在当前行号的前面或后面的offset行停住。offiset为自然数。 break filename:linenum 在源文件filename的linenum行处停住。 break filename:function 在源文件filename的function函数的入口处停住。 break \*address 在程序运行的内存地址处停住。 break break命令没有参数时，表示在下一条指令处停住。 break ... if ...可以是上述的参数，condition表示条件，在条件成立时停住。比如在循环境体中，可以设置break if i=100，表示当i为100时停住程序。查看断点时，可使用info命令，如下所示：（注：n表示断点号） info breakpoints \[n\] info break \[n\] 二、设置观察点（WatchPoint）观察点一般来观察某个表达式（变量也是一种表达式）的值是否有变化了，如果有变化，马上停住程序。我们有下面的几种方法来设置观察点： watch 为表达式（变量）expr设置一个观察点。一量表达式值有变化时，马上停住程序。 rwatch 当表达式（变量）expr被读时，停住程序。 awatch 当表达式（变量）的值被读或被写时，停住程序。 info watchpoints 列出当前所设置了的所有观察点。三、设置捕捉点（CatchPoint）你可设置捕捉点来补捉程序运行时的一些事件。如：载入共享库（动态链接库）或是C++的异常。设置捕捉点的格式为： catch 当event发生时，停住程序。event可以是下面的内容： 1、throw 一个C++抛出的异常。（throw为关键字） 2、catch 一个C++捕捉到的异常。（catch为关键字） 3、exec 调用系统调用exec时。（exec为关键字，目前此功能只在HP-UX下有用） 4、fork 调用系统调用fork时。（fork为关键字，目前此功能只在HP-UX下有用） 5、vfork 调用系统调用vfork时。（vfork为关键字，目前此功能只在HP-UX下有用） 6、load 或 load 载入共享库（动态链接库）时。（load为关键字，目前此功能只在HP-UX下有用） 7、unload 或 unload 卸载共享库（动态链接库）时。（unload为关键字，目前此功能只在HP-UX下有用） tcatch 只设置一次捕捉点，当程序停住以后，应点被自动删除。四、维护停止点上面说了如何设置程序的停止点，GDB中的停止点也就是上述的三类。在GDB中，如果你觉得已定义好的停止点没有用了，你可以使用delete、clear、disable、enable这几个命令来进行维护。 clear 清除所有的已定义的停止点。 clear clear 清除所有设置在函数上的停止点。 clear clear 清除所有设置在指定行上的停止点。 delete \[breakpoints\] \[range...\] 删除指定的断点，breakpoints为断点号。如果不指定断点号，则表示删除所有的断点。range 表示断点号的范围（如：3-7）。其简写命令为d。比删除更好的一种方法是disable停止点，disable了的停止点，GDB不会删除，当你还需要时，enable即可，就好像回收站一样。 disable \[breakpoints\] \[range...\] disable所指定的停止点，breakpoints为停止点号。如果什么都不指定，表示disable所有的停止点。简写命令是dis. enable \[breakpoints\] \[range...\] enable所指定的停止点，breakpoints为停止点号。 enable \[breakpoints\] once range... enable所指定的停止点一次，当程序停止后，该停止点马上被GDB自动disable。 enable \[breakpoints\] delete range... enable所指定的停止点一次，当程序停止后，该停止点马上被 DB自动删除。五、停止条件维护前面在说到设置断点时，我们提到过可以设置一个条件，当条件成立时，程序自动停止，这是一个非常强大的功能，这里，我想专门说说这个条件的相关维护命令。一般来说，为断点设置一个条件，我们使用if关键词，后面跟其断点条件。并且，条件设置好后，我们可以用condition命令来修改断点的条件。（只有break和watch命令支持if，catch目前暂不支持if） condition 修改断点号为bnum的停止条件为expression。 condition 清除断点号为bnum的停止条件。还有一个比较特殊的维护命令ignore，你可以指定程序运行时，忽略停止条件几次。 ignore 表示忽略断点号为bnum的停止条件count次。六、为停止点设定运行命令我们可以使用GDB提供的command命令来设置停止点的运行命令。也就是说，当运行的程序在被停止住时，我们可以让其自动运行一些别的命令，这很有利行自动化调试。对基于GDB的自动化调试是一个强大的支持。 commands \[bnum\] ... command-list ... end 为断点号bnum指写一个命令列表。当程序被该断点停住时，gdb会依次运行命令列表中的命令。例如： break foo if x>0 commands printf "x is %d\\n",x continue end 断点设置在函数foo中，断点条件是x>0，如果程序被断住后，也就是，一旦x的值在foo函数中大于0，GDB会自动打印出x的值，并继续运行程序。如果你要清除断点上的命令序列，那么只要简单的执行一下commands命令，并直接在打个end就行了。七、断点菜单在C++中，可能会重复出现同一个名字的函数若干次（函数重载），在这种情况下，break 不能告诉GDB要停在哪个函数的入口。当然，你可以使用break <function(type)>也就是把函数的参数类型告诉GDB，以指定一个函数。否则的话，GDB会给你列出一个断点菜单供你选择你所需要的断点。你只要输入你菜单列表中的编号就可以了。如： (gdb) b String::after \[0\] cancel \[1\] all \[2\] file:String.cc; line number:867 \[3\] file:String.cc; line number:860 \[4\] file:String.cc; line number:875 \[5\] file:String.cc; line number:853 \[6\] file:String.cc; line number:846 \[7\] file:String.cc; line number:735 > 2 4 6 Breakpoint 1 at 0xb26c: file String.cc, line 867. Breakpoint 2 at 0xb344: file String.cc, line 875. Breakpoint 3 at 0xafcc: file String.cc, line 846. Multiple breakpoints were set. Use the "delete" command to delete unwanted breakpoints. (gdb) 可见，GDB列出了所有after的重载函数，你可以选一下列表编号就行了。0表示放弃设置断点，1表示所有函数都设置断点。八、恢复程序运行和单步调试当程序被停住了，你可以用continue命令恢复程序的运行直到程序结束，或下一个断点到来。也可以使用step或next命令单步跟踪程序。 continue \[ignore-count\] c \[ignore-count\] fg \[ignore-count\] 恢复程序运行，直到程序结束，或是下一个断点到来。ignore-count表示忽略其后的断点次数。continue，c，fg三个命令都是一样的意思。 step 单步跟踪，如果有函数调用，他会进入该函数。进入函数的前提是，此函数被编译有debug信息。很像VC等工具中的step in。后面可以加count也可以不加，不加表示一条条地执行，加表示执行后面的count条指令，然后再停住。 next 同样单步跟踪，如果有函数调用，他不会进入该函数。很像VC等工具中的step over。后面可以加count也可以不加，不加表示一条条地执行，加表示执行后面的count条指令，然后再停住。 set step-mode set step-mode on 打开step-mode模式，于是，在进行单步跟踪时，程序不会因为没有debug信息而不停住。这个参数有很利于查看机器码。 set step-mod off 关闭step-mode模式。 finish 运行程序，直到当前函数完成返回。并打印函数返回时的堆栈地址和返回值及参数值等信息。 until 或 u 当你厌倦了在一个循环体内单步跟踪时，这个命令可以运行程序直到退出循环体。 stepi 或 si nexti 或 ni 单步跟踪一条机器指令！一条程序代码有可能由数条机器指令完成，stepi和nexti可以单步执行机器指令。与之一样有相同功能的命令是“display/i $pc” ，当运行完这个命令后，单步跟踪会在打出程序代码的同时打出机器指令（也就是汇编代码）九、信号（Signals）信号是一种软中断，是一种处理异步事件的方法。一般来说，操作系统都支持许多信号。尤其是UNIX，比较重要应用程序一般都会处理信号。UNIX定义了许多信号，比如SIGINT表示中断字符信号，也就是Ctrl+C的信号，SIGBUS表示硬件故障的信号；SIGCHLD表示子进程状态改变信号；SIGKILL表示终止程序运行的信号，等等。信号量编程是UNIX下非常重要的一种技术。 GDB有能力在你调试程序的时候处理任何一种信号，你可以告诉GDB需要处理哪一种信号。你可以要求GDB收到你所指定的信号时，马上停住正在运行的程序，以供你进行调试。你可以用GDB的handle命令来完成这一功能。 handle <keywords...> 在GDB中定义一个信号处理。信号可以以SIG开头或不以SIG开头，可以用定义一个要处理信号的范围（如：SIGIO-SIGKILL，表示处理从SIGIO信号到SIGKILL的信号，其中包括SIGIO，SIGIOT，SIGKILL三个信号），也可以使用关键字all来标明要处理所有的信号。一旦被调试的程序接收到信号，运行程序马上会被GDB停住，以供调试。其可以是以下几种关键字的一个或多个。 nostop 当被调试的程序收到信号时，GDB不会停住程序的运行，但会打出消息告诉你收到这种信号。 stop 当被调试的程序收到信号时，GDB会停住你的程序。 print 当被调试的程序收到信号时，GDB会显示出一条信息。 noprint 当被调试的程序收到信号时，GDB不会告诉你收到信号的信息。 pass noignore 当被调试的程序收到信号时，GDB不处理信号。这表示，GDB会把这个信号交给被调试程序会处理。 nopass ignore 当被调试的程序收到信号时，GDB不会让被调试程序来处理这个信号。 info signals info handle 查看有哪些信号在被GDB检测中。十、线程（Thread Stops）如果你程序是多线程的话，你可以定义你的断点是否在所有的线程上，或是在某个特定的线程。GDB很容易帮你完成这一工作。 break thread break thread if ... linespec指定了断点设置在的源程序的行号。threadno指定了线程的ID，注意，这个ID是GDB分配的，你可以通过“info threads”命令来查看正在运行程序中的线程信息。如果你不指定thread 则表示你的断点设在所有线程上面。你还可以为某线程指定断点条件。如： (gdb) break frik.c:13 thread 28 if bartab > lim 当你的程序被GDB停住时，所有的运行线程都会被停住。这方便你你查看运行程序的总体情况。而在你恢复程序运行时，所有的线程也会被恢复运行。那怕是主进程在被单步调试时。查看栈信息 ————— 当程序被停住了，你需要做的第一件事就是查看程序是在哪里停住的。当你的程序调用了一个函数，函数的地址，函数参数，函数内的局部变量都会被压入“栈”（Stack）中。你可以用GDB命令来查看当前的栈中的信息。下面是一些查看函数调用栈信息的GDB命令： backtrace bt 打印当前的函数调用栈的所有信息。如： (gdb) bt \#0 func (n=250) at tst.c:6 \#1 0x08048524 in main (argc=1, argv=0xbffff674) at tst.c:30 \#2 0x400409ed in \_\_libc\_start\_main () from /lib/libc.so.6 从上可以看出函数的调用栈信息：\_\_libc\_start\_main --> main() --> func() backtrace bt n是一个正整数，表示只打印栈顶上n层的栈信息。 backtrace <-n> bt <-n> -n表一个负整数，表示只打印栈底下n层的栈信息。如果你要查看某一层的信息，你需要在切换当前的栈，一般来说，程序停止时，最顶层的栈就是当前栈，如果你要查看栈下面层的详细信息，首先要做的是切换当前栈。 frame f n是一个从0开始的整数，是栈中的层编号。比如：frame 0，表示栈顶，frame 1，表示栈的第二层。 up 表示向栈的上面移动n层，可以不打n，表示向上移动一层。 down 表示向栈的下面移动n层，可以不打n，表示向下移动一层。上面的命令，都会打印出移动到的栈层的信息。如果你不想让其打出信息。你可以使用这三个命令： select-frame 对应于 frame 命令。 up-silently 对应于 up 命令。 down-silently 对应于 down 命令。查看当前栈层的信息，你可以用以下GDB命令： frame 或 f 会打印出这些信息：栈的层编号，当前的函数名，函数参数值，函数所在文件及行号，函数执行到的语句。 info frame info f 这个命令会打印出更为详细的当前栈层的信息，只不过，大多数都是运行时的内内地址。比如：函数地址，调用函数的地址，被调用函数的地址，目前的函数是由什么样的程序语言写成的、函数参数地址及值、局部变量的地址等等。如： (gdb) info f Stack level 0, frame at 0xbffff5d4: eip = 0x804845d in func (tst.c:6); saved eip 0x8048524 called by frame at 0xbffff60c source language c. Arglist at 0xbffff5d4, args: n=250 Locals at 0xbffff5d4, Previous frame's sp is 0x0 Saved registers: ebp at 0xbffff5d4, eip at 0xbffff5d8 info args 打印出当前函数的参数名及其值。 info locals 打印出当前函数中所有局部变量及其值。 info catch 打印出当前的函数中的异常处理信息。查看源程序 ————— 一、显示源代码 GDB 可以打印出所调试程序的源代码，当然，在程序编译时一定要加上-g的参数，把源程序信息编译到执行文件中。不然就看不到源程序了。当程序停下来以后，GDB会报告程序停在了那个文件的第几行上。你可以用list命令来打印程序的源代码。还是来看一看查看源代码的GDB命令吧。 list 显示程序第linenum行的周围的源程序。 list 显示函数名为function的函数的源程序。 list 显示当前行后面的源程序。 list - 显示当前行前面的源程序。一般是打印当前行的上5行和下5行，如果显示函数是是上2行下8行，默认是10行，当然，你也可以定制显示的范围，使用下面命令可以设置一次显示源程序的行数。 set listsize 设置一次显示源代码的行数。 show listsize 查看当前listsize的设置。 list命令还有下面的用法： list , 显示从first行到last行之间的源代码。 list , 显示从当前行到last行之间的源代码。 list + 往后显示源代码。一般来说在list后面可以跟以下这们的参数：行号。 <+offset> 当前行号的正偏移量。 <-offset> 当前行号的负偏移量。哪个文件的哪一行。函数名。哪个文件中的哪个函数。 <\*address> 程序运行时的语句在内存中的地址。二、搜索源代码不仅如此，GDB还提供了源代码搜索的命令： forward-search search 向前面搜索。 reverse-search 全部搜索。其中，就是正则表达式，也主一个字符串的匹配模式，关于正则表达式，我就不在这里讲了，还请各位查看相关资料。三、指定源文件的路径某些时候，用-g编译过后的执行程序中只是包括了源文件的名字，没有路径名。GDB提供了可以让你指定源文件的路径的命令，以便GDB进行搜索。 directory <dirname ... > dir <dirname ... > 加一个源文件路径到当前路径的前面。如果你要指定多个路径，UNIX下你可以使用“:”，Windows下你可以使用“;”。 directory 清除所有的自定义的源文件搜索路径信息。 show directories 显示定义了的源文件搜索路径。四、源代码的内存你可以使用info line命令来查看源代码在内存中的地址。info line后面可以跟“行号”，“函数名”，“文件名:行号”，“文件名:函数名”，这个命令会打印出所指定的源码在运行时的内存地址，如： (gdb) info line tst.c:func Line 5 of "tst.c" starts at address 0x8048456 <func+6> and ends at 0x804845d <func+13>. 还有一个命令（disassemble）你可以查看源程序的当前执行时的机器码，这个命令会把目前内存中的指令dump出来。如下面的示例表示查看函数func的汇编代码。 (gdb) disassemble func Dump of assembler code for function func: 0x8048450 : push %ebp 0x8048451 <func+1>: mov %esp,%ebp 0x8048453 <func+3>: sub $0x18,%esp 0x8048456 <func+6>: movl $0x0,0xfffffffc(%ebp) 0x804845d <func+13>: movl $0x1,0xfffffff8(%ebp) 0x8048464 <func+20>: mov 0xfffffff8(%ebp),%eax 0x8048467 <func+23>: cmp 0x8(%ebp),%eax 0x804846a <func+26>: jle 0x8048470 <func+32> 0x804846c <func+28>: jmp 0x8048480 <func+48> 0x804846e <func+30>: mov %esi,%esi 0x8048470 <func+32>: mov 0xfffffff8(%ebp),%eax 0x8048473 <func+35>: add %eax,0xfffffffc(%ebp) 0x8048476 <func+38>: incl 0xfffffff8(%ebp) 0x8048479 <func+41>: jmp 0x8048464 <func+20> 0x804847b <func+43>: nop 0x804847c <func+44>: lea 0x0(%esi,1),%esi 0x8048480 <func+48>: mov 0xfffffffc(%ebp),%edx 0x8048483 <func+51>: mov %edx,%eax 0x8048485 <func+53>: jmp 0x8048487 <func+55> 0x8048487 <func+55>: mov %ebp,%esp 0x8048489 <func+57>: pop %ebp 0x804848a <func+58>: ret End of assembler dump. 查看运行时数据 ——————— 在你调试程序时，当程序被停住时，你可以使用print命令（简写命令为p），或是同义命令inspect来查看当前程序的运行数据。print命令的格式是： print print / 是表达式，是你所调试的程序的语言的表达式（GDB可以调试多种编程语言），是输出的格式，比如，如果要把表达式按16进制的格式输出，那么就是/x。一、表达式 print和许多GDB的命令一样，可以接受一个表达式，GDB会根据当前的程序运行的数据来计算这个表达式，既然是表达式，那么就可以是当前程序运行中的const常量、变量、函数等内容。可惜的是GDB不能使用你在程序中所定义的宏。表达式的语法应该是当前所调试的语言的语法，由于C/C+*是一种大众型的语言，所以，本文中的例子都是关于C/C*+的。（而关于用GDB调试其它语言的章节，我将在后面介绍）在表达式中，有几种GDB所支持的操作符，它们可以用在任何一种语言中。 @ 是一个和数组有关的操作符，在后面会有更详细的说明。 :: 指定一个在文件或是一个函数中的变量。 {} 表示一个指向内存地址的类型为type的一个对象。二、程序变量在GDB中，你可以随时查看以下三种变量的值： 1、全局变量（所有文件可见的） 2、静态全局变量（当前文件可见的） 3、局部变量（当前Scope可见的）如果你的局部变量和全局变量发生冲突（也就是重名），一般情况下是局部变量会隐藏全局变量，也就是说，如果一个全局变量和一个函数中的局部变量同名时，如果当前停止点在函数中，用print显示出的变量的值会是函数中的局部变量的值。如果此时你想查看全局变量的值时，你可以使用“::”操作符： file::variable function::variable 可以通过这种形式指定你所想查看的变量，是哪个文件中的或是哪个函数中的。例如，查看文件f2.c中的全局变量x的值： gdb) p 'f2.c'::x 当然，“::”操作符会和C+*中的发生冲突，GDB能自动识别“::” 是否C的操作符，所以你不必担心在调试C*+程序时会出现异常。另外，需要注意的是，如果你的程序编译时开启了优化选项，那么在用GDB调试被优化过的程序时，可能会发生某些变量不能访问，或是取值错误码的情况。这个是很正常的，因为优化程序会删改你的程序，整理你程序的语句顺序，剔除一些无意义的变量等，所以在GDB调试这种程序时，运行时的指令和你所编写指令就有不一样，也就会出现你所想象不到的结果。对付这种情况时，需要在编译程序时关闭编译优化。一般来说，几乎所有的编译器都支持编译优化的开关，例如，GNU的C/C++编译器GCC，你可以使用“-gstabs”选项来解决这个问题。关于编译器的参数，还请查看编译器的使用说明文档。三、数组有时候，你需要查看一段连续的内存空间的值。比如数组的一段，或是动态分配的数据的大小。你可以使用GDB的“`”操作符，“`”的左边是第一个内存的地址的值，“@”的右边则你想查看内存的长度。例如，你的程序中有这样的语句： int **array = (int**) malloc (len \* sizeof (int)); 于是，在GDB调试过程中，你可以以如下命令显示出这个动态数组的取值： p \*array@len @的左边是数组的首地址的值，也就是变量array所指向的内容，右边则是数据的长度，其保存在变量len中，其输出结果，大约是下面这个样子的： (gdb) p \*array@len $1 = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40} 如果是静态数组的话，可以直接用print数组名，就可以显示数组中所有数据的内容了。四、输出格式一般来说，GDB会根据变量的类型输出变量的值。但你也可以自定义GDB的输出的格式。例如，你想输出一个整数的十六进制，或是二进制来查看这个整型变量的中的位的情况。要做到这样，你可以使用GDB的数据显示格式： x 按十六进制格式显示变量。 d 按十进制格式显示变量。 u 按十六进制格式显示无符号整型。 o 按八进制格式显示变量。 t 按二进制格式显示变量。 a 按十六进制格式显示变量。 c 按字符格式显示变量。 f 按浮点数格式显示变量。 (gdb) p i $21 = 101 (gdb) p/a i $22 = 0x65 (gdb) p/c i $23 = 101 'e' (gdb) p/f i $24 = 1.41531145e-43 (gdb) p/x i $25 = 0x65 (gdb) p/t i $26 = 1100101 五、查看内存你可以使用examine命令（简写是x）来查看内存地址中的值。x命令的语法如下所示： x/<n/f/u> n、f、u是可选的参数。 n 是一个正整数，表示显示内存的长度，也就是说从当前地址向后显示几个地址的内容。 f 表示显示的格式，参见上面。如果地址所指的是字符串，那么格式可以是s，如果地十是指令地址，那么格式可以是i。 u 表示从当前地址往后请求的字节数，如果不指定的话，GDB默认是4个bytes。u参数可以用下面的字符来代替，b表示单字节，h表示双字节，w表示四字节，g表示八字节。当我们指定了字节长度后，GDB会从指内存定的内存地址开始，读写指定字节，并把其当作一个值取出来。表示一个内存地址。 n/f/u三个参数可以一起使用。例如：命令：x/3uh 0x54320 表示，从内存地址0x54320读取内容，h表示以双字节为一个单位，3表示三个单位，u表示按十六进制显示。六、自动显示你可以设置一些自动显示的变量，当程序停住时，或是在你单步跟踪时，这些变量会自动显示。相关的GDB命令是display。 display display/ display/ expr是一个表达式，fmt表示显示的格式，addr表示内存地址，当你用display设定好了一个或多个表达式后，只要你的程序被停下来，GDB会自动显示你所设置的这些表达式的值。格式i和s同样被display支持，一个非常有用的命令是： display/i $pc $pc是GDB的环境变量，表示着指令的地址，/i则表示输出格式为机器指令码，也就是汇编。于是当程序停下后，就会出现源代码和机器指令码相对应的情形，这是一个很有意思的功能。下面是一些和display相关的GDB命令： undisplay <dnums...> delete display <dnums...> 删除自动显示，dnums意为所设置好了的自动显式的编号。如果要同时删除几个，编号可以用空格分隔，如果要删除一个范围内的编号，可以用减号表示（如：2-5） disable display <dnums...> enable display <dnums...> disable和enalbe不删除自动显示的设置，而只是让其失效和恢复。 info display 查看display设置的自动显示的信息。GDB会打出一张表格，向你报告当然调试中设置了多少个自动显示设置，其中包括，设置的编号，表达式，是否enable。七、设置显示选项 GDB中关于显示的选项比较多，这里我只例举大多数常用的选项。 set print address set print address on 打开地址输出，当程序显示函数信息时，GDB会显出函数的参数地址。系统默认为打开的，如： (gdb) f \#0 set\_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>") at input.c:530 530 if (lquote != def\_lquote) set print address off 关闭函数的参数地址显示，如： (gdb) set print addr off (gdb) f \#0 set\_quotes (lq="<<", rq=">>") at input.c:530 530 if (lquote != def\_lquote) show print address 查看当前地址显示选项是否打开。 set print array set print array on 打开数组显示，打开后当数组显示时，每个元素占一行，如果不打开的话，每个元素则以逗号分隔。这个选项默认是关闭的。与之相关的两个命令如下，我就不再多说了。 set print array off show print array set print elements 这个选项主要是设置数组的，如果你的数组太大了，那么就可以指定一个来指定数据显示的最大长度，当到达这个长度时，GDB就不再往下显示了。如果设置为0，则表示不限制。 show print elements 查看print elements的选项信息。 set print null-stop <on/off> 如果打开了这个选项，那么当显示字符串时，遇到结束符则停止显示。这个选项默认为off。 set print pretty on 如果打开printf pretty这个选项，那么当GDB显示结构体时会比较漂亮。如： $1 = { next = 0x0, flags = { sweet = 1, sour = 1 }, meat = 0x54 "Pork" } set print pretty off 关闭printf pretty这个选项，GDB显示结构体时会如下显示： $1 = {next = 0x0, flags = {sweet = 1, sour = 1}, meat = 0x, 54 "Pork"} show print pretty 查看GDB是如何显示结构体的。 set print sevenbit-strings <on/off> 设置字符显示，是否按“\\nnn”的格式显示，如果打开，则字符串或字符数据按\\nnn显示，如“\\065”。 show print sevenbit-strings 查看字符显示开关是否打开。 set print union <on/off> 设置显示结构体时，是否显式其内的联合体数据。例如有以下数据结构： typedef enum {Tree, Bug} Species; typedef enum {Big\_tree, Acorn, Seedling} Tree\_forms; typedef enum {Caterpillar, Cocoon, Butterfly} Bug\_forms; struct thing { Species it; union { Tree\_forms tree; Bug\_forms bug; } form; }; struct thing foo = {Tree, {Acorn}}; 当打开这个开关时，执行 p foo 命令后，会如下显示： $1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}} 当关闭这个开关时，执行 p foo 命令后，会如下显示： $1 = {it = Tree, form = {...}} show print union 查看联合体数据的显示方式 set print object <on/off> 在C++中，如果一个对象指针指向其派生类，如果打开这个选项，GDB会自动按照虚方法调用的规则显示输出，如果关闭这个选项的话，GDB就不管虚函数表了。这个选项默认是off。 show print object 查看对象选项的设置。 set print static-members <on/off> 这个选项表示，当显示一个C++对象中的内容是，是否显示其中的静态数据成员。默认是on。 show print static-members 查看静态数据成员选项设置。 set print vtbl <on/off> 当此选项打开时，GDB将用比较规整的格式来显示虚函数表时。其默认是关闭的。 show print vtbl 查看虚函数显示格式的选项。八、历史记录当你用GDB的print查看程序运行时的数据时，你每一个print都会被GDB记录下来。GDB会以$1, $2, $3 .....这样的方式为你每一个print命令编上号。于是，你可以使用这个编号访问以前的表达式，如$1。这个功能所带来的好处是，如果你先前输入了一个比较长的表达式，如果你还想查看这个表达式的值，你可以使用历史记录来访问，省去了重复输入。九、GDB环境变量你可以在GDB的调试环境中定义自己的变量，用来保存一些调试程序中的运行数据。要定义一个GDB的变量很简单只需。使用GDB的set命令。GDB的环境变量和UNIX一样，也是以$起头。如： set $foo = \*object\_ptr 使用环境变量时，GDB会在你第一次使用时创建这个变量，而在以后的使用中，则直接对其賦值。环境变量没有类型，你可以给环境变量定义任一的类型。包括结构体和数组。 show convenience 该命令查看当前所设置的所有的环境变量。这是一个比较强大的功能，环境变量和程序变量的交互使用，将使得程序调试更为灵活便捷。例如： set $i = 0 print bar\[$i**\]->contents 于是，当你就不必，print bar\[0\]~~contents, print bar\[1\]~~>contents地输入命令了。输入这样的命令后，只用敲回车，重复执行上一条语句，环境变量会自动累加，从而完成逐个输出的功能。十、查看寄存器要查看寄存器的值，很简单，可以使用如下命令： info registers 查看寄存器的情况。（除了浮点寄存器） info all-registers 查看所有寄存器的情况。（包括浮点寄存器） info registers <regname ...> 查看所指定的寄存器的情况。寄存器中放置了程序运行时的数据，比如程序当前运行的指令地址（ip），程序的当前堆栈地址（sp）等等。你同样可以使用print命令来访问寄存器的情况，只需要在寄存器名字前加一个$符号就可以了。如：p $eip。改变程序的执行 ——————— 一旦使用GDB挂上被调试程序，当程序运行起来后，你可以根据自己的调试思路来动态地在GDB中更改当前被调试程序的运行线路或是其变量的值，这个强大的功能能够让你更好的调试你的程序，比如，你可以在程序的一次运行中走遍程序的所有分支。一、修改变量值修改被调试程序运行时的变量值，在GDB中很容易实现，使用GDB的print命令即可完成。如： (gdb) print x=4 x=4这个表达式是C/C++的语法，意为把变量x的值修改为4，如果你当前调试的语言是Pascal，那么你可以使用Pascal的语法：x:=4。在某些时候，很有可能你的变量和GDB中的参数冲突，如： (gdb) whatis width type = double (gdb) p width $4 = 13 (gdb) set width=47 Invalid syntax in expression. 因为，set width是GDB的命令，所以，出现了“Invalid syntax in expression”的设置错误，此时，你可以使用set var命令来告诉GDB，width不是你GDB的参数，而是程序的变量名，如： (gdb) set var width=47 另外，还可能有些情况，GDB并不报告这种错误，所以保险起见，在你改变程序变量取值时，最好都使用set var格式的GDB命令。二、跳转执行一般来说，被调试程序会按照程序代码的运行顺序依次执行。GDB提供了乱序执行的功能，也就是说，GDB可以修改程序的执行顺序，可以让程序执行随意跳跃。这个功能可以由GDB的jump命令来完： jump 指定下一条语句的运行点。可以是文件的行号，可以是file:line格式，可以是+num这种偏移量格式。表式着下一条运行语句从哪里开始。 jump

这里的

是代码行的内存地址。注意，jump命令不会改变当前的程序栈中的内容，所以，当你从一个函数跳到另一个函数时，当函数运行完返回时进行弹栈操作时必然会发生错误，可能结果还是非常奇怪的，甚至于产生程序Core Dump。所以最好是同一个函数中进行跳转。熟悉汇编的人都知道，程序运行时，有一个寄存器用于保存当前代码所在的内存地址。所以，jump命令也就是改变了这个寄存器中的值。于是，你可以使用“set $pc”来更改跳转执行的地址。如： set $pc = 0x485 三、产生信号量使用singal命令，可以产生一个信号量给被调试的程序。如：中断信号Ctrl+C。这非常方便于程序的调试，可以在程序运行的任意位置设置断点，并在该断点用GDB产生一个信号量，这种精确地在某处产生信号非常有利程序的调试。语法是：signal ，UNIX的系统信号量通常从1到15。所以取值也在这个范围。 single命令和shell的kill命令不同，系统的kill命令发信号给被调试程序时，是由GDB截获的，而single命令所发出一信号则是直接发给被调试程序的。四、强制函数返回如果你的调试断点在某个函数中，并还有语句没有执行完。你可以使用return命令强制函数忽略还没有执行的语句并返回。 return return 使用return命令取消当前函数的执行，并立即返回，如果指定了，那么该表达式的值会被认作函数的返回值。五、强制调用函数 call 表达式中可以一是函数，以此达到强制调用函数的目的。并显示函数的返回值，如果函数返回值是void，那么就不显示。另一个相似的命令也可以完成这一功能——print，print后面可以跟表达式，所以也可以用他来调用函数，print和call的不同是，如果函数返回void，call则不显示，print则显示函数返回值，并把该值存入历史数据中。在不同语言中使用GDB —————————— GDB支持下列语言：C, C**, Fortran, PASCAL, Java, Chill, assembly, 和 Modula-2。一般说来，GDB会根据你所调试的程序来确定当然的调试语言，比如：发现文件名后缀为“.c”的，GDB会认为是C程序。文件名后缀为“.C, .cc, .cp, .cpp, .cxx, .c**”的，GDB会认为是C++程序。而后缀是“.f, .F”的，GDB会认为是Fortran程序，还有，后缀为如果是“.s, .S”的会认为是汇编语言。也就是说，GDB会根据你所调试的程序的语言，来设置自己的语言环境，并让GDB的命令跟着语言环境的改变而改变。比如一些GDB命令需要用到表达式或变量时，这些表达式或变量的语法，完全是根据当前的语言环境而改变的。例如C/C++中对指针的语法是\*p，而在Modula-2中则是p^。并且，如果你当前的程序是由几种不同语言一同编译成的，那到在调试过程中，GDB也能根据不同的语言自动地切换语言环境。这种跟着语言环境而改变的功能，真是体贴开发人员的一种设计。下面是几个相关于GDB语言环境的命令： show language 查看当前的语言环境。如果GDB不能识为你所调试的编程语言，那么，C语言被认为是默认的环境。 info frame 查看当前函数的程序语言。 info source 查看当前文件的程序语言。如果GDB没有检测出当前的程序语言，那么你也可以手动设置当前的程序语言。使用set language命令即可做到。当set language命令后什么也不跟的话，你可以查看GDB所支持的语言种类： (gdb) set language The currently understood settings are: local or auto Automatic setting based on source file c Use the C language c** Use the C** language asm Use the Asm language chill Use the Chill language fortran Use the Fortran language java Use the Java language modula-2 Use the Modula-2 language pascal Use the Pascal language scheme Use the Scheme language 于是你可以在set language后跟上被列出来的程序语言名，来设置当前的语言环境。后记 —— GDB是一个强大的命令行调试工具。大家知道命令行的强大就是在于，其可以形成执行序列，形成脚本。UNIX下的软件全是命令行的，这给程序开发提代供了极大的便利，命令行软件的优势在于，它们可以非常容易的集成在一起，使用几个简单的已有工具的命令，就可以做出一个非常强大的功能。于是UNIX下的软件比Windows下的软件更能有机地结合，各自发挥各自的长处，组合成更为强劲的功能。而Windows下的图形软件基本上是各自为营，互相不能调用，很不利于各种软件的相互集成。在这里并不是要和Windows做个什么比较，所谓“寸有所长，尺有所短”，图形化工具还是有不如命令行的地方。（看到这句话时，希望各位千万再也不要认为我就是“鄙视图形界面”，和我抬杠了）我是根据版本为5.1.1的GDB所写的这篇文章，所以可能有些功能已被修改，或是又有更为强劲的功能。而且，我写得非常仓促，写得比较简略，并且，其中我已经看到有许多错别字了（我用五笔，所以错字让你看不懂），所以，我在这里对我文中的差错表示万分的歉意。文中所罗列的GDB的功能时，我只是罗列了一些带用的GDB的命令和使用方法，其实，我这里只讲述的功能大约只占GDB所有功能的60%吧，详细的文档，还是请查看GDB的帮助和使用手册吧，或许，过段时间，如果我有空，我再写一篇GDB的高级使用。我个人非常喜欢GDB的自动调试的功能，这个功能真的很强大，试想，我在UNIX下写个脚本，让脚本自动编译我的程序，被自动调试，并把结果报告出来，调试成功，自动checkin源码库。一个命令，编译带着调试带着checkin，多爽啊。只是GDB对自动化调试目前支持还不是很成熟，只能实现半自动化，真心期望着GDB的自动化调试功能的成熟。如果各位对GDB或是别的技术问题有兴趣的话，欢迎和我讨论交流。本人目前主要在UNIX下做产品软件的开发，所以，对UNIX下的软件开发比较熟悉，当然，不单单是技术，对软件工程实施，软件设计，系统分析，

GDB调试精粹及使用实例

2011-09-16T00:00:00+00:00

http://mikev.blog.163.com/blog/static/39911080200781564718746/

GNU的调试器称为gdb，该程序是一个交互式工具，工作在字符模式。在 X Window 系统中，有一个gdb的前端图形工具，称为xxgdb。gdb 是功能强大的调试程序，可完成如下的调试任务：　　* 设置断点；　　* 监视程序变量的值；　　* 程序的单步执行；　　* 修改变量的值。　　在可以使用 gdb 调试程序之前，必须使用 -g 选项编译源文件。可在 makefile 中如下定义 CFLAGS 变量：　　 CFLAGS = -g 　　运行 gdb 调试程序时通常使用如下的命令：　　 gdb progname

　　在 gdb 提示符处键入help，将列出命令的分类，主要的分类有：　　* aliases：命令别名　　* breakpoints：断点定义；　　* data：数据查看；　　* files：指定并查看文件；　　* internals：维护命令；　　* running：程序执行；　　* stack：调用栈查看；　　* statu：状态查看；　　* tracepoints：跟踪程序执行。　　键入 help 后跟命令的分类名，可获得该类命令的详细清单。

gdb 的常用命令命令解释　　break NUM 在指定的行上设置断点。　　bt 显示所有的调用栈帧。该命令可用来显示函数的调用顺序。　　clear 删除设置在特定源文件、特定行上的断点。其用法为clear FILENAME:NUM 　　continue 继续执行正在调试的程序。该命令用在程序由于处理信号或断点而导致停止运行时。　　display EXPR 每次程序停止后显示表达式的值。表达式由程序定义的变量组成。　　file FILE 装载指定的可执行文件进行调试。　　help NAME 显示指定命令的帮助信息。　　info break 显示当前断点清单，包括到达断点处的次数等。　　info files 显示被调试文件的详细信息。　　info func 显示所有的函数名称。　　info local 显示当函数中的局部变量信息。　　info prog 显示被调试程序的执行状态。　　info var 显示所有的全局和静态变量名称。　　kill 终止正被调试的程序。　　list 显示源代码段。　　make 在不退出 gdb 的情况下运行 make 工具。　　next 在不单步执行进入其他函数的情况下，向前执行一行源代码。　　print EXPR 显示表达式 EXPR 的值。

gdb 使用范例

清单一个有错误的 C 源程序 bugging.c 代码:

1　＃i nclude 2 3　static char buff [256]; 4　static char* string; 5　int main () 6　{ 7　　　printf (“Please input a string: “); 8　　　gets (string);　　 9　　 printf (“\nYour string is: %s\n”, string); 10 }

　上面这个程序非常简单，其目的是接受用户的输入，然后将用户的输入打印出来。该程序使用了一个未经过初始化的字符串地址 string，因此，编译并运行之后，将出现 Segment Fault 错误： $ gcc -o bugging -g bugging.c $ ./bugging Please input a string: asfd Segmentation fault (core dumped) 为了查找该程序中出现的问题，我们利用 gdb，并按如下的步骤进行： 1．运行 gdb bugging 命令，装入 bugging 可执行文件； 2．执行装入的 bugging 命令 run； 3．使用 where 命令查看程序出错的地方； 4．利用 list 命令查看调用 gets 函数附近的代码； 5．唯一能够导致 gets 函数出错的因素就是变量 string。用print命令查看 string 的值； 6．在 gdb 中，我们可以直接修改变量的值，只要将 string 取一个合法的指针值就可以了，为此，我们在第8行处设置断点 break 8； 7．程序重新运行到第 8行处停止，这时，我们可以用 set variable 命令修改 string 的取值； 8．然后继续运行，将看到正确的程序运行结果。

一：列文件清单 1． List (gdb) list line1,line2

二：执行程序要想运行准备调试的程序，可使用run命令，在它后面可以跟随发给该程序的任何参数，包括标准输入和标准输出说明符(<和>)和外壳通配符（\*、？、\[、\]）在内。如果你使用不带参数的run命令，gdb就再次使用你给予前一条run命令的参数，这是很有用的。利用set args 命令就可以修改发送给程序的参数，而使用show args 命令就可以查看其缺省参数的列表。（gdb）set args –b –x (gdb) show args backtrace命令为堆栈提供向后跟踪功能。 Backtrace 命令产生一张列表，包含着从最近的过程开始的所以有效过程和调用这些过程的参数。

三：显示数据利用print 命令可以检查各个变量的值。 (gdb) print p (p为变量名) whatis 命令可以显示某个变量的类型 (gdb) whatis p type = int *

print 是gdb的一个功能很强的命令，利用它可以显示被调试的语言中任何有效的表达式。表达式除了包含你程序中的变量外，还可以包含以下内容： l 对程序中函数的调用 (gdb) print find_entry(1,0) l 数据结构和其他复杂对象 (gdb) print *table_start $8={e=reference=’\000’,location=0x0,next=0x0} l 值的历史成分 (gdb)print $1 ($1为历史记录变量,在以后可以直接引用 $1 的值) l 人为数组人为数组提供了一种去显示存储器块（数组节或动态分配的存储区）内容的方法。早期的调试程序没有很好的方法将任意的指针换成一个数组。就像对待参数一样，让我们查看内存中在变量h后面的10个整数，一个动态数组的语法如下所示： base@length 因此，要想显示在h后面的10个元素，可以使用h@10： (gdb)print h@10 $13=(-1,345,23,-234,0,0,0,98,345,10)

四：断点(breakpoint) break命令（可以简写为b）可以用来在调试的程序中设置断点，该命令有如下四种形式： l break line-number 使程序恰好在执行给定行之前停止。 l break function-name 使程序恰好在进入指定的函数之前停止。 l break line-or-function if condition 如果condition（条件）是真，程序到达指定行或函数时停止。 l break routine-name 在指定例程的入口处设置断点

如果该程序是由很多原文件构成的，你可以在各个原文件中设置断点，而不是在当前的原文件中设置断点，其方法如下： (gdb) break filename:line-number (gdb) break filename:function-name

要想设置一个条件断点，可以利用break if命令，如下所示： (gdb) break line-or-function if expr 例： (gdb) break 46 if testsize==100

从断点继续运行：countinue 命令五．断点的管理

1．显示当前gdb的断点信息： (gdb) info break 他会以如下的形式显示所有的断点信息： Num Type Disp Enb Address What 1 breakpoint keep y 0x000028bc in init_random at qsort2.c:155 2 breakpoint keep y 0x0000291c in init_organ at qsort2.c:168 (gdb) 2.删除指定的某个断点： (gdb) delete breakpoint 1 该命令将会删除编号为1的断点，如果不带编号参数，将删除所有的断点 (gdb) delete breakpoint 3.禁止使用某个断点 (gdb) disable breakpoint 1 该命令将禁止断点 1,同时断点信息的 (Enb)域将变为 n 4．允许使用某个断点 (gdb) enable breakpoint 1 该命令将允许断点 1,同时断点信息的 (Enb)域将变为 y 5．清除原文件中某一代码行上的所有断点 (gdb)clean number 注：number 为原文件的某个代码行的行号六．变量的检查和赋值 l whatis:识别数组或变量的类型 l ptype:比whatis的功能更强，他可以提供一个结构的定义 l set variable:将值赋予变量 l print 除了显示一个变量的值外，还可以用来赋值

七．单步执行 l next 不进入的单步执行 l step 进入的单步执行如果已经进入了某函数，而想退出该函数返回到它的调用函数中，可使用命令finish 八．函数的调用 l call name 调用和执行一个函数 (gdb) call gen_and_sork( 1234,1,0 ) (gdb) call printf(“abcd”) $1=4 l finish 结束执行当前函数，显示其返回值（如果有的话）

九．机器语言工具有一组专用的gdb变量可以用来检查和修改计算机的通用寄存器，gdb提供了目前每一台计算机中实际使用的4个寄存器的标准名字： l $pc ：程序计数器 l $fp ：帧指针（当前堆栈帧） l $sp ：栈指针 l $ps ：处理器状态

十．信号 gdb通常可以捕捉到发送给它的大多数信号，通过捕捉信号，它就可决定对于正在运行的进程要做些什么工作。例如，按CTRL-C将中断信号发送给gdb，通常就会终止gdb。但是你或许不想中断gdb，真正的目的是要中断gdb正在运行的程序，因此，gdb要抓住该信号并停止它正在运行的程序，这样就可以执行某些调试操作。

Handle命令可控制信号的处理，他有两个参数，一个是信号名，另一个是接受到信号时该作什么。几种可能的参数是： l nostop 接收到信号时，不要将它发送给程序，也不要停止程序。 l stop 接受到信号时停止程序的执行，从而允许程序调试；显示一条表示已接受到信号的消息（禁止使用消息除外） l print 接受到信号时显示一条消息 l noprint 接受到信号时不要显示消息（而且隐含着不停止程序运行） l pass 将信号发送给程序，从而允许你的程序去处理它、停止运行或采取别的动作。 l nopass 停止程序运行，但不要将信号发送给程序。例如，假定你截获SIGPIPE信号，以防止正在调试的程序接受到该信号，而且只要该信号一到达，就要求该程序停止，并通知你。要完成这一任务，可利用如下命令： (gdb) handle SIGPIPE stop print 请注意，UNIX的信号名总是采用大写字母！你可以用信号编号替代信号名如果你的程序要执行任何信号处理操作，就需要能够测试其信号处理程序，为此，就需要一种能将信号发送给程序的简便方法，这就是signal命令的任务。该命令的参数是一个数字或者一个名字，如SIGINT。假定你的程序已将一个专用的SIGINT（键盘输入，或CTRL-C；信号2）信号处理程序设置成采取某个清理动作，要想测试该信号处理程序，你可以设置一个断点并使用如下命令：（gdb） signal 2 continuing with signal SIGINT (2) 该程序继续执行，但是立即传输该信号，而且处理程序开始运行.

十一. 原文件的搜索 search text:该命令可显示在当前文件中包含text串的下一行。 Reverse-search text:该命令可以显示包含text 的前一行。

十二.UNIX接口 shell 命令可启动UNIX外壳，CTRL-D退出外壳，返回到 gdb.

十三.命令的历史为了允许使用历史命令，可使用 set history expansion on 命令 (gdb) set history expansion on

小结：常用的gdb命令 backtrace 显示程序中的当前位置和表示如何到达当前位置的栈跟踪（同义词：where） breakpoint 在程序中设置一个断点 cd 改变当前工作目录 clear 删除刚才停止处的断点 commands 命中断点时，列出将要执行的命令 continue 从断点开始继续执行 delete 删除一个断点或监测点；也可与其他命令一起使用 display 程序停止时显示变量和表达时 down 下移栈帧，使得另一个函数成为当前函数 frame 选择下一条continue命令的帧 info 显示与该程序有关的各种信息 jump 在源程序中的另一点开始运行 kill 异常终止在gdb 控制下运行的程序 list 列出相应于正在执行的程序的原文件内容 next 执行下一个源程序行，从而执行其整体中的一个函数 print 显示变量或表达式的值 pwd 显示当前工作目录 pype 显示一个数据结构（如一个结构或C++类）的内容 quit 退出gdb reverse-search 在源文件中反向搜索正规表达式 run 执行该程序 search 在源文件中搜索正规表达式 set variable 给变量赋值 signal 将一个信号发送到正在运行的进程 step 执行下一个源程序行，必要时进入下一个函数 undisplay display命令的反命令，不要显示表达式 until 结束当前循环 up 上移栈帧，使另一函数成为当前函数 watch 在程序中设置一个监测点（即数据断点） whatis 显示变量或函数类型 **

咕噜咕噜

2011-08-22T00:00:00+00:00

趣谈教主毁灭星际 GOMTV WCG直到今日FOX

2011-08-22T00:00:00+00:00

作者：天下无狗来源：万丰发布时间：08-22　

当他获得 GOMTV 主办的 Intel Classic 冠军后, GOMTV 不久就退出了星际

当他获得 WCG 冠军后, WCG 不再有星际了

当他获得 SPL 总冠军后, Estro 和 Sparkz 相继解散

当他获得 MSL 冠军拿到金徽章后, MBCGame 转型音乐台的传闻随之而起

当他蝉联 SPL 总冠军并奠定他在星际史上难以超越的地位的时候 ———- 他出身的 Fox 战队也消亡了

水友制作——最终兵器Flash的Highlight

作者：吃肉得吃牛肉来源：plu

WeMadeFOX全队解散：星际被托管魔兽成历史

2011-08-22T00:00:00+00:00

文章所属:星际争霸2资讯作者：佚名来源：网易

WemadeFOX是由韩国网游巨头Wemade娱乐有限公司于2007年所建立的电子竞技职业俱乐部，Wemade娱乐有限公司出品了《传奇2》、《传奇3》、《苍天》、《青燐》、《天堂梦》、《阿凡龙》等著名网游。而WemadeFOX电子竞技俱乐部旗下设有《星际争霸》、《魔兽争霸3》、《反恐精英》分部。 WeMadeFOX前身是PENTECH EX，在2007年Wemade娱乐有限公司与韩亚银行竞争并胜出，从而以“WeMadeFOX”征战星际联赛。但是由于近些年扩张过度，尤其是魔兽3以及反恐精英赛事的日益减少让该战队不堪重负并最终解散。

此前，我们曾报道了韩国著名的电竞战队WeMadeFOX或将解散的消息，如今消息成真，WeMadeFOX将与8月31日后解散旗下全部分部。 WeMadeFOX试图通过打包出售等方式解决战队问题，但均遭失败。运营不佳的WeMadeFOX只能将星际1分部托管给韩国电子竞技协会(KeSPA)，至于魔兽3选手则很可能转型其他项目并被其他战队所吸纳。

WeMadeFOX星际1战队曾是韩国10支职业电竞战队之一，虽然在近几年没有重量级的冠军但也都进入了季后赛(基本上季后赛被一轮)。但如今他们也将被KeSPA所托管直到找到新的战队。

注：在最新的韩国战队积分榜中，WeMadeFOX战队位居第八。昔日WMF星际巨星Nada如今征战GSL：

昔日WeMadeFXO星际巨星Nada如今在星际2发售之后果断转型，目前稳定在GSL S级八强(Nada五次杀入GSL S级16强；4次杀入8强)。并与第一神族MC一起被SK战队所签约(Nada与MC征战海外星际2赛事费用全部由SK承包，但在韩国比赛依然身披oGs队服)。如果星际战队不能找到下家，或许对TY、Mind而言转型星际2是个不错的选择。 WMF魔兽明星前途堪忧：而中国的iG战队此前就曾表示想要引入Moon，王思聪也戏言Moon将转型打DOTA2。但不容否认的是，随着魔兽3赛事的日益减少以及Moon、Lyn在星际2上的糟糕战绩，昔日魔兽大牌在今后的道路可能并不好走。

WeMadeFOX魔兽3分部队员 WemadeFOX魔兽分部解散前阵容： Moon Lyn SocceR WemadeFOX星际分部解散前阵容： TY Mind Midas Major Roro Shine Hero Sacsri Pure Wooki Lucifer WeMadeFOX战队昔日巨星： Nada

inline函数链接报错：LNK2019

2011-08-20T00:00:00+00:00

症状：inline函数链接报错LNK2019,去掉inline后就没有错误了。

解决：把inline函数的实现写到.h文件中就好了。

思考：为什么分开写就报错？

补间动画不播放的问题

2011-08-03T00:00:00+00:00

在fla文件中，使用一个原件（名称”a”），制作一段补间动画。给带有动画的原件”a”，起好实例名称（比如”_a”）。原件做成导出类。编译成swf文件。然后再FlashBuilder的代码中，加载swf后，反序列化后，取出导出类。实例化后，使用实例名称(“_a”)取出开始定义好的原件”a”。

这个时候，只要修改a的位置坐标（即使这个坐标和原始坐标是相同的），那么原来制作的动画，就不再播放了。很奇怪的问题……

星际经典回顾

2011-07-25T00:00:00+00:00

来自plu.cn和网上寻找的资料，有介绍和视频。

人族皇帝SlayerS_BoxeR Highlight

韩国最著名星际争霸职业选手，没有之一。　　姓名：林耀焕　　游戏ID：SLayerS’_‘BoxeR 　　现役：SKT1 　　曾效力过战队：SKT1，AirForce ACE（空军战队）　　国籍：韩国　　种族：Terran 　　地位：SLayerS’_‘BoxeR 之于星际就好像乔丹之于篮球。　　最喜欢的对局:TvZ 　　最喜欢的单位:坦克　　生日：1980年9月4日　　身高：178cm 　　体重：68Kg 　　血型：B型　　爱好：看电影、看漫画　　喜欢的食物：拉面汤(和中国的拉面不同，里面放很多的东西，当然也包括泡菜) 　　印象最深的比赛：可口可乐OSL上击败Yellow(此后他有了“人族皇帝”的称号) 　　最喜欢的游戏：《StarCraft》

他是所有星际FANS口中的’人族皇帝’, 他是世界上最好的电子竞技职业选手, 他对电子竞技事业有不可取代的推动作用, 他在韩国星际争霸联赛中创造了无数的神话,

可以看一下Boxer十大经典战役网上很好搜到

划时代的人物,OSL 2冠 4亚，MSL 1冠（前身KPGA 1st Tour）最先发掘人族精妙操作的人，同时又是人族大招的祖师爷，印象最深的是野兵营（野到july路口）和8bb（8bb帽子戏法3：0淘汰yellow），OSL连冠唯一一人，前SKT灵魂人物，Iloveoov的师傅. 献给Boxer的诗如果我是即将绽放的蔷薇绽放只是因为尝到想念的滋味我要把灵魂出卖给撒旦让你看到永不枯萎的花蕾如果我是即将凋零的玫瑰凋零只是因为尝到寂寞的滋味我要把灵魂出卖给撒旦让你闻到永不褪却的香味

金佳妍简介　　姓名：金佳妍　　生日：1972年9月9日　　身高：164CM 体重：44公斤　　学历：汉阳大学舞蹈系学士　　获奖：2004年第41届大钟奖电影节女演员助演奖　　代表作　　电视：　　1999 MBC《我们真的爱过吗》　　2001 KBS《美丽人生》　　2002 KBS《巷子里的人们》　　2002 KBS《张嬉嫔》　　2004 MBC《花王仙女》　　2004 SBS《巴黎恋人》　　2005 MBC《赤脚的青春》　　2006 SBS《游戏女王》　　2007 KBS《坏爱情》　　电影：　　1998年《下雪的圣诞节》　　2000年《犯规王》　　2000年《错爱双鱼座》　　2004年《洪班长我的百事通男友》　　2007年《荒诞的自杀骚动》

英雄神族Reach Highlight

韩国最著名的星际争霸神族选手，没有之一 id: [oops]reach 姓名：朴正石国籍：韩国生日：1983年12月27日种族：protoss 所属：hanbit soft clan 外号：英雄神族战队：ACE 在神族最低谷的时候，他的神族拯救了无数P user的信心。当你看到在那个Terran鼎盛的时期，他击败boxer，击败iloveoov的时候你就知道，为什么我们都叫他‘英雄神族’。

死神Anytime Highlight

LeCafOZ_AnyTime..[gm] 死神神族　　韩国著名星际争霸职业选手　　姓名：오영종（吴永忠）　　ID：AnyTime[gm] 　　种族：Protoss 　　战队：韩国空军战队(Airforce Team) 曾经效力LeCafOZ（原Plus）　　生日：1986年10月18日　　国家：韩国　　身高：175CM 　　体重：67KG 主要荣誉　　2005年SO1 OSL冠军　　2006年新韩OSL第二赛季亚军　　新韩银行Proleague 2007后期MVP

野兽iloveoov Highlight

<-女帝！ ID：iloveoov 　　昵称：怪兽　　战队：SKTelecomT1 　　游戏项目：星际争霸　　主种族：Terran 　　APM：240 　　姓名：崔然星　　出生：1983年 11月 5日　　身体：身高: 187cm, 体重: 81kg 职业生涯的荣誉　　2003 TG Sambo MSL冠军　　2004 HanaFOS cengame MSL冠军　　2004 Gillette OSL季军　　2004 SPRIS MSL冠军　　2004 EVER OSL冠军　　2005 EVER OSL 8强　　2005 UZOO MSL第四　　2005 SO1 OSL季军　　2005~2006 LG CYON MSL季军　　2005~2006 SinHan OSL冠军　　2006 WCG冠军　　这个成绩是如此变态,以致于令人瞠目结舌,每一个冠军都有极高的含金量,令Nada、Boxer所无法企及。　　他就是iloveoov。

随着状态的不断下滑,iloveoov于2008年2月11日退役，出任SKT1教练一职。同年10月28日再次复出。

梦想家Nal_ra Highlight

姜旼（강민，1982年3月15日－）（Nal_rA），是一位韩国职业星际争霸选手，目前效力KTF战队。他在星际争霸中常用的ID名为Nal_rA。姜旼惯用的星际争霸种族是Protoss。他的称号是“梦想家”（Dreamer），该称号来自于他在比赛中经常使用的一些诸如取消建筑物变换科技路线的奇异战术。

姜旼首次作为职业选手出现在星际舞台是在PGR21锦标赛。他在该赛事中起先表现出色，但最终惨败于Xellos[yG]选手。但他在下一届PGR21卷土重来，一举击败Xellos[yG]。2002年，姜旼获得了奥林巴斯挑战杯联赛（Olympus Challenge League）的参赛权。他在比赛中表现出了极高的技巧和战术，但是最终输给了号称“魔鬼神族”的Kingdom选手。此后，他在MBC联赛中表现神勇，并击败[Red]Nada选手最终夺冠。 2004年4月，姜旼在韩国职业游戏协会的星际争霸排名升至第二位。 2006年2月，他在暴雪娱乐公司举办的世界邀请赛（World Wide Invitational）星际比赛中夺冠。 2006年7月，姜旼夺得MBC联赛第二名。

2003年Stout MSL冠军、2003~2004年NHN Hangame OSL冠军，KTF战队老牌Protoss选手“梦想家

完美人族Xellos Highlight

ID: XellOs[yG] 　　姓名: 徐志勋(Seo Jihoon) 　　种族: Terran 　　生日: 1985年2月9日　　隶属战队: SUMA GO CJ 　　绰号: 完美人族(Perfect Terrran)

之所以叫完美人族，因为2003年左右颠峰时期的XellOs[yG] 集Boxer,Nada,Iloveoov三人族技巧于一身，三者的技术特点在他身上完美的融合在一起，每一种技术不是很突出，但是很完美。颠峰时期的他对抗3个族的战绩都很平衡，胜率都在60%以上（被称为“Triple60成员”，Triple60成员是指在顶级联赛中对各种族胜率在60%以上的选手）。

马本座Savior HIghlight

星际著名虫族选手,是继Yellow之后又一新的虫族天王, 联赛ID曾为ipxzerg后改为sAviOr[gm],但人们还是习惯称呼他为ipxzerg。　　姓名：马在允　　生日：1987年11月23日　　身高：178cm 　　体重：60kg 　　出生地：大邱　　ID：sAviOr 　　种族：Zerg 　　爱好：网络　　战队：CJ Entus 　　Clan：ArnC 　　Fans主页：http://cafe.daum.net/ipxzerg 　　视力：1.2(左)/1.2(右) 　　座右铭：加油　　键盘：Samsung DT-35白色　　鼠标：罗技MINI 　　每日练习量：8~10小时　　最亲密的Pro：队友

　　荣誉簿　　2007 　　1月：第四届SuperFight冠军　　2月：新韩银行Starleague第三赛季冠军　　3月：GomTV MSL亚军　　5月：WWI2007星际项目亚军　　8月：BlizzCon2007星际项目冠军　　8月：IEF2007星际项目亚军　　8月：WCG韩国区预选赛季军　　2006 　　12月：第三届SuperFight冠军，SKY Proleague 2006后期联赛亚军　　11月：Pringles MSL第二赛季冠军　　10月：第一届SuperFight冠军　　9月：IEF2006星际项目亚军　　8月：WEF2006星际项目冠军　　7月：Pringles MSL第一赛季冠军　　1月：LG CYON MSL亚军　　2005 　　9月：WEF2005星际项目冠军　　8月：UZOO MSL冠军　　7月：SKY Proleague 2005前期联赛季军　　3月：MBC Movies MTL冠军　　1月：SKY Proleague 2004第三阶段季军　　2004 　　8月：Tucson MTL亚军　　5月：SPRIS MSL 8强　　2月：Neowiz Pmang OTL冠军　　1月：LG IBM MTL季军　　——————————————————————– 　　IPXzerg特性词：猥琐，冷静，沉着，持久战。

假赛风波　　轰动一时的韩国假赛赌博门初审判决，著名选手马在允IPXzerg(Savior)被判入狱18个月；马本在被判之后，表示很后悔，7年电竟生涯，有第二春一定好好做贡献。　　马在允在职业期间，夺得过三次MSL冠军，1次OSL冠军，誉为马本座。不过在2010年，马本座被爆出假赛风波，被人买通，并且协同多人假赛，来赚取非法金钱，最终被判入狱。

教主Flash

这里不得不提一下现役最强的职业选手姓名：이영호（Lee Young Ho ）教主Flash 李永浩中文姓名：李永浩（在Korean Air OSL s2 确认）　　韩国著名星际争霸职业选手　　现役世界最强星际争霸选手　　ID：Kt.FlaSh 　　种族：Terran（人族）　　生日：1992年7月5日　　国籍：韩国　　战队：KT RolsteR（原KTF MagicNs）　　昵称：教主、小新、最终兵器，吃肉人族，蹭饭人族，烧酒人族，傻新　　称号：第六代本座

成名战

Kespa认证赛战绩

截止至2011年7月11日 vs All: 424:169 胜率：72% （共593场） vs Zerg: 142:60 胜率：70% （共202场） vs Protoss: 129:55 胜率：70% （共184场） vs Terran: 153:54 胜率：74% （共207场）

荣誉及记录

个人荣誉　　Daum OSL 2007 四强（半决赛负于GGPlay）　　SPL2007~2008 赛季多胜王　　GOM TV Invitational 2008 冠军　　Bacchus OSL 2008 冠军（3：0 横扫无缺点总司令Stork并韩国星际史上最年轻的个人联赛冠军，Flash夺冠时候年仅15岁！）　　Arena MSL 2008 四强（半决赛负于fOrGG）　　TG Sambo-Intel Classic 2008 S1 亚军　　TG Sambo-Intel Classic 2008 S3 冠军　　SPL2008~2009 赛季多胜王　　EVER OSL 2009 冠军（3：1 轻松战胜Movie）　　NATE MSL 2009 亚军（1：3 因MSL决赛断电暖风机门败给Jaedong屈居亚军，也引起了巨大的争议！）　　SWL 2010 冠军MVP 　　大韩航空 OSL 2010 亚军（2：3 被火星神奇逆转）　　Hana证券 MSL 2010 冠军（3：0 横扫jaedong大魔王）　　SPL2009~2010 赛季多胜王　　SPL2009~2010 战队联赛总冠军　　SPL2009~2010 常规赛MVP 　　SPL2009~2010 决赛FINAL MVP 　　WCG2010 韩国区总决赛星际争霸项目亚军　　2010 Bigfile MSL 冠军（3：2 击败jaedong大魔王）　　2010 大韩航空OSL第二赛季冠军（3：1 轻松击败jaedong大魔王) 　　WCG 2010 世界总决赛星际争霸项目冠军　　2011 MSL冠军（3:0横扫小零）个人记录　　最年轻的OSL冠军获得者　　最年轻的SPL100胜达成者　　最短时间SPL100胜达成者　　最少场次的SPL100胜达成者（获得SPL100胜时胜率最高）　　最长TvsT连胜记录保持着（TvsT 22连胜）　　星际争霸职业选手最高ELO记录（唯一一个达到2400分的星际争霸职业选手）　　连续3界杀入OSL决赛（打平了人族皇帝Boxer的记录）　　连续3界双线杀入OSL,MSL决赛（只有FLASH一人达成）　　OSL MSL双线同时夺冠（只有FLASH和NADA两人达成）　　最年轻的金鼠标获得者（18岁零2个月）　　第一个OSL海外决赛夺冠选手（2010年9月11日，中国上海，大韩航空OSL S2）　　Kespa历史最高分（记录为4,292.5分，同时也是唯一一个突破4000分的星际争霸职业选手）　　Kespa排名第一18个月（历史第一）　　同时拥有金鼠标和金徽章（平NADA大神）

金徽章征程　　2010.5 Hana Daetoo MSL：巅峰初现，十指相扣庆祝首个MSL冠军。　　2010.9 BigFile MSL：封印全解，谁与争锋！精准Timing的进攻再次在决赛场零封jaedong。　　2011.6 ABC-Mart MSL：令对手窒息的闪电战压迫式打法零封Zero！　　夺得金徽章之后，flash成为继nada之后又一位金徽章金鼠标同时拥有的选手。

李双录　　李双录起源：2009 NATE MSL 1:3 因断电门，教主Flash屈居亚军　　李双录李双录第二：2010 Hana MSL 3:0 教主Flash横扫暴君jaedong夺冠　　李双录第三：2010 WCG韩国区总决赛 1:2 教主Flash被暴君jaedong逆转，惜败　　李双录第四：2010 Bigfile MSL3:2 教主Flash战胜暴君jaedong 　　李双录第五：2010 大韩航空 OSL S2 3:1 教主Flash轻松战胜暴君jaedong 　　李双录第六：2010WCG世界总决赛 2：1教主FLASH战胜暴君jaedong进入决赛

　　不是只有乐坛才有Leessang。星际争霸界也有李双。那就是像《无限挑战》里的“蜜罐”吉所在的hip-hop组合Leessang一样有名的星际争霸李氏双雄:教主Flash和暴君Jaedong。fans们取两个人的姓“李氏”称他们作“李双”，并且他们两分别是现在星际争霸人族和虫族的领军人物，实力都非常的强大，于是他们之间的巅峰对决就被称为“李双录”。同时也延续了TvZ经典的“林臻录”。　　那么李双究竟是多么优秀的选手呢？Jaedong拿过3次OSL冠军，2次MSL冠军。在SPL中不仅是新人王，还是08-09赛季的多胜王；Flash也不落下风甚至更甚一筹：SPL FINAL MVP称号，连续3个赛季的SPL多胜王称号（08-09赛季他与Jaedong并称多胜王），并获得OSL3次冠军，3次MSL冠军。Jaedong2009年突破100胜，有着BO5之王的称号；Flash则是最年轻的OSL冠军获得者，最年轻的SPL100胜达成者，有着金鼠标获得者最年少纪录等多项纪录，这些纪录在很长一段时间内都难有人能打破。

垃圾游戏特征及其诞生原因推测

2011-07-11T00:00:00+00:00

来源：nico百科(网址真的忘了,别人给我翻译的)

垃圾游戏六大特征 1 bug多，严重的甚至无法继续 2 平衡性差 3 故事无法理解，跳跃太大 4 影像和音乐等粗糙 5 游戏系统差 6 作品本身没有内容

其中2,3 会有个人差异 4,5主要是故事情节的表现手法：读取时间，操作是否便利，视角等 1-6占有项目越多的的游戏垃圾度越高追加第7条就是，明知道有bug还不承认的厂商以及其作品

===

15条垃圾游戏诞生的原因

1 开发期的开放理念不明，导致团队没有共同努力的目标。（具体原因是没有想象的策划书，或者根本就没有策划等等）

2 相对最大容量来说，想加入的内容超标

3 开发团队的经验，或者技术本身不足所致（做不出色子的随机程序等等）

4 开发团队的默契，以及开发环境的不足（设备等等）

5 由于4造成的重大失误、制作过程中的调查不充分（人名地名引用使用时多国言语之间的区别，有没有不合适的用法，时代是否吻合，与自身设定是否矛盾等等）、美术设计（色彩，物体间各种比例等）的不成熟。对于以上这些现象采取姑息妥协放任的态度，谁也不去承担责任。

6 开发人员半途失踪（原因可以从4和其它中找出，还包括开发过程中的裁员和解雇）。其结果导致陷入整体失去了共同的开发理念，成为1的状态。初期开始各种设定都不明确就开始制作，一系列作品中的设定负责人变更，导致剧情前后严重矛盾。却全用一句此作品为平行世界去打发，放纵自己。最糟糕的时候导致无法继续开发，甚至需要专业团队介入，帮助完成开发，应付交货的指标。这种情况来说，几乎100%会诞生一部垃圾游戏。

7 目标为同类作品的大厂商的亚流（模仿，缩水，亚人的那个亚的意思）作品的时候，开发团队情绪低落，没有热情，毫无干劲，导致4的情况。（对比大量热潮中的同类游戏，就可以仿佛出其中开发团队的水平）

8 过度依存于漫画，电影和现实中的艺人，游戏性全无考虑。或者过于重视艺人的意见和风格，导致无法理解的游戏诞生，让玩家无法理解。（例如迈克杰克逊的月面行走等等）

9 突然的策划变动。（社长突然说，天要是紫色该多好啊，于是就强行追加了很多想法和实时的话题）。过于突然，与到那为止的游戏开发和平衡性实现不了大致的吻合。有一些与没出完的原作品同时在开发的游戏，突然原作出现了天翻地覆的情节发展的时候，游戏也会因此突然改变原始的制作计划）

10 因为9导致的交货期紧迫，没有debug的时间。导致很多当初未确定，或者感觉差不多的东西，全都就那么直接上市了。

11 决算期（日本的3月）前赶工，或者因为预算削减开发时间，导致各种不足的状态下出品。（一部作品的收益就可能决定是否倒闭的小厂商必须赶着很多时间去开发，比如动画连载结束前等等，有版权作品的场合居多）顺便说一下老虎机，小钢珠那些游戏，故意比原作晚出10年以上，就是为了避开原作的情节急转和类别间的巅峰期商战等等原因。比如北斗神拳的老虎机

12 相反开发时间过长，开发组对于游戏难度的感觉产生麻痹，游戏变得失去平衡性。（会出现一些——这谁能过？这样的超难度的情况）比如偶像大师（一个跳舞游戏）的多次降低难度，和口袋妖怪的”冷却时间”设定的追加。

13 单纯将外国游戏本地化的失败。积极在日本展开事业的欧美企业也就只有Microsoft Wizards of the Coast、Aristocrat，如果不是日本方面参与本地化制作，基本就是失败告终。

14 广告商，赞助等等，不择时机地要求追加点什么

15 游戏制作人暴走，无人能给其降温。开发团队中缺少一个有凝聚力的人物。甚至外请所谓的自称专家的外行制作人参与制作。（疯狂的例子里，甚至有在游戏分类名称那里直接加上垃圾游戏上市的。例如”垃圾rpg“）

RPGツクールDS RPGツクール4 エルヴァンディアストーリー大奥記人生ゲーム（Wiiウェア）海腹川背Portable（通称：なんとかPortable（笑））グランディアⅢ 高校野球育成アクションゲームめざせ！甲子園ゴーストバスターズ（ファミコン版など）「りり」を参照里見の謎サンダーフォースⅥ 四八（仮）シミュレーションRPGツクール戦極姫センチメンタルグラフティジャンライン修羅の門大冒険セントエルモスの奇跡（これはひどい）たけしの挑戦状チーターマン2 デスクリムゾンドラゴンズレアトランスフォーマーコンボイの謎ハローキティといっしょ!（鬼帝·覇王鬼帝） Big Rigs ファンタシースターユニバース FIST プロゴルファー猿星をみるひと香港９７摩訶摩訶

マインドシーカーメジャーWii パーフェクトクローザー(ダメジャー) メタルマックス２改(メタルマックス２壊) ラストリベリオンルナティックドーンテンペストローグギャラクシー

这个是有个垃圾游戏的成因分类… http://www23.atwiki.jp/ksgmatome/pages/439.html 其中还有一条标准是厂商和制作组公开承认是垃圾游戏的题目，几种，游戏名称，怎么个垃圾法点了还能看具体一点的说明呢

ff14（最终幻想14）没出就被认定了商品として失格最悪の企業態度「それでも私はFF14を続けるよ」这是一句引用说尽管那样我还是会继续玩ff14的这是制作组的头说的然后就被解雇了骂翻了都一次更新直接把电脑都更坏了更新也不知道更了什么牛比东西了

神经病人思维广，弱智儿童欢乐多

2011-07-11T00:00:00+00:00

宅若久时天然呆，呆到深处自然萌

2011-07-01T00:00:00+00:00

ABC MART MSL4强第二日

2011-06-02T00:00:00+00:00

Hydra(Z) 0:3 Flash(T)

暗黑3全新符文之石系统及炫丽技能效果展示

2011-05-26T00:00:00+00:00

作者：草莓来源：凯恩之角今天凌晨，暴雪发布了关于暗黑3中符文之石的详细官方资料。其中包括了符文的名称，对一些技能的具体效果等说明。还有视频演示和UI界面截图。我们已经将这些资料和视频整理完毕。首先推荐大家观看一下暗黑百科对暗黑3中符文的历史资料记载。详情看这里 http://news.plu.cn/othernews/20110526/29058.html

信吗？笑吧《暗黑破坏神3》中国随全球同步发售

2011-05-24T00:00:00+00:00

作者：血脸杀手来源：凯恩之角 http://news.plu.cn/othernews/20110523/28916.html

一个很偶然的机会，凯恩之角的管理人员和暴雪/威望迪的一位高层人士进行了一次短暂的交流，其中一些内容非常给力，并且确实和我们所掌握的中国地区的某些情况吻合：

一：暗黑破坏神3的第一个内部测试版本已经在早先发往全球的各分公司开始进行测试。目前全球各分公司的员工将根据各自的工作性质，分批分先后的开始试玩暗黑3。（注：暴雪中国分公司包含在内。）

二：暗黑破坏神3的多语言版本在同步进行中，各地的语言版本在翻译制作中。（注：大陆地区的翻译应该是由暴雪中国在进行制作。）

三：Beta日期现在还没有最后确定！因为在这次公司内部测试结束后，会对游戏进行一次修补，然后开始进行下一次的公开测试，就是我们所知道的三季度的测试。但是目前美国总部的内部测试基本完毕，只是欧洲和亚洲的测试因为开始较晚，目前还没有结束。

四：给我们透露此消息的人还没有玩上暗黑3，因为他一直在出差（注：所以我们得到了这些消息，呵呵。）

五：关于发售，这位高层非常肯定的说，暗黑3会全球同步发售！！！注意，是全球同步，各种语言版本。

以上是我们从交流中得到的消息，其中前几条在之前我曾经在论坛中提到过，所以可以看出，这位高层所说的内容基本是属实的！这就非常让人期待了，毕竟如果中文版可以同步面市的话，会让我们暗黑迷感到异常兴奋。关于消息来源和具体人名，请不要打听了，因为这是绝对保密的。如果过两天这个新闻不见了，也请不要见怪！

</embed> 尽管《星际争霸：幽灵特务》(英文为Starcraft: Ghost)从05年之后暴雪就宣布无限期跳票，然而这部于02年开发的作品依然受到了许多玩家的青睐。

《星际争霸：幽灵特务》针对PS2和Xbox开发，并且可以经由Xbox Live和Battle.net进行多人连线。玩家将操作一个超级女特工诺娃(Nova)来完成一系列的任务。

然而这个2002年宣布开始制作，并与2005年宣布“无限期跳票”的游戏如今被暴雪总裁迈克莫汉先生证实：当初会将《Starcraft: Ghost》取消开发，是因为当时《魔兽世界》太受欢迎，使得暴雪做出取消《Starcraft: Ghost》的决定。

暴雪也因为魔兽世界的大受欢迎转而在2005年宣布《Starcraft: Ghost》停止开发，而女主角诺娃（Nova）也只能成为《星海争霸2》剧情模式中的串场角色，徒留遗憾而已

动视暴雪Q1财务表现强劲

2011-05-10T00:00:00+00:00

来源：网易

全球最大的游戏开发商和发行商动视暴雪当日发布了2011年截至3月31日的一季度财报。财报显示，一季度净利润为5.03亿美元，合每股42美分，同比增32%，高于华尔街的预期。

本季度营收入的主要驱动力来自于游戏《使命召唤：黑色行动》和《魔兽世界》。据悉，今年2月，动视暴雪推出资料片DLC先发制人(First Strike)。去年12月发布的《魔兽争霸：大灾变》在今年一季度仍然取得了良好的销售业绩。

财报显示，一季度，动视暴雪来自数字渠道的营收同比增30%。数字渠道包括游戏下载、移动游戏以及订阅费用，这方面收入占公司总营收的58%。

动视暴雪将2011年全年营收预期从先前的39.0亿美元调至39.5亿美元（在Non-GAAP标准下），每股盈利则从之前的0.70美元上调至0.73美元。

动视暴雪称，公司预计第二季度的营收为5.75亿美元，合每股0.04美元。低于华尔街分析师的预期，华尔街分析师预期该公司二季度营收为6.587亿美元，合每股0.08美元。

北京时间5月10日凌晨4：30（太平洋时间9日13：30），动视暴雪公布了其2011年第一季度的财报，在最引人关注的暴雪游戏计划方面，暗黑破坏神3虽未正式公布beta时间，但暴雪给出了一个时间点：计划于第三季度开启公测！以下是财报中暴雪相关信息整理： Q1财务表现强劲魔兽世界在浩劫与重生上市之后，欧美地区的销售记录

截至3月，付费用户数在欧美回到浩劫与重生之前的水平
计划继续为玩家带来持续更新的内容
我们在中国的合作伙伴网易正努力使得浩劫与重生能在中国尽快上线
刚刚在中国启动了游戏增值服务星际争霸2
于1季度在中国上线，已经成为全球星际争霸2最大的玩家群体之一
正在努力开发第一部资料片虫群之心暗黑破坏神3
正在启动公司内部的全面测试
目标在第三季度开启更广泛的beta测试
尚未确定具体的发售时间点但努力做到在年内发售

搜寻地外文明

2011-05-10T00:00:00+00:00

http://boinc.berkeley.edu 将您计算机 (包括 Windows、Mac 以及Linux) 的闲置时间利用起来，就可以帮助科学家们治疗疾病、了解全球变暖、发现脉冲星以及其它多种类型的科学研究，而且这还很简单和安全：

SETI@home 是一项利用全球联网的计算机共同搜寻地外文明（SETI）的科学实验计划。你可以通过运行一个免费程序下载并分析从射电望远镜传来的数据来加入这个项目。

人工神经网络

2011-05-05T00:00:00+00:00

开篇

我一直对此十分感兴趣。以前写了一些模拟神经元的代码。但是很久没研究了，基本快忘了ann的算法原理。还特地研究了一下生物心理学和神经科学的基础知识。了解了一下人类大脑是处理信息的过程。

用计算机程序来模拟这一过程，十分疯狂的…不过目前已经有很多算法能模拟人类大脑一部分功能。人类的感情，公认是难以模拟的…

用计算机模拟人类学习、记忆和分析信息的能力还是可以达到的…好抽象。

应用领域其实都挺不靠谱的…什么这那的预测啊，什么xx的识别啊。比较像人类思维方式，人类思维方式就是有这个特点：不确定性。人类思考一个事情，得出的结论，不一定是最优的，但应该是一个能解决问题的结论。最明显的例子，我们现在要去一个地方，有两条路都能到达。一条路近，但是不好走。另一条路，很整洁，但是远一些。我们走那条路呢？一般有“走最近的”的想法的人，就会选择最近的。但是，最近的路很乱，不好走。那有“路要好走”的想法的人会选择好走的路。恩，人类就是擅长对这种“无确定结果”的“最佳答案”的分析上。再具体点，咱们无时无刻都在做的事情。咱们的视觉信息，听觉信息，还有嗅觉信息，都是这么处理的。比如看验证码，比如闻到一种酒香判断是什么酒，比如听音乐判断用的什么乐器。即使是非常一致的结论，其实也是通过无数次这种思考，渐渐得到一个比较确定的结论的时候，才会每次都给出统一的结论。比如计算1+1的时候，一个人从来没有计算过1+1，那么开始你就告诉他1+1=3，如果没人纠正他，那他这一生的1+1都会等于3了。

学习经验>思考结论>经验… 通过信息输入（眼睛，鼻子，舌头，耳朵，神经末梢等），获得信息（经验），把这些经验当做思考时计算用的的参数，然后通过思考得出结论，得出的结论又会被当做经验参与以后的思考（反馈）（输出不输出看心情）。如此循环…

这么一个循环，基本上就是人类智慧的获取办法…我这么猜的。其实人工神经网络算法，基本上也是这个思路。

然而，以下两个方面，无法简单的用算法模拟…… 一、人类的下意识，灵感，创造力，第六感，第七感，第八感？好吧，这是圣斗士……比如我走着走着，突然觉得我得蹦一下。我就蹦了一下。很莫名其妙，没有缘由这种。说不清道不明的，不知道是什么原因造成。大脑短路？二、就是感情因素，也无法模拟，确切的说是无法量化……比如我特别喜欢两个人，但是这个怎么量化，我是更喜欢哪个多一点？这个人类自己都很那回答。但是原理基本上在神经科学中应该是有解释的，以后再细说。

以后会抽出时间来总结一下学习过的信息。我tmd说话越来越不像人了。

这东西没有数学基础很难搞，咋办啊……………… 我对大自然能进化出人来这种怪物…表示敬佩。这么复杂的神经系统是怎么锻炼出来的。

谁有相关的信息能帮助一下咱，咱绝对给他磕头。

消息

2011-05-04T00:00:00+00:00

卡塔尔半岛电视台日前播放了一段据信是本拉登的录音, 在录音中, 本拉登亲口证实：他已在巴基斯坦被美军击毙。

Concerto Gate (魔力2)人物加点计算器

2011-05-04T00:00:00+00:00

Either scripts and active content are not permitted to run or Adobe Flash Player version 10.0.0 or greater is not installed.

思考的问题

2011-05-03T00:00:00+00:00

往往人类使用直觉代替逻辑思考，直接给出问题的答案。越理性的人越容易用逻辑思考代替直觉。即使理性的人，也容易使用直觉。但是经过提示后，能更小心翼翼的使用逻辑思考问题。而且，逻辑思考能力和智商有关。

拉登死亡

2011-05-02T00:00:00+00:00

记录拉登死亡 2011.05.02

大事记 264年：魏元帝封司马昭为晋王。 1670年：经英国国王查理二世的皇家特许，哈德逊湾公司取得垄断北美鲁伯领地所有贸易的权利。 1808年：在半岛战争中，西班牙马德里的居民发动起义，反抗拿破仑率领的法国军队的占领。 1895年：广东南海举人康有为等人在北京发起公车上书，要求改革。 1895年：英国南非公司将在赞比亚以南的领地组成罗得西亚。 1933年：现代人第一次目击到了尼斯湖水怪。 1942年：毛泽东在延安文艺座谈会上发表讲话。 1945年：德军柏林卫戍司令魏德林向朱可夫率领的苏联红军投降，柏林战役结束。 1945年：中国第一部新歌剧《白毛女》上演。 1952年：英国彗星型客机投入航线首航，从伦敦飞往南非约翰内斯堡，成为世界首部民用喷气式客机。 1953年：约旦国王侯塞因二世加冕。 1953年：伊拉克国王费萨尔二世加冕。 1964年：中国登山运动员首次登上西藏境内的希夏邦马峰峰顶。 1982年：在马岛战争中，阿根廷贝尔格拉诺将军号巡洋舰被英国皇家海军的核潜艇用鱼雷击沉，导致323人死亡。 1989年：匈牙利开放对奥地利的边界。铁幕被打开了。 1990年：南非非洲人国民大会主席曼德拉与南非总统戴克拉克会谈。 1997年：英国工党重新执政后，托尼·布莱尔成为英国1812年以来最年轻首相。 1998年：欧盟15国国家元首和政府首脑在比利时首都，启动欧元进入倒计时。 2003年：苹果日报 (台湾)发行台湾版首刷。 2008年：强热带风暴纳尔吉斯在缅甸伊洛瓦底江三角洲登陆，造成至少77,738人死亡，55,917人失踪。 2011年：“9.11”恐怖袭击的幕后策划者本拉登在巴基斯坦被美军击毙。

出生 1892年：曼费雷德·冯·里希特霍芬，德国飞行员。 1860年：西奥多·赫茨尔，犹太复国主义思想的创始人，作家和记者。 1921年：沙提阿耶特·雷，印度电影导演，作曲家。 1928年：吉格梅·多吉·旺楚克，不丹国王。（1972年逝世） 1942年：雅克·罗格，比利时整形外科医生、国际奥委会主席。 1942年：章孝慈，台湾法律学者。 1942年：蒋孝严，中华民国政治人物，外交官。 1952年：杜可风，香港电影摄影师。 1952年：李立群，台湾演员 1953年：瓦列里·格吉耶夫，俄罗斯指挥家。 1956年：秋元康，作词家、音乐制作人、放送作家‧‧‧等。 1968年：菊田洋之，日本漫画家。 1968年：绿川光，日本动画声优。 1972年：The Rock，美国男演员。 1974年：张震岳，台湾流行音乐歌手。 1975年：大卫·贝克汉姆，英格兰足球运动员。 1977年：陈建州，台湾男演员。 1981年：佐藤利奈，日本动画声优。 1984年：萨博·塞福罗萨，瑞士的职业篮球运动员。 1985年：莉莉·艾伦，英格兰女歌手、主持人。 1985年：莎拉·晓丝，美国女子花样滑冰运动员。 1988年：梁心颐，台湾裔美国人，台湾女歌手。 1991年：郑珍云，韩国美声男子团体2AM成员。

逝世 1519年：列奥纳多·达·芬奇，意大利文艺复兴时期画家。（－1452年） 1918年：苏曼殊，中国诗人、作家。 1934年：保罗·冯·兴登堡，德国军人、政治家。 1957年：约瑟夫·麦卡锡，美国政治家。 1969年：弗兰茨·冯·巴本，德国政治家。 1972年：约翰·埃德加·胡佛，美国联邦调查局局长。 1990年：施光南，中国音乐家。 1991年：吴运铎，有“中国的保尔·柯察金”之称号的中国作家。 1998年：松本秀人，又称hide，日本视觉系乐团X JAPAN吉他手。 2005年：黄金辉，新加坡第四任总统。

Flash 三神器

2011-05-01T00:00:00+00:00

三大神器：量天尺、圣水宝矿力水特（Pocari Sweat）、三重封神印。

量天尺：据说用来测量显示器和键盘的距离以保证最佳的操作状态。

宝矿力水特：广告。小含一口减轻比赛压力，大喝一口增加膀胱压力。

封神印：封印于教主手臂的神箍。在教主比赛偶有失利的情况下解放，遂现人间地狱。

在OSL911上海决赛之后，教主已经被官方认定，成为正式的第六本座。由于这次决赛在中国进行，而且游戏风云拿到了转播权，圆了大师，二龙，三炮一个梦想吧。传说他们的梦想就是解说韩国职业联赛。这次总决赛转播权同样感兴趣的是上海的NeoTV。虽然NeoTV无论是财力，人力，物理都要比游戏风云和PLU勥，但是我不太喜欢他们的风格。不太亲民吧。当然，为中国电竞事业奉献的人，都值得敬佩。

以下是韩航OSL2010上海总决赛vod。来自plu.cn 没有去现场看很遗憾啊…

OSL视频集锦大师、BBC和二龙在欣赏教主的三重封印 http://sc.plu.cn/vod/OSL2009/2010-09-24/1032871.html

[韩航 OSL]总决赛开幕式 http://sc.plu.cn/vod/OSL2009/2010-09-12/1032829.html

[韩航 OSL]总决赛 Jaedong(Z) vs Flash(T) 1 http://sc.plu.cn/vod/OSL2009/2010-09-12/1032830.html

[韩航 OSL]总决赛 Jaedong(Z) vs Flash(T) 2 http://sc.plu.cn/vod/OSL2009/2010-09-12/1032831.html

[韩航 OSL]总决赛 Jaedong(Z) vs Flash(T) 3 http://sc.plu.cn/vod/OSL2009/2010-09-12/1032832.html

[韩航 OSL]总决赛 Jaedong(Z) vs Flash(T) 4 http://sc.plu.cn/vod/OSL2009/2010-09-12/1032833.html

2010 OSL决赛Flash夺冠后采访(中字) http://sc.plu.cn/vod/OSL2009/2010-09-18/1032838.html

Public-key cryptography

2011-05-01T00:00:00+00:00

下午和鱼琢磨了半天非对称加密及其作用。总结了半天，我画了一张图，免得以后忘了。如果有不对的地方，帮忙指正。公钥，公共的钥匙。任何人都可以拥有她。所以，用户a，用户b都拥有公钥a和公钥b。私钥，私有的钥匙。每个人只有自己的钥匙。所以，用户a有私钥a，用户b有私钥b。那现在来看看用户a和用户b都各自拥有哪些钥匙。用户a：公钥a，公钥b，私钥a。用户b：公钥a，公钥b，私钥b。

非对称加密算法还有一个原则：用公钥加密，使用对应的私钥解密。用私钥加密，使用对应的公钥解密。

遵循这个原则，用户a，可以使用公钥b加密明文内容，生成密文。那么，用户b就可以使用私钥b解密，从而解密密文为明文。当然实际流程并非这么简单。请看下图… 我也不知道此图对不对。凑合看吧… 从左上角开始解释。用户a将明文使用哈希算法，生成“数字指纹”，用来验证信息完整性，防止明文在传输过程中被篡改。数字指纹内容加上“用户a的私钥”，使用非对称加密算法进行加密，得到“用户a的数字签名”。她里面拥有“明文信息摘要”的数据。这个“用户a的数字签名”是为了验证信息来源的可靠性，防止明文被他人假冒发出。然后把“明文数据”和“用户a的数字签名”还有“用户a的公钥”（用户a数字证书）这些数据，加上“对称密钥”，使用对称加密算法，得到“密文”。“密文”里就拥有“明文”，“用户a的数字签名”，和“a的公钥”这三项数据了。然后，将刚才加密“明文”数据使用到的“对称密钥”，加上“用户b的公钥”，使用非对称加密算法加密，得到“数字信封”。“数字信封”里就拥有解密密文内容要用到的“对称密钥”的信息了。

将“数字信封”和“密文”数据传送给用户b。

用户b首先将“数字信封”解密，由于“数字信封”使用的是“用户b的公钥”加密，那么用户b只要使用“用户b的私钥”就能解开“数字信封”。解开“数字信封”后，得到用于加密明文信息的“对称密钥”。使用“对称密钥”，用过对称算法，将“密文”解密。得到“明文”，“用户a的数字签名”，和“用户a的公钥”。这三个数据。将“用户a的数字签名”，通过“用户a的公钥”，使用非对称算法解密，得到“明文”的“数字指纹”。然后将解密得到的“明文”信息直接使用哈希算法得到的“数字指纹”信息和刚才用“数字签名”解密出来的“数字指纹”做对比。如果一致，说明“明文”内容没有被篡改过。并且“密文”数据的来源是可靠的。如果不一致，说明要不就是“明文”数据被篡改过，要不就是“用户a的数字签名”是伪造的（用户a的私钥是伪造的）。

东方动画《幻想万华镜》新动画+OP+ED

2011-04-30T00:00:00+00:00

东方系列一直是我喜欢的游戏

虽然现在没什么时间玩了，反应能力也没以前快了，眼神也不好了，但是对这个东方游戏系列的热爱还是有的。一个小的纵版射击游戏，无论从音乐，人物配音，人设，情节（虽然看不懂，但是能看出来是精心制作）,画面，游戏性和难度（除了音效）都达到了射击游戏的一个很高的水平。国内外粉丝众多，包括我。制作品质一流。就是我的评价。我喜欢日式rpg，以后如果有融合rpg和射击，这两种类型的游戏就好了。就合那个史克威尔出品的很垃圾的《横滨最速传说》类似的游戏（虽然很垃圾，其实也是有些乐趣的…）。

这次由満福神社×幽閉サテライト联合制作的动画可以说是承载了众多东方粉丝的期待。现在要出动画了？god… 我对动漫很不了解。但是看起来貌似是民间团体出的…不清楚，谁了解可以告诉咱。満福神社×幽閉サテライト到底是什么团体。和山口组有啥联系没。

http://news.plu.cn/othernews/20110430/27675.html

The scripture of NineSuns

2011-04-30T00:00:00+00:00

悉心体认,随人所动,随曲就伸,不丢不顶. 一静无有不静,静须静如山岳.他强由他强, 清风拂山冈. 一动无有不动,动当动若江河,他横任他横,明月照大江. –《九阳神功》

《暗黑破坏神3》即将出在PS3或XBOX

2011-04-30T00:00:00+00:00

暴雪又要玩家用机了？

刚刚在plu.cn上看到一个新闻。http://news.plu.cn/othernews/20110429/27663.html 好吧「失落的维京人」我玩过。电脑版的和SFC版的我都玩过。当时来说还算不错。只要游戏机手柄能操作的过来，那么在家用机上完D3还是没有问题的。电脑和游戏机的操作方式不同，这个对UE设计是个很大挑战。如何适应两种不同操作习惯的UE和UI… 和jaedong大魔王的两队飞龙齐甩难度差不多。顺便说一句…2007年的OSL片头真不错，至少比现在的勥。

我就喜欢不着边际的事情

2011-04-28T00:00:00+00:00

昨天看了一篇关于暴雪总部探访的报道

前些日子在国服战网看过暴雪20年的视频。昨天又看了一些相关的文字内容。感觉到，暴雪的成长是真的很快。基本上用了2年的时间，公司就成熟起来了，资金也基本稳定。是个很幸运的公司。

反观我现在…我觉得很杯具。启动资金不比他们少，人员相对来说也充足，经验也充足。但是，唯一不足的是，公司的产品规划战略。暴雪的成功，不仅仅是运气问题，很大一部分，尤其是在其创业初期取决于他们的产品规划战略的成功。暴雪中期，从魔兽争霸1上市的时候，已经在电脑游戏业界站稳了脚跟。我们走的弯路太多了。当然，这个不是我所能决定的。太二了。

暴雪总裁麦克-莫汉(Mike Morhaime)，在创业的时候还能向祖母借款1.5万美元。我都没地方找这个钱。想想都惨…

如果成功了，我还会继续做游戏。如果失败了，我想我还是先暂时回家画画去吧…好像只有画画，才能直接的，没有任何别人的杂念，自己看着爽的东西吧。

电脑就是解决数学问题而产生的，我的数学知识不够支撑我继续前进的了。所以，想找个数学nb的志同道合的人，来帮帮我…

2011.04.28

好吧，从新开始。

2011-04-27T00:00:00+00:00

//(◕‿‿◕)要相信你的cpu

换了版面。从来没有写博客的习惯，不过和大家一起分享的快乐，才是真正的快乐。

根据noya的要求，我加入了评论的功能。

这个blog功能比较简单，没有日历索引，所以…将就吧…

2011.04.27

奇怪的梦-1

2011-04-27T00:00:00+00:00

今天做了一个脱狱的梦，很刺激，像电影。记录下来

梦的开始，是在一个监狱里。本来我是没有越狱的计划。我其实是被卷进去的。开始部分是一天正常的进行，没什么波澜。

第二天白天，出来放风的时候，发生了事情。这里还有个细节回顾。因为在监狱，没什么事情，每天都是出来放风。所以在放风的时候很无聊，我会仔细观察周围的地形，和防范状况。虽然没有要逃脱的想法，但是貌似就是为了逃脱随时准备着似的。总是在想，如果这么走，会怎么样。如果那么走会怎么样。这也许是对自由向往的本能驱使吧。

突然，睡在我旁边的狱友冲出人群，开始奔跑。他跑之前叫上了我，我没有犹豫的就跟上去了（脑残了）。后面也跟了一个人。我们一起疯狂的跑。放风的围墙不高，很容易就翻出去了，监狱的墙在更大的外圈，是不可能翻出去的，只能从大门走。这就是体现出后面智慧的地方了。然后带头的人，一看就是有预谋的，带着我们，跑到了一个平时我们经常观察的一个小楼里，距离放风的地方很近。没有人看到我们进入了这里。然后他说，在这个楼里藏起来，等明躲到天黑了的时候，再想办法从大门出去。最危险的地方，就是最安全的地方。因为平时总在琢磨监狱防范的弱点，所以这个小楼是公认的弱点，废弃了的，而且里面可以隐蔽。在小楼里面，带头的人有个图，我们仔细商量从哪个门出去。我看了，图上只有2个门。一个很近，一个稍微远点。我不知道方向，但是图上是这么画的。上面的门稍微近，右面的门，远一些。其实大家心里也知道哪个近哪个远。于是，我们就开始休息，带头的人说，咱们睡一会儿，手和脚伸进小窗户里，用绳子吊住手和脚，悬空睡。我一直没明白为什么要这么麻烦的睡觉。但是还没吊好，有什么原因，我们必须离开这里。

于是我们就继续跑，跑到一个楼下，觉得没什么问题了，就想继续休息。我们没有进去，只是在外墙，也很安全。就开始考虑原计划进行，虽然不是在室内，但是也很安全，没什么人。于是开始吊，休息。但是我观察这个楼，很奇怪，好像在哪里见过。再仔细一想，这个就是监狱的办公楼…卧草。平时都是从另外的角度看，这个角度从来没看过，所以一下没反应过来。惊诧的同时，一个守卫看见了我们，开始用狙击枪瞄准我们。我迅速的解开绳子，然后往他视线死角跑。那个人开始开枪。我们疯狂的乱跑，左右胡乱改变着奔跑的路线，让他无法瞄准。突然，带头的人中弹了。我看了他一眼，皱了皱眉头。他让我继续跑。我没有管他，继续跑。前面就是大门。很奇怪，没什么守备，我和另外一个人顺利的跑了出来。

外面就是马路，人很多。我们直接跑过马路，然后钻进了一个小胡同，混进了茫茫人海。暂时摆脱了追击。然后我们在那个小胡同里，商量怎么办。胡同的另一侧，有个发廊。我瞄了一眼，好像有个女的。我们正在各自想着以后的办法。突然，出现2个人，一个狱友，一个是狱警。当时我就傻眼了…很害怕，可是那个狱警做出投降的动作。他说他厌烦了监狱的生活，要和我们一起跑。我不明白为什么他会这么做，也没多想。就带上他了。现在想起来很可怕，是很不明智的选择，不过，梦里没有交代为什么让他加入。不深究了。然后突然，从哪个小发廊里冲出来2人，也是狱友，又吓我一跳。我以为是来抓我们的…现在终于有女人出现了。

我们继续跑路。六个人了。我没有问他们都怎么出来的。但是逃跑现在是最重要的。中间的过程记忆很模糊了。我们来到了一个小旅馆。怎么进来的我都忘了。一个房间，里放6个人…我知道，京城的旅馆都和派出所是联网的。都有通缉犯的照片。但是不知道为什么我们能进这个旅馆。可能是黑旅馆吧。我们在里面商量怎么继续逃亡。也回忆了一下过去的经过。缅怀了一下带头的人…大家都很惋惜。有了放松和休息的一小会儿时间。然后我注意到，我们房间门口来往的人太多了。我觉得这里很不安全，我说必须走。然后我们退了房，我很奇怪，怎么退的。在最后锁门的时候，钥匙还差点丢了。那个管理房间的人，貌似一点都不关心我们是干嘛的。

从旅馆出来后，相对安全了一些，大家都显得放松和开心。我说现在相对安全了，咱们分开各自走路吧。尽量走人多的公共场所，不要去静止不动的公共场所，比如公交车，地铁，茶馆什么的。只要保持移动就好。因为我要回家。很奇怪就和大家分开了。

画面转到了我来到了我家小区的外面。我刚刚发现，原来那个监狱就在我家小区的南面…，我只要从北门出来就能直接回家了…我打算绕开监狱，回家了。于是从旁边的小区里面的小路走。走的很快。归心似箭。好像是被谁发现了，于是我开始疯狂的跑。上屋顶跑，来回躲避。慌不择路，最后不知道怎么跑的，又进入了监狱…于是我毫不犹豫的向北跑。北面几乎没有墙，是一个小的灌木围墙。距离我家的楼很近，我都能看到我家了。我跳出了灌木。被一枪放倒了。（最后这一段，可能真是脑子混乱了，因为监狱的墙不可能是灌木丛…）

我躺在地上，想象着几年以后，狱友聚会。大家聊着惊心动魄的脱狱故事，描述着自己生活的趣事…我笑了。醒了。

2011.04.22

test

2011-04-26T00:00:00+00:00

Title

内容

字数字数

文字文字 wenzi

int main(int argc, char* argv[])
{
	print("hello world!");
	return 0;
}

文字文字

奇怪的梦-0

2011-03-31T00:00:00+00:00

昨晚做了一个梦，梦见我去一个奇怪的书店，好多漫画书，我拿了一本漫画书，名字很长，具体忘了。是关于花的题目。很长很拗口，但是挺有意思。我才拿了这本书。

大意是，一个小孩和一群孩子在一片空地上玩耍，好像是足球，玩着玩着，自己被一个坑绊倒了。但是这一倒下去，从他的身体里分裂出一个类似骷髅的东西，但还有血肉。骷髅开始说话，孩子很害怕，但是很镇静。骷髅给孩子讲故事。画面一闪，来到一个风雨交加的夜晚，骷髅是说他的经历好像。一个日本武士，很威武，很nb。在和一群人缠斗。他娴熟的剑法，把那群看似坏蛋的人，打的片甲不留。武士使用着精准的剑法，抵挡着敌人的进攻。但是突然被击中了，然后，武士被那群坏人在身上刺了12个窟窿眼儿，腿上也砍了一下好像。就躺在那里。坏人都走了。但是很幸运，武士没有死。被一个好心路过的人看到，救了起来。那个好心人照顾他，给他养好伤。（武士得知这个老太太的儿子患了一种奇怪的病，长不大，只有一种花能治疗，武士为了报答她的救命之恩，就去帮他找花）突然画面有转到，一个村庄，武士出现在这里。这个村庄貌似是一个对花很有研究的地方。用花来治病。他访问了村民，可是好像有什么问题没人帮助他。但是中间好像用武力又帮助了村民，中间很模糊记不清了，最后得到一个少女的帮助，帮他找到了他要找的花。花的名字忘了。那个少女好像是什么传人，是最村子里最厉害的的花的鉴赏家的后代好像是。然后画面又转回小屋，夜晚，一个老奶奶，坐在那里，小孩在熟睡。然后小孩突然碰到一个类似佛像的一个什么东西，然后就变成25岁的成人了。这个小孩本来就应该25岁了。那个老奶奶很高兴，武士也很高兴，对老奶奶说，您的儿子终于恢复了。然后这个故事就结束了，最后写的是xxxx花。（书是淡黄色的纸，很雅致，我特意看了看）这是一个系列漫画，说的就是各种花的故事，每个故事都说的是一种花。这是第一本，介绍整个故事的大概框架。开始那个少年后来怎样了，也不知道，可能是个主线情节，第一本最后没有交代，应该是后来的伏笔。开始那些坏人追杀他的目的也不清楚。中间有些情节也是被我忘了。最后我看完了这本书，我拿着书走出了书店，居然没人管我要钱。我也忘记给钱了。走在大街上，看到好多以前经典漫画的大幅海报，不过海报的内容是漫画里的截图而已，没有任何修饰。也有我这本书的海报。

这是我比较清晰的对梦的记忆，故此记录下来，免得忘记。

喵哈哈

2011-02-09T00:00:00+00:00

喵哈哈

内容字数字数

RTTI、虚函数和虚基类的开销分析及使用指导

2010-03-02T00:00:00+00:00

转自：http://baiy.cn/doc/cpp/inside_rtti.htm

RTTI、虚函数和虚基类的开销分析及使用指导

白杨

http://baiy.cn

“在正确的场合使用恰当的特性” 对称职的C+程序员来说是一个基本标准。想要做到这点，首先要了解语言中每个特性的实现方式及其开销。本文主要讨论相对于传统 C 而言，对效率有影响的几个C+新特性。

相对于传统的 C 语言，C** 引入的额外开销体现在以下两个方面：

编译时开销

模板、类层次结构、强类型检查等新特性，以及大量使用了这些新特性的 STL 标准库都增加了编译器负担。但是应当看到，这些新机能在不降低，甚至（由于模板的内联能力）提升了程序执行效率的前提下，明显减轻了广大 C** 程序员的工作量。用几秒钟的CPU时间换取几人日的辛勤劳动，附带节省了日后调试和维护代码的时间，这点开销当算超值。

当然，在使用这些特性的时候，也有不少优化技巧。比如：编译一个广泛依赖模板库的大型软件时，几条显式实例化指令就可能使编译速度提高几十倍；恰当地组合使用部分专门化和完全专门化，不但可以最优化程序的执行效率，还可以让同时使用多种不同参数实例化一套模板的程序体积显著减小……

运行时开销

运行时开销恐怕是程序员最关心的问题之一了。相对与传统C程序而言，C++中有可能引入额外运行时开销的新特性包括：虚基类虚函数 RTTI（dynamic_cast和typeid）异常对象的构造和析构关于其中第四点：异常，对于大多数现代编译器来说，在正常情况（未抛出异常）下，try块中的代码执行效率和普通代码一样高，而且由于不再需要使用传统上通过返回值或函数调用来判断错误的方式，代码的实际执行效率还可能进一步提高。抛出和捕捉异常的效率也只是在某些情况下才会稍低于函数正常返回的效率，何况对于一个编写良好的程序，抛出和捕捉异常的机会应该不多。关于异常使用的详细讨论，参见：C+编码规范正文中的相关部分和C+异常机制的实现方式和开销分析一节。

而第五点，对象的构造和析构开销也不总是存在。对于不需要初始化/销毁的类型，并没有构造和析构的开销，相反对于那些需要初始化/销毁的类型来说，即使用传统的C方式实现，也至少需要与之相当的开销。这里要注意的一点是尽量不要让构造和析构函数过于臃肿，特别是在一个类层次结构中更要注意。时刻保持你的构造、析构函数中只有最必要的初始化和销毁操作，把那些并不是每个（子）对象都需要执行的操作留给其他方法和派生类去解决。

其实对一个优秀的编译器而言，C+的各种特性本身就是使用C/汇编加以千锤百炼而最优化实现的。可以说，想用C甚至汇编比编译器更高效地实现某个C+特性几乎是不可能的。要是真能做到这一点的话，大侠就应该去写个编译器造福广大程序员才对～

C++之所以被广泛认为比C“低效”，其根本原因在于：由于程序员对某些特性的实现方式及其产生的开销不够了解，致使他们在错误的场合使用了错误的特性。而这些错误基本都集中在：

把异常当作另一种流控机制，而不是仅将其用于错误处理中一个类和/或其基类的构造、析构函数过于臃肿，包含了很多非初始化/销毁范畴的代码滥用或不正确地使用RTTI、虚函数和虚基类机制其中前两点上文已经讲过，下面讨论第三点。

为了说明RTTI、虚函数和虚基类的实现方式，这里首先给出一个经典的菱形继承实例，及其具体实现（为了便于理解，这里故意忽略了一些无关紧要的优化）：

图中虚箭头代表偏移，实箭头代表指针

由上图得到每种特性的运行时开销如下：　特性时间开销空间开销 RTTI 几次整形比较和一次取址操作（可能还会有1、2次整形加法）每类型一个type_info对象（包括类型ID和类名称），典型情况下小于32字节

虚函数一次整形加法和一次指针间接引用每类型一个虚表，典型情况下小于128字节每对象若干个（大部分情况下是一个）虚表指针，典型情况下小于8字节

虚基类从直接虚继承的子类（例如上图中的 “B1” 和 “B2”，但不包括 “DD” ）中访问虚基类的数据成员或其虚函数时，将增加两次指针间接引用和一次整形加法（部分情况下可以优化为一次指针间接引用）。每类型一个虚基类表，典型情况下小于32字节每对象若干虚基类表指针，典型情况下小于8字节

在同时使用了虚函数的时候，虚基类表可以合并到虚表（virtual table）中，每对象的虚基类表指针（vbptr）也可以省略（只需vptr即可）。实际上，大部分实现都是这么做的。

* 其中“每类型”或“每对象”是指用到该特性的类型/对象。对于未用到这些功能的类型及其对象，则不会增加上述开销可见，关于老天“饿时掉馅饼、睡时掉老婆”等美好传说纯属谣言。但凡人工制品必不完美，总有设计上的取舍，有其适应的场合也有其不适用的地方。

C++中的每个特性，都是从程序员平时的生产生活中逐渐精化而来的。在不正确的场合使用它们必然会引起逻辑、行为和性能上的问题。对于上述特性，应该只在必要、合理的前提下才使用。

“dynamic_cast” 用于在类层次结构中漫游，对指针或引用进行自由的向上、向下或交叉强制。”typeid” 则用于获取一个对象或引用的确切类型，与 “dynamic_cast” 不同，将 “typeid” 作用于指针通常是一个错误，要得到一个指针指向之对象的type_info，应当先将其解引用（例如：”typeid(*p);”）。

一般地讲，能用虚函数解决的问题就不要用 “dynamic_cast”，能够用 “dynamic_cast” 解决的就不要用 “typeid”。比如：

反面教材:

void
rotate(IN const CShape& iS)
{
    if (typeid(iS) == typeid(CCircle))
    {
        // ...
    }
    else if (typeid(iS) == typeid(CTriangle))
    {
        // ...
    }
    else if (typeid(iS) == typeid(CSqucre))
    {
        // ...
    }
    // ...
}

以上代码用 “dynamic_cast” 写会稍好一点，当然最好的方式还是在CShape里定义名为 “rotate” 的虚函数。

虚函数是C++众多运行时多态特性中开销最小，也最常用的机制。虚函数的好处和作用这里不再多说，应当注意在对性能有苛刻要求的场合，或者需要频繁调用，对性能影响较大的地方（比如每秒钟要调用成千上万次，而自身内容又很简单的事件处理函数）要慎用虚函数。

需要特别说明的一点是：虚函数的调用开销与通过函数指针的间接函数调用（例如：经典C程序中常见的，通过指向结构中的一个函数指针成员调用；以及调用DLL/SO中的函数等常见情况）是相当的。比起函数调用本身的开销（保存现场~~传递参数~~>传递返回值->恢复现场）来说，一次指针间接引用是微不足道的。这就使得在绝大部分可以使用函数的场合中都能够负担得起虚方法的些微额外开销。

作为一种支持多继承的面向对象语言，虚基类有时是保证类层次结构正确一致的一种必不可少的手段。但在需要频繁使用基类提供的服务，又对性能要求较高的场合，应该尽量避免使用它。在基类中没有数据成员的场合，也可以解除使用虚基类。例如，在上图中，如果类 “BB” 中不存在数据成员，那么 “BB” 就可以作为一个普通基类分别被 “B1” 和 “B2” 继承。这样的优化在达到相同效果的前提下，解除了虚基类引起的开销。不过这种优化也会带来一些问题：从 “DD” 向上强制到 “BB” 时会引起歧义，破坏了类层次结构的逻辑关系。

上述特性的空间开销一般都是可以接受的，当然也存在一些特例，比如：在存储布局需要和传统C结构兼容的场合、在考虑对齐的场合、在需要为一个本来尺寸很小的类同时实例化许多对象的场合等等。

C/C++ 字符串处理函数

2010-02-23T00:00:00+00:00

2008年01月15日星期二 21:06 刚开始学C/C+时，一直对字符串处理函数一知半解，这里列举C/C+字符串处理函数，希望对初学者有一定的帮助。

函数名: stpcpy 功能: 拷贝一个字符串到另一个用法: char *stpcpy(char *destin, char *source); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char string[10]; 
   char *str1 = "abcdefghi"; 
   stpcpy(string, str1); 
   printf("%sn", string); 
   return 0; 
}

函数名: strcat 功能: 字符串拼接函数用法: char *strcat(char *destin, char *source); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char destination[25]; 
   char *blank = " ", *c = "C++", *Borland = "Borland"; 
   strcpy(destination, Borland); 
   strcat(destination, blank); 
   strcat(destination, c); 
   printf("%sn", destination); 
   return 0; 
}

函数名: strchr 功能: 在一个串中查找给定字符的第一个匹配之处用法: char *strchr(char *str, char c); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
	char string[15]; 
	char *ptr, c = 'r'; 
	strcpy(string, "This is a string"); 
	ptr = strchr(string, c); 
	if (ptr) 
		printf("The character %c is at position: %dn", c, ptr-string); 
	else 
		printf("The character was not foundn"); 
	return 0; 
}

函数名: strcmp 功能: 串比较用法: int strcmp(char *str1, char *str2); 看Asic码，str1>str2，返回值 > 0；两串相等，返回0 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
	char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc"; 
	int ptr; 
	ptr = strcmp(buf2, buf1); 
	if (ptr > 0) 
	   printf("buffer 2 is greater than buffer 1n"); 
	else 
	   printf("buffer 2 is less than buffer 1n"); 
	ptr = strcmp(buf2, buf3); 
	if (ptr > 0) 
	   printf("buffer 2 is greater than buffer 3n"); 
	else 
	   printf("buffer 2 is less than buffer 3n"); 
	return 0; 
}

函数名: strncmpi 功能: 将一个串中的一部分与另一个串比较, 不管大小写用法: int strncmpi(char *str1, char *str2, unsigned maxlen); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *buf1 = "BBB", *buf2 = "bbb"; 
   int ptr; 
   ptr = strcmpi(buf2, buf1); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 1n"); 
   if (ptr < 0) 
      printf("buffer 2 is less than buffer 1n"); 
   if (ptr == 0) 
      printf("buffer 2 equals buffer 1n"); 
   return 0; 
}

函数名: strcpy 功能: 串拷贝用法: char *strcpy(char *str1, char *str2); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
	char string[10]; 
	char *str1 = "abcdefghi"; 
	strcpy(string, str1); 
	printf("%sn", string); 
	return 0; 
}

函数名: strcspn 功能: 在串中查找第一个给定字符集内容的段用法: int strcspn(char *str1, char *str2); 程序例:

#include <stdio.h> 
#include <string.h> 
#include <alloc.h> 
int main(void) 
{ 
	char *string1 = "1234567890"; 
	char *string2 = "747DC8"; 
	int length; 
	length = strcspn(string1, string2); 
	printf("Character where strings intersect is at position %dn", length); 
	return 0; 
}

函数名: strdup 功能: 将串拷贝到新建的位置处用法: char *strdup(char *str); 程序例:

#include <stdio.h> 
#include <string.h> 
#include <alloc.h> 
int main(void) 
{ 
	char *dup_str, *string = "abcde"; 
	dup_str = strdup(string); 
	printf("%sn", dup_str); 
	free(dup_str); 
	return 0; 
}

函数名: stricmp 功能: 以大小写不敏感方式比较两个串用法: int stricmp(char *str1, char *str2); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *buf1 = "BBB", *buf2 = "bbb"; 
   int ptr; 
   ptr = stricmp(buf2, buf1); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 1n"); 
   if (ptr < 0) 
      printf("buffer 2 is less than buffer 1n"); 
   if (ptr == 0) 
      printf("buffer 2 equals buffer 1n"); 
   return 0; 
}

函数名: strerror 功能: 返回指向错误信息字符串的指针用法: char *strerror(int errnum); 程序例:

#include <stdio.h> 
#include <errno.h> 
int main(void) 
{ 
   char *buffer; 
   buffer = strerror(errno); 
   printf("Error: %sn", buffer); 
   return 0; 
}

函数名: strcmpi 功能: 将一个串与另一个比较, 不管大小写用法: int strcmpi(char *str1, char *str2); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *buf1 = "BBB", *buf2 = "bbb"; 
   int ptr; 
   ptr = strcmpi(buf2, buf1); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 1n"); 
   if (ptr < 0) 
      printf("buffer 2 is less than buffer 1n"); 
   if (ptr == 0) 
      printf("buffer 2 equals buffer 1n"); 
   return 0; 
}

函数名: strncmp 功能: 串比较用法: int strncmp(char *str1, char *str2, int maxlen); 程序例:

#include <string.h> 
#include <stdio.h> 
int  main(void) 
{ 
   char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc"; 
   int ptr; 
   ptr = strncmp(buf2,buf1,3); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 1n"); 
   else 
      printf("buffer 2 is less than buffer 1n"); 
   ptr = strncmp(buf2,buf3,3); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 3n"); 
   else 
      printf("buffer 2 is less than buffer 3n"); 
   return(0); 
}

函数名: strncmpi 功能: 把串中的一部分与另一串中的一部分比较, 不管大小写用法: int strncmpi(char *str1, char *str2); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *buf1 = "BBBccc", *buf2 = "bbbccc"; 
   int ptr; 
   ptr = strncmpi(buf2,buf1,3); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 1n"); 
   if (ptr < 0) 
      printf("buffer 2 is less than buffer 1n"); 
   if (ptr == 0) 
      printf("buffer 2 equals buffer 1n"); 
   return 0; 
}

函数名: strncpy 功能: 串拷贝用法: char *strncpy(char *destin, char *source, int maxlen); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char string[10]; 
   char *str1 = "abcdefghi"; 
   strncpy(string, str1, 3); 
   string[3] = ''; 
   printf("%sn", string); 
   return 0; 
}

函数名: strnicmp 功能: 不注重大小写地比较两个串用法: int strnicmp(char *str1, char *str2, unsigned maxlen); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *buf1 = "BBBccc", *buf2 = "bbbccc"; 
   int ptr; 
   ptr = strnicmp(buf2, buf1, 3); 
   if (ptr > 0) 
      printf("buffer 2 is greater than buffer 1n"); 
   if (ptr < 0) 
      printf("buffer 2 is less than buffer 1n"); 
   if (ptr == 0) 
      printf("buffer 2 equals buffer 1n"); 
   return 0; 
}

函数名: strnset 功能: 将一个串中的所有字符都设为指定字符用法: char *strnset(char *str, char ch, unsigned n); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char *string = "abcdefghijklmnopqrstuvwxyz"; 
   char letter = 'x'; 
   printf("string before strnset: %sn", string); 
   strnset(string, letter, 13); 
   printf("string after  strnset: %sn", string); 
   return 0; 
}

函数名: strpbrk 功能: 在串中查找给定字符集中的字符用法: char *strpbrk(char *str1, char *str2); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char *string1 = "abcdefghijklmnopqrstuvwxyz"; 
   char *string2 = "onm"; 
   char *ptr; 
   ptr = strpbrk(string1, string2); 
   if (ptr) 
      printf("strpbrk found first character: %cn", *ptr); 
   else 
      printf("strpbrk didn't find character in setn"); 
   return 0; 
}

函数名: strrchr 功能: 在串中查找指定字符的最后一个出现用法: char *strrchr(char *str, char c); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char string[15]; 
   char *ptr, c = 'r'; 
   strcpy(string, "This is a string"); 
   ptr = strrchr(string, c); 
   if (ptr) 
      printf("The character %c is at position: %dn", c, ptr-string); 
   else 
      printf("The character was not foundn"); 
   return 0; 
}

函数名: strrev 功能: 串倒转用法: char *strrev(char *str); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *forward = "string"; 
   printf("Before strrev(): %sn", forward); 
   strrev(forward); 
   printf("After strrev():  %sn", forward); 
   return 0; 
}

函数名: strset 功能: 将一个串中的所有字符都设为指定字符用法: char *strset(char *str, char c); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char string[10] = "123456789"; 
   char symbol = 'c'; 
   printf("Before strset(): %sn", string); 
   strset(string, symbol); 
   printf("After strset():  %sn", string); 
   return 0; 
}

函数名: strspn 功能: 在串中查找指定字符集的子集的第一次出现用法: int strspn(char *str1, char *str2); 程序例:

#include <stdio.h> 
#include <string.h> 
#include <alloc.h> 
int main(void) 
{ 
   char *string1 = "1234567890"; 
   char *string2 = "123DC8"; 
   int length; 
   length = strspn(string1, string2); 
   printf("Character where strings differ is at position %dn", length); 
   return 0; 
}

函数名: strstr 功能: 在串中查找指定字符串的第一次出现用法: char *strstr(char *str1, char *str2); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char *str1 = "Borland International", *str2 = "nation", *ptr; 
   ptr = strstr(str1, str2); 
   printf("The substring is: %sn", ptr); 
   return 0; 
}

函数名: strtod 功能: 将字符串转换为double型值用法: double strtod(char *str, char **endptr); 程序例:

#include <stdio.h> 
#include <stdlib.h> 
int main(void) 
{ 
   char input[80], *endptr; 
   double value; 
   printf("Enter a floating point number:"); 
   gets(input); 
   value = strtod(input, &endptr); 
   printf("The string is %s the number is %lfn", input, value); 
   return 0; 
}

函数名: strtok 功能: 查找由在第二个串中指定的分界符分隔开的单词用法: char *strtok(char *str1, char *str2); 程序例:

#include <string.h> 
#include <stdio.h> 
int main(void) 
{ 
   char input[16] = "abc,d"; 
   char *p; 
   /* strtok places a NULL terminator 
   in front of the token, if found */ 
   p = strtok(input, ","); 
   if (p)   printf("%sn", p); 
   /* A second call to strtok using a NULL 
   as the first parameter returns a pointer 
   to the character following the token  */ 
   p = strtok(NULL, ","); 
   if (p)   printf("%sn", p); 
   return 0; 
}

函数名: strtol 功能: 将串转换为长整数用法: long strtol(char *str, char **endptr, int base); 程序例:

#include <stdlib.h> 
#include <stdio.h> 
int main(void) 
{ 
   char *string = "87654321", *endptr; 
   long lnumber; 
   /* strtol converts string to long integer  */ 
   lnumber = strtol(string, &endptr, 10); 
   printf("string = %s  long = %ldn", string, lnumber); 
   return 0; 
}

函数名: strupr 功能: 将串中的小写字母转换为大写字母用法: char *strupr(char *str); 程序例:

#include <stdio.h> 
#include <string.h> 
int main(void) 
{ 
   char *string = "abcdefghijklmnopqrstuvwxyz", *ptr; 
   /* converts string to upper case characters */ 
   ptr = strupr(string); 
   printf("%sn", ptr); 
   return 0; 
}

函数名: swab 功能: 交换字节用法: void swab (char *from, char *to, int nbytes); 程序例:

#include <stdlib.h> 
#include <stdio.h> 
#include <string.h> 
char source[15] = "rFna koBlrna d"; 
char target[15]; 
int main(void) 
{ 
   swab(source, target, strlen(source)); 
   printf("This is target: %sn", target); 
   return 0; 
}

PS:isalpha()是字符函数，不是字符串函数，

isalpha

原型：extern int isalpha(int c);

用法：#include

功能：判断字符c是否为英文字母

说明：当c为英文字母a-z或A-Z时，返回非零值，否则返回零。

举例：

// isalpha.c
#include <syslib.h>
#include <ctype.h>
#include <stdio.h>
main()
{
   int c;
   clrscr();        // clear screen
   printf("Press a key");
   for(;;)
   {
      c=getchar();
      clrscr();
      printf("%c: %s letter",c,isalpha(c)?"is":"not");
   }
   return 0; // just to avoid warnings by compiler
}

C：

char st[100];

字符串长度 strlen(st);
字符串比较 strcmp(st1,st2); strncmp(st1,st2,n); //把st1,st2的前n个进行比较。
附加 strcat(st1,st2); strncat(st1,st2,n); //n表示连接上st2的前n个给st1，在最后不要加’\0’。
替换 strcpy(st1,st2); strncpy(st1,st2,n); //n表示复制st2的前n个给st1，在最后要加’\0’。
查找 where = strchr(st,ch) //ch为要找的字符。 where = strspn(st1,st2); //查找字符串。

C++：

string str; 1. 字符串长度 len = str.length(); len = str.size(); 2. 字符串比较可以直接比较也可以: str1.compare(str2); str1.compare(pos1,len1,str2,pos2,len2); //值为负，0 ，正。 nops 长度到完。 3. 附加 str1 += str2; 或 str1.append(str2); str1.append(str2.pos2,len2); 4. 字符串提取 str2 = str1.substr(); str2 = str1.substr(pos1); str2 = str1.substr(pos1,len1); 5. 字符串搜索 where = str1.find(str2); where = str1.find(str2,pos1); pos1是从str1的第几位开始。 where = str1.rfind(str2); 从后往前搜。 6. 插入字符串不是赋值语句。 str1.insert(pos1,str2); str1.insert(pos1,str2,pos2,len2); str1.insert(pos1,numchar,char); numchar是插入次数，char是要插入的字符。 7. 替换字符串 str1.replace(pos1,str2); str1.replace(pos1,str2,pos2,len2); 8. 删除字符串 str.erase(pos,len) str.clear(); 9. 交换字符串 swap(str1,str2); 10. C --> C++ char *cstr = "Hello"; string str1; cstr = cstr; string str2(cstr); 对于ACMer来说，C的字符串处理要比C++的方便、简单，尽量用C的字符串处理函数。转自:http://hi.baidu.com/czyuan_acm/blog/item/2c82f5df298f8a1749540309.html

C++的营养RAII

2010-02-21T00:00:00+00:00

莫华枫动物都会摄取食物，吸收其中的营养，用于自身生长和活动。然而，并非食物中所有的物质都能为动物所吸收。那些无法消化的物质，通过消化道的另一头（某些动物消化道只有一头）排出体外。不过，一种动物无法消化的排泄物，是另一种动物（生物）的食物，后者可以从中摄取所需的营养。一门编程语言，对于程序员而言，如同食物那样，包含着所需的养分。当然也包含着无法消化的东西。不同的是，随着程序员不断成长，会逐步消化过去无法消化的那些东西。 C+可以看作一种成分复杂的食物，对于多数程序员而言，是无法完全消化的。正因为如此，很多程序员认为C太难以消化，不应该去吃它。但是，C的营养不可谓不丰富，就此舍弃，而不加利用，则是莫大的罪过。好在食物可以通过加工，变得易于吸收，比如说发酵。鉴于程序员们的消化能力的差异，也为了让C的营养能够造福他人，我就暂且扮演一回酵母菌，把C+的某些营养单独提取出来，并加以分解，让那些消化能力不太强的程序员也能享受它的美味。:) （为了让这些营养便于消化，我将会用C#做一些案例。选择C#的原因很简单，因为我熟悉。:)） RAII RAII，好古怪的营养啊！它的全称应该是“Resource Acquire Is Initial”。这是C++创始人Bjarne Stroustrup发明的词汇，比较令人费解。说起来，RAII的含义倒也不算复杂。用白话说就是：在类的构造函数中分配资源，在析构函数中释放资源。这样，当一个对象创建的时候，构造函数会自动地被调用；而当这个对象被释放的时候，析构函数也会被自动调用。于是乎，一个对象的生命期结束后将会不再占用资源，资源的使用是安全可靠的。下面便是在C++中实现RAII的典型代码：

class file 
{ 
public: 
	file(string const& name) { 
		  m_fileHandle=open_file(name.cstr()); 
	} 
	~file() { 
		  close_file(m_fileHandle); 
	} 
	... 
private: 
	handle m_fileHandle; 
}

很典型的“在构造函数里获取，在析构函数里释放”。如果我写下代码：

void fun1() ...{ 
	file myfile("my.txt"); 
	... //操作文件 
}    //此处销毁对象，调用析构函数，释放资源

当函数结束时，局部对象myfile的生命周期也结束了，析构函数便会被调用，资源会得到释放。而且，如果函数中的代码抛出异常，那么析构函数也会被调用，资源同样会得到释放。所以，在RAII下，不仅仅资源安全，也是异常安全的。但是，在如下的代码中，资源不是安全的，尽管我们实现了RAII：

void fun2() ...{ 
	file pfile=new file("my.txt"); 
		... //操作文件 
}

因为我们在堆上创建了一个对象（通过new），但是却没有释放它。我们必须运用delete操作符显式地加以释放：

void fun3() ...{ 
	file pfile=new file("my.txt"); 
		... //操作文件 
		delete pfile; 
}

否则，非但对象中的资源得不到释放，连对象本身的内存也得不到回收。（将来，C++的标准中将会引入GC（垃圾收集），但正如下面分析的那样，GC依然无法确保资源的安全）。现在，在fun3()，资源是安全的，但却不是异常安全的。因为一旦函数中抛出异常，那么delete pfile;这句代码将没有机会被执行。C++领域的诸位大牛们告诫我们：如果想要在没有GC的情况下确保资源安全和异常安全，那么请使用智能指针：

void fun4() ...{ 
	  shared_ptr <file> spfile(new file("my.txt")); 
	  ... //操作文件 
}  //此处，spfile结束生命周期的时候，会释放（delete）对象

那么，智能指针又是怎么做到的呢？下面的代码告诉你其中的把戏（关于智能指针的更进一步的内容，请参考std::auto_ptr，boost或tr1的智能指针）：

template <typename T> 
class smart_ptr 
...{ 
public: 
	smart_ptr(T* p):m_ptr(p) ...{} 
	~smart_ptr() ...{ delete m_ptr; } 
	... 
private: 
	T* m_ptr; 
}

没错，还是RAII。也就是说，智能指针通过RAII来确保内存资源的安全，也间接地使得对象上的RAII得到实施。不过，这里的RAII并不是十分严格：对象（所占的内存也是资源）的创建（资源获取）是在构造函数之外进行的。广义上，我们也把它划归RAII范畴。但是，Matthew Wilson在《Imperfect C**》一书中，将其独立出来，称其为RRID（Resource Release Is Destruction）。RRID的实施需要在类的开发者和使用者之间建立契约，采用相同的方法获取和释放资源。比如，如果在shared_ptr构造时使用malloc()，便会出现问题，因为shared_ptr是通过delete释放对象的。对于内置了GC的语言，资源管理相对简单。不过，事情并非总是这样。下面的C#代码摘自MSDN Library的C#编程指南，我略微改造了一下：

static void CodeWithoutCleanup() 
...{ 
	System.IO.FileStream file = null; 
	System.IO.FileInfo fileInfo = new System.IO.FileInfo("C:\file.txt"); 
	file = fileInfo.OpenWrite(); 
	file.WriteByte(0xF); 
}

那么资源会不会泄漏呢？这取决于对象的实现。如果通过OpenWrite()获得的FileStream对象，在析构函数中执行了文件的释放操作，那么资源最终不会泄露。因为GC最终在执行GC操作的时候，会调用Finalize()函数（C#类的析构函数会隐式地转换成Finalize()函数的重载）。这是由于C#使用了引用语义（严格地讲，是对引用类型使用引用语义），一个对象实际上不是对象本身，而是对象的引用。如同C++中的那样，引用在离开作用域时，是不会释放对象的。否则，便无法将一个对象直接传递到函数之外。在这种情况下，如果没有显式地调用Close()之类的操作，资源将不会得到立刻释放。但是像文件、锁、数据库链接之类属于重要或稀缺的资源，如果等到GC执行回收，会造成资源不足。更有甚者，会造成代码执行上的问题。我曾经遇到过这样一件事：我执行了一个sql操作，获得一个结果集，然后执行下一个sql，结果无法执行。这是因为我使用的SQL Server 2000不允许在一个数据连接上同时打开两个结果集（很多数据库引擎都是这样）。第一个结果集用完后没有立刻释放，而GC操作则尚未启动，于是便造成在一个未关闭结果集的数据连接上无法执行新的sql的问题。所以，只要涉及了内存以外的资源，应当尽快释放。（当然，如果内存能够尽快释放，就更好了）。对于上述CodeWithoutCleanup()函数，应当在最后调用file对象上的Close()函数，以便释放文件：

static void CodeWithoutCleanup() 
...{ 
	System.IO.FileStream file = null; 
	System.IO.FileInfo fileInfo = new System.IO.FileInfo("C:\file.txt"); 
	file = fileInfo.OpenWrite(); 
	file.WriteByte(0xF); 
	file.Close(); 
}

现在，这个函数是严格资源安全的，但却不是严格异常安全的。如果在文件的操作中抛出异常，Close()成员将得不到调用。此时，文件也将无法及时关闭，直到GC完成。为此，需要对异常作出处理：

static void CodeWithCleanup() 
{
	System.IO.FileStream file = null; 
	System.IO.FileInfo fileInfo = null; 
	try 
	{ 
		fileInfo = new System.IO.FileInfo("C:\file.txt"); 
		file = fileInfo.OpenWrite(); 
		file.WriteByte(0xF); 
	} 
	catch(System.Exception e) 
	{ 
		System.Console.WriteLine(e.Message); 
	} 
	finally 
	{ 
		if (file != null) 
		{
			file.Close(); 
		}
	} 
}

try-catch-finally是处理这种情况的标准语句。但是，相比前面的C++代码fun1()和fun4()繁琐很多。这都是没有RAII的后果啊。下面，我们就来看看，如何在C#整出RAII来。一个有效的RAII应当包含两个部分：构造/析构函数的资源获取/释放和确定性的析构函数调用。前者在C#中不成问题，C#有构造函数和析构函数。不过， C#的构造函数和析构函数是不能用于RAII的，原因一会儿会看到。正确的做法是让一个类实现IDisposable接口，在IDisposable:: Dispose()函数中释放资源：

class RAIIFile : IDisposable 
{ 
	public RAIIFile(string fn) { 
		System.IO.FileInfo fileInfo = new System.IO.FileInfo(fn); 
		file = fileInfo.OpenWrite(); 
	} 

	public void Dispose() { 
	  file.Close(); 
	} 
	private System.IO.FileStream file = null; 
}

下一步，需要确保文件在退出作用域，或发生异常时被确定性地释放。这项工作需要通过C#的using语句实现：

static void CodeWithRAII() 
{ 
	using(RAIIFile file=new RAIIFile("C:\file.txt")) 
	{ 
		 //操作文件 
	} //文件释放 
}

原文: http://topic.csdn.net/u/20080216/08/afb1d694-803b-4248-9b0f-893225023491.html

Windows 平台上长路径名文件的解决方法

2010-02-21T00:00:00+00:00

强晟 (qiangsh@cn.ibm.com), 软件工程师, IBM 韩兆兵 (hanzb@cn.ibm.com), 软件工程师, IBM 2008 年 1 月 31 日上层逻辑控制和事务处理使用 Java 开发，而底层核心功能使用 C/C** 实现，这已经成为一种较为通用的开发模式。但由于 Windows 操作系统的默认设置，上述语言在对长路径名（>260 字符）文件的处理时会遇到一些问题。本文列出了不同的 JDK 版本在 Windows 操作系统上对于长路径名文件处理的区别，给出了两种支持长路径名文件的 C/C** 编程方法，同时还指出了从 JDK 5.0 开始才完全支持长路径名。使用本文的方法，可以解决在 Windows 平台上标准 API 函数对长路径名文件支持的局限性问题，给开发测试工作带来方便。

众所周知，微软的文件系统经历了 fat~~fat32~~>NTFS 的技术变革。且不论安全和文件组织方式上的革新，单就文件名而言，已经从古老的 DOS 8.3 文件格式（仅支持最长 8 个字符的文件名和 3 个字符的后缀名）转变为可以支持长达 255 个字符的文件名。而对于路径长度，NTFS 也已经支持长达 32768 个字符的路径名。然而，Windows 操作系统并没有完全放开路径名长度的限制，在 windef.h 中，可以找到如下的宏： #define MAX_PATH 260

事实上，所有的 Windows API 都遵循这个限制。因此，每当我们试图更改某一文件的文件名时，当输入的文件名长度 ( 全路径 ) 到达一定限度时，虽然文件名本身还未达到 255 个字符的限制，但是任何输入将不再被接受，这其实正是由于操作系统不允许 260 个字符（byte）的文件全路径。实际应用中，这种 260 个字符的全路径的限制给应用开发带来了很大的不便。试想如下应用：我们希望给应用服务器增加一个本地 cache 的功能，该功能可以把远程服务器上的文件留下一个本地的副本。一个合理的实现可以把 url 映射为文件名，当 url 很长时，cache 文件的长度也会很长。当文件名长度超过 255，我们可以把映射文件名的前 255 个字符作为目录名称。但是，我们仍然无法解决 260 个字符的全路径限制。另外，如果一个应用软件的目录结构过深，很容易出现某些文件名长度（含路径）超过 260 个字符，并因此造成安装或删除的失败。总而言之，该限制给我们的开发测试工作带来了诸多不便。对于一些网络服务器，往往需要将 Java 代码用于上层逻辑控制 / 事务处理的开发，同时将 C/C** 用于底层核心功能的实现。为此，我们研究了这两种程序语言对长路径名文件的支持情况。其中，对于 Java，比较了两个常用版本 1.4 和 5.0 对长路径支持的差异性；对于 C/C** 语言的局限性，提出了我们的解决方法。实验环境 : 操作系统： Windows xp 文件系统： NTFS 文件系统 Java 编译环境： IBM JDK 1.4.2 以及 IBM JDK 5.0 C** 编译环境： VC.net

Java 语言并不需要对长路径名文件进行特殊的处理，就可以支持长路径名文件的创建、读写和删除操作等基本操作。但是，JDK 1.4.2 和 JDK 5.0 在长路径的支持上是不同的，JDK 1.4.2 并不是完全支持所有的长路径名文件操作，比如访问文件属性的操作是不支持的。我们设计了如下代码来验证 JDK 1.4.2 和 JDK 5.0 对长路径名文件支持的区别。

try {
    String fileName = "E:\\VerylongpathVerylongpathVerylongpath
        VerylongpathVerylongpathVerylongpathVerylongpath
        VerylongpathVerylongpathVerylongpathVerylongpath\\
	VerylongpathVerylongpathVerylongpathVery
        longpathVerylongpathVerylongpathVerylongpath
	VerylongpathVerylongpathVerylongpathVerylongpa
        th.txt";
    System.out.println("Filename: " + fileName);
    System.out.println("File path length: " + fileName.length());
    String renameFileName = "E:\\VerylongpathVerylongpathVerylongpath
        VerylongpathVerylongpathVerylongpathVerylongpath
        VerylongpathVerylongpathVerylongpathVerylongpath\\Short.txt";
    //Create the file.
    File file = new File(fileName);
    if (!file.exists())
        file.createNewFile();
    if (file.exists())
        System.out.println("The file exists!");
    if (file.canRead())
        System.out.println("The file can be read!");
    if (file.canWrite())
        System.out.println("The file can be written!");
    if (file.isFile())
        System.out.println("It's a file!");
    //Write to the created file.
    FileOutputStream out = new FileOutputStream(file);
    PrintStream p = new PrintStream(out);
    p.println("This is only a test!");
    p.close();
    //Read the information from that file.
    BufferedReader br = new BufferedReader(new FileReader(file));
    StringBuffer sb = new StringBuffer();
    while (true) {
        String sl = br.readLine();
        if (sl == null) {
            break;
        } else {
            sb.append(sl + "\n");
        }
    }
    br.close();
    System.out.println("The content in the file:");
    System.out.print("\t" + sb.toString());
    //File rename
    File newfile = new File(renameFileName);
    if (newfile.exists())
        System.out.println(renameFileName + "exsited");
    else {
        if (file.renameTo(newfile)){
            System.out.println("Rename sucessful!");
        } else {
            System.out.println("Rename failed!");
        }	
    }
    //delete file
    if (file.delete())
        System.out.println("The old file deleted!");
    if (newfile.delete())
        System.out.println("The renamed file deleted!");
    }  catch (IOException e) {
        //Error happened
        e.printStackTrace();
        System.out.println("Error occurs in writing to the file.");
    }
}

File path length: 272

The content in the file:

This is only a test!

Rename failed!

The old file deleted!

从实验结果来看，JDK 1.4.2 得到了该长路径名文件的内容，因此，对于该长路径名文件的创建以及读写操作都是支持的。但是对比下文使用 JDK 5.0 的结果，可以看到，所有对于文件属性的判断都是错误的，同时，重命名的操作也无法实现。更为重要的是，JDK 1.4.2 存在着一个很致命的问题，即方法File.exists() 是失效的。通常，在删除文件前，需要调用该方法判断文件是否存在，对于 JDK 1.4.2，如果直接去删除一个不知道是否存在的文件，就会存在比较大的风险。因此，JDK 1.4.2 在 Windows 平台对长路径名文件的操作只是有限的支持，使用的时候，一定要注意。

Filename: E:\VerylongpathVerylongpathVerylongpath VerylongpathVerylongpathVerylongpathVerylongpathVer ylongpathVerylongpathVerylongpathVerylongpath
VerylongpathVerylongpathVerylongpathVerylong pathVerylongpathVerylongpathVerylongpath VerylongpathVerylongpathVerylongpathVerylongpath.txt File path length: 272 The file exists! The file can be read! The file can be written! It’s a file! The content in the file: This is only a test! Rename sucessful! The renamed file deleted!

从实验中可以清楚的看到，在版本 JDK 5.0 中，所有的文件操作（新建、读写、属性操作、重命名、删除等）都能够得到正确的处理。使用 JDK 5.0 就可以完全不用担心长路径名文件的使用问题。

相对于 JDK 5.0 不需要任何改动就可以支持长路径名文件，在 C/C** 中使用超过 260 个字符的路径长度的文件，会复杂得多。下面介绍两种支持长路径名文件的方法。

从微软官方网站 Path Field Limits，可以查到，使用 Unicode 版本的 API，对于使用 NTFS 文件系统的 Windows NT 4.0, Windows 2000, Windows XP Home Edition, Windows XP Professional 和 Windows Server 2003 操作系统，可以支持 32768 字节的文件路径长度。同时，路径名必须使用 \\?\ 的前缀。依照这个思路，我们设计了实验。

{
	FILE *from, *to;
	char filename[1024];
	strcpy(filename,"\\\\?\\E:\\VerylongpathVerylongpathVerylongpathVerylongpathVerylongpathV
	erylongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpath\\VerylongpathVeryl
	ongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpat
	hVerylongpathVerylongpath.txt");
	int iL1=MultiByteToWideChar(CP_ACP, 0, filename, strlen(filename), NULL, 0); 
	WCHAR* wfilename=new WCHAR[iL1+1]; 
	wfilename[iL1] = '\0';
	int iL2=MultiByteToWideChar(CP_ACP, 0, filename, strlen(filename), wfilename, iL1); 
	from = _wfopen( wfilename ,L"rb");
	to = fopen(".\\longpath.txt", "wb");
	if((from ==NULL)||(to==NULL))
		return -1;
	char buffer[1024];
	int count = 0;
	while ( (count = fread(buffer, sizeof(char), 1024, from)) != 0)
		fwrite( buffer, sizeof(char), count, to);
	delete []wfilename;
	fclose (from); fclose(to);
}

使用如上的方法，我们可以拷贝某长路径名的文件到当前文件夹中。从试验结果看，该方法是有效的。但是，由于该方法要求系统使用 Unicode 的 API，同时需要更改路径名称以及编码方式。因此，对于一个已经存在的系统，由于需要改变所有文件操作相关的 API，因此改动将会很大。

对于每一个长路径名，都有一个 8.3 格式（8 个字符的文件名和 3 个字符的后缀名）的短路径名与其相对应，任意的文件夹或者文件名都可以映射成一个 8 字符的文件名（A~B），其中 A 是文件名前缀，B 是表示字母序的顺序。操作系统可以保证这样的映射是一对一的，只要使用 GetShortPathName() 将长路径名转成相应的短路径名，就可以进行对该文件进行普通的文件操作。同时，在任何时候都可以用函数 GetLongPathName() 把 8.3 格式的短路径名恢复成初始的长路径名。如 GetShortPathName Function 叙述，我们需要一个 Unicode 版本的 API，同时在路径名前加上 \\?\ 的前缀，才能实现长短路径名间的切换。但从实验来看，即使不使用 Unicode 的 API，依然可以实现上述功能。

{
	char pathName [1024];
	strcpy(pathName,"\\\\?\\E:\\VerylongpathVerylongpathVerylongpathVerylongpathVerylongpathV
	erylongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpath\\VerylongpathVeryl
	ongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpathVerylongpat
	hVerylongpathVerylongpath.txt");
	const int MaxPathLength = 2048;
	char shortPath[MaxPathLength];
	if (strlen(pathName) >= MAX_PATH)
	{
		char prePath[] = "\\\\?\\";
		if (strlen(pathName) >= MaxPathLength - strlen(pathName))
			return false;
		sprintf(shortPath, "%s%s", prePath, pathName);
		for (int iPathIndex = 0; iPathIndex < strlen(shortPath); iPathIndex++)
			if (shortPath[iPathIndex] == '/')
				shortPath[iPathIndex] = '\\';
		int dwlen = GetShortPathName(shortPath, shortPath, MaxPathLength);
		if (dwlen <= 0)
			return false;
	}
}

经过上述的代码，超过 MAX_PATH 限制的路径名都可以转变成一个 8.3 格式的短路径名，可以把这个文件名 (shortPath)作为后续文件操作函数的参数。这种情况下，对于该文件的所有操作都可以被支持了。我们用这种缩短路径名长度的方式解决了长路径名文件的操作问题。

本文首先列出了不同的 JDK 版本在 Windows 操作系统上对于长路径名文件处理的区别，同时指出了 JDK 5.0 开始才完全支持长路径名；在第二部分中给出了两种支持长路径名文件的 C/C** 编程方法。使用上文中的任一方法，我们都可以实现对长路径名文件的操作，这将在很大程度上方便我们的开发工作，解决在 Windows 平台上标准 API 函数对长路径名文件支持的局限性问题。

以上实验代码仅在 Windows XP 操作系统和 VC.NET 编译环境中测试通过 , 作者不对其提供任何种类的保证。如果有任何问题 , 欢迎来信与作者讨论。

developerWorks Java 技术专区：这里有数百篇关于 Java 编程的文章。

强晟，IBM 中国软件开发中心工程师，在 WVS and EVV 组工作，从事 WebSphere Voice Server 相关产品的软件测试和技术支持工作。

韩兆兵，IBM 中国软件开发中心工程师，在 WVS and EVV 组工作，从事 Websphere VoiceServer 的技术支持工作。

http://www.ibm.com/developerworks/cn/java/j-lo-longpath.html

c++文件读写总结

2010-02-20T00:00:00+00:00

一、ASCII 输出为了使用下面的方法, 你必须包含头文件<fstream.h>(译者注：在标准C+*中，已经使用取代< fstream.h>，所有的C*+标准头文件都是无后缀的。)。这是 <iostream.h>的一个扩展集, 提供有缓冲的文件输入输出操作. 事实上, <iostream.h> 已经被<fstream.h>包含了, 所以你不必包含所有这两个文件, 如果你想显式包含他们，那随便你。我们从文件操作类的设计开始, 我会讲解如何进行ASCII I/O操作。如果你猜是"fstream," 恭喜你答对了！但这篇文章介绍的方法,我们分别使用"ifstream"?和 "ofstream" 来作输入输出。如果你用过标准控制台流"cin"?和 "cout," 那现在的事情对你来说很简单。我们现在开始讲输出部分，首先声明一个类对象。 ofstream fout; 这就可以了，不过你要打开一个文件的话, 必须像这样调用ofstream::open()。

fout.open(“output.txt”); 你也可以把文件名作为构造参数来打开一个文件.

ofstream fout(“output.txt”); 这是我们使用的方法, 因为这样创建和打开一个文件看起来更简单. 顺便说一句, 如果你要打开的文件不存在，它会为你创建一个, 所以不用担心文件创建的问题. 现在就输出到文件，看起来和”cout”的操作很像。对不了解控制台输出”cout”的人, 这里有个例子。

int num = 150; char name[] = “John Doe”; fout << “Here is a number: “ << num << “\n”; fout << “Now here is a string: “ << name << “\n”; 现在保存文件，你必须关闭文件，或者回写文件缓冲. 文件关闭之后就不能再操作了, 所以只有在你不再操作这个文件的时候 “ type=”text/javascript”> 才调用它，它会自动保存文件。回写缓冲区会在保持文件打开的情况下保存文件, 所以只要有必要就使用它。回写看起来像另一次输出, 然后调用方法关闭。像这样：

fout << flush; fout.close(); 现在你用文本编辑器打开文件，内容看起来是这样：

Here is a number: 150 Now here is a string: John Doe 很简单吧! 现在继续文件输入, 需要一点技巧, 所以先确认你已经明白了流操作，对 “<<” 和”>>” 比较熟悉了, 因为你接下来还要用到他们。继续…

二、ASCII 输入输入和”cin” 流很像. 和刚刚讨论的输出流很像, 但你要考虑几件事情。在我们开始复杂的内容之前, 先看一个文本：

12 GameDev 15.45 L This is really awesome! 为了打开这个文件，你必须创建一个in-stream对象,?像这样。

ifstream fin(“input.txt”); 现在读入前四行. 你还记得怎么用”<<” 操作符往流里插入变量和符号吧？好,?在 “<<” (插入)?操作符之后，是”>>” (提取) 操作符. 使用方法是一样的. 看这个代码片段.

int number; float real; char letter, word[8]; fin >> number; fin >> word; fin >> real; fin >> letter; 也可以把这四行读取文件的代码写为更简单的一行。

fin >> number >> word >> real >> letter; 它是如何运作的呢? 文件的每个空白之后, “>>” 操作符会停止读取内容, 直到遇到另一个>>操作符. 因为我们读取的每一行都被换行符分割开(是空白字符), “>>” 操作符只把这一行的内容读入变量。这就是这个代码也能正常工作的原因。但是，可别忘了文件的最后一行。

This is really awesome! 如果你想把整行读入一个char数组, 我们没办法用”>>“?操作符，因为每个单词之间的空格（空白字符）会中止文件的读取。为了验证：

char sentence[101]; fin >> sentence; 我们想包含整个句子, “This is really awesome!” 但是因为空白, 现在它只包含了”This”. 很明显, 肯定有读取整行的方法, 它就是getline()。这就是我们要做的。

fin.getline(sentence, 100); 这是函数参数. 第一个参数显然是用来接受的char数组. 第二个参数是在遇到换行符之前，数组允许接受的最大元素数量. 现在我们得到了想要的结果：“This is really awesome!”。你应该已经知道如何读取和写入ASCII文件了。但我们还不能罢休，因为二进制文件还在等着我们。

三、二进制输入输出二进制文件会复杂一点, 但还是很简单的。首先你要注意我们不再使用插入和提取操作符(译者注：<< 和 >> 操作符). 你可以这么做，但它不会用二进制方式读写。你必须使用read() 和write() 方法读取和写入二进制文件. 创建一个二进制文件, 看下一行。

ofstream fout(“file.dat”, ios::binary); 这会以二进制方式打开文件, 而不是默认的ASCII模式。首先从写入文件开始。函数write() 有两个参数。第一个是指向对象的char类型的指针, 第二个是对象的大小（译者注：字节数）。为了说明，看例子。

int number = 30; fout.write((char )(&number), sizeof(number)); 第一个参数写做”(char)(&number)”. 这是把一个整型变量转为char *指针。如果你不理解，可以立刻翻阅C++的书籍，如果有必要的话。第二个参数写作”sizeof(number)”. sizeof() 返回对象大小的字节数. 就是这样! 二进制文件最好的地方是可以在一行把一个结构写入文件。如果说，你的结构有12个不同的成员。用ASCII?文件，你不得不每次一条的写入所有成员。但二进制文件替你做好了。看这个。

struct OBJECT { int number; char letter; } obj; obj.number = 15; obj.letter = ‘M’; fout.write((char *)(&obj), sizeof(obj)); 这样就写入了整个结构! 接下来是输入. 输入也很简单，因为read()?函数的参数和 write()是完全一样的, 使用方法也相同。

ifstream fin(“file.dat”, ios::binary); fin.read((char *)(&obj), sizeof(obj)); 我不多解释用法, 因为它和write()是完全相同的。二进制文件比ASCII文件简单, 但有个缺点是无法用文本编辑器编辑。接着, 我解释一下ifstream 和ofstream 对象的其他一些方法作为结束.

四、更多方法我已经解释了ASCII文件和二进制文件, 这里是一些没有提及的底层方法。

检查文件你已经学会了open() 和close() 方法, 不过这里还有其它你可能用到的方法。方法good() 返回一个布尔值，表示文件打开是否正确。类似的，bad() 返回一个布尔值表示文件打开是否错误。如果出错，就不要继续进一步的操作了。最后一个检查的方法是fail(), 和bad()有点相似, 但没那么严重。

读文件方法get() 每次返回一个字符。方法ignore(int,char) 跳过一定数量的某个字符, 但你必须传给它两个参数。第一个是需要跳过的字符数。第二个是一个字符, 当遇到的时候就会停止。例子,

fin.ignore(100, ‘\n’); 会跳过100个字符，或者不足100的时候，跳过所有之前的字符，包括 ‘\n’。方法peek() 返回文件中的下一个字符, 但并不实际读取它。所以如果你用peek() 查看下一个字符, 用get() 在peek()之后读取，会得到同一个字符, 然后移动文件计数器。方法putback(char) 输入字符, 一次一个, 到流中。我没有见到过它的使用，但这个函数确实存在。

写文件只有一个你可能会关注的方法.?那就是 put(char), 它每次向输出流中写入一个字符。

打开文件当我们用这样的语法打开二进制文件:

ofstream fout(“file.dat”, ios::binary); “ios::binary”是你提供的打开选项的额外标志. 默认的, 文件以ASCII方式打开, 不存在则创建, 存在就覆盖. 这里有些额外的标志用来改变选项。

ios::app 添加到文件尾 ios::ate 把文件标志放在末尾而非起始。 ios::trunc 默认. 截断并覆写文件。 ios::nocreate 文件不存在也不创建。 ios::noreplace 文件存在则失败。

文件状态我用过的唯一一个状态函数是eof(), 它返回是否标志已经到了文件末尾。我主要用在循环中。例如, 这个代码断统计小写‘e’ 在文件中出现的次数。

ifstream fin(“file.txt”); char ch; int counter; while (!fin.eof()) { ch = fin.get(); if (ch == ‘e’) counter**; } fin.close(); 我从未用过这里没有提到的其他方法。还有很多方法，但是他们很少被使用。参考C++书籍或者文件流的帮助文档来了解其他的方法。

结论你应该已经掌握了如何使用ASCII文件和二进制文件。有很多方法可以帮你实现输入输出，尽管很少有人使用他们。我知道很多人不熟悉文件I/O操作，我希望这篇文章对你有所帮助。每个人都应该知道. 文件I/O还有很多显而易见的方法,?例如包含文件 <stdio.h>. 我更喜欢用流是因为他们更简单。祝所有读了这篇文章的人好运, 也许以后我还会为你们写些东西

无论读写都要包含头文件

读：从外部文件中将数据读到程序中来处理对于程序来说，是从外部读入数据，因此定义输入流，即定义输入流对象:ifsteam infile，infile就是输入流对象。这个对象当中存放即将从文件读入的数据流。假设有名字为myfile.txt的文件，存有两行数字数据，具体方法：

int a,b;
ifstream infile;
infile.open("myfile.txt");      //注意文件的路径
infile>>a>>b;                   //两行数据可以连续读出到变量里
infile.close();

如果是个很大的多行存储的文本型文件可以这么读：

char buf[1024];                //临时保存读取出来的文件内容
string message;
ifstream infile;
infile.open("myfile.js");
if(infile.is_open())          //文件打开成功,说明曾经写入过东西
{
 while(infile.good() && !infile.eof())
 {
   memset(buf,0,1024);
   infile.getline(buf,1204);
   message = buf;
   ......                     //这里可能对message做一些操作
   cout<<message<<endl;
 }
 infile.close();
}

写：将程序中处理后的数据写到文件当中对程序来说是将数据写出去，即数据离开程序，因此定义输出流对象ofstream outfile，outfile就是输出流对象，这个对象用来存放将要写到文件当中的数据。具体做法：

ofstream outfile;
outfile.open("myfile.bat");  //myfile.bat是存放数据的文件名
if(outfile.is_open())
{
  outfile<<message<<endl;    //message是程序中处理的数据
  outfile.close();
}
else
{
  cout<<"不能打开文件!"<<endl;
}

c++对文件的读写操作的例子

/*/从键盘读入一行字符，把其中的字母依次放在磁盘文件fa2.dat中，再把它从磁盘文件读入程序，将其中的小写字母改成大写字母，再存入磁盘fa3.dat中*/

#include<fstream>
#include<iostream>
#include<cmath>
using namespace std;
//////////////从键盘上读取字符的函数
void read_save(){
	char c[80];
	ofstream outfile("f1.dat");//以输出方工打开文件
	if(!outfile){
		cerr<<"open error!"<<endl;//注意是用的是cerr
		exit(1);
	}
	cin.getline(c,80);//从键盘读入一行字符
	for(int i=0;c[i]!=0;i++) //对字符一个一个的处理，直到遇到'/0'为止
		if(c[i]>=65&&c[i]<=90||c[i]>=97&&c[i]<=122){//保证输入的字符是字符
			outfile.put(c[i]);//将字母字符存入磁盘文件
			cout<<c[i]<<"";
		}
	cout<<endl;
	outfile.close();
}
void creat_data(){
	char ch;
	ifstream infile("f1.dat",ios::in);//以输入的方式打开文件
	if(!infile){
		cerr<<"open error!"<<endl;
		exit(1);
	}
	ofstream outfile("f3.dat");//定义输出流f3.dat文件
	if(!outfile){
		cerr<<"open error!"<<endl;
		exit(1);
	}
	while(infile.get(ch)){//当读取字符成功时
		if(ch<=122&&ch>=97)
		ch=ch-32;
		outfile.put(ch);
		cout<<ch;
	}
	cout<<endl;
	infile.close();
	outfile.close();
}
int main(){
	read_save();
	creat_data();
	system("pause");
	return 0;
}

转自:http://blog.csdn.net/shtianhai/archive/2008/05/02/2363841.aspx

C/C++ 文件读写操作总结

2010-02-20T00:00:00+00:00

在编程的过程中，文件的操作是一个经常用到的问题，在C++Builder中，可以使用多种方法对文件操作，下面我就按以下几个部分对此作详细介绍，就是：

1、基于C的文件操作； 2、基于C++的文件操作； 3、基于WINAPI的文件操作； 4、基于BCB库的文件操作； 5、特殊文件的操作。

壹、基于C的文件操作在ANSI C中，对文件的操作分为两种方式，即流式文件操作和I/O文件操作，下面就分别介绍之。

一、流式文件操作这种方式的文件操作有一个重要的结构FILE，FILE在stdio.h中定义如下：

typedef struct {
	int level; /* fill/empty level of buffer */
	unsigned flags; /* File status flags */
	char fd; /* File descriptor */
	unsigned char hold; /* Ungetc char if no buffer */
	int bsize; /* Buffer size */
	unsigned char _FAR *buffer; /* Data transfer buffer */
	unsigned char _FAR *curp; /* Current active pointer */
	unsigned istemp; /* Temporary file indicator */
	short token; /* Used for validity checking */
} FILE; /* This is the FILE object */

FILE这个结构包含了文件操作的基本属性，对文件的操作都要通过这个结构的指针来进行，此种文件操作常用的函数见下表函数功能 fopen() 打开流 fclose() 关闭流 fputc() 写一个字符到流中 fgetc() 从流中读一个字符 fseek() 在流中定位到指定的字符 fputs() 写字符串到流 fgets() 从流中读一行或指定个字符 fprintf() 按格式输出到流 fscanf() 从流中按格式读取 feof() 到达文件尾时返回真值 ferror() 发生错误时返回其值 rewind() 复位文件定位器到文件开始处 remove() 删除文件 fread() 从流中读指定个数的字符 fwrite() 向流中写指定个数的字符 tmpfile() 生成一个临时文件流 tmpnam() 生成一个唯一的文件名

下面就介绍一下这些函数

1.fopen() fopen的原型是：FILE *fopen(const char *filename,const char *mode)，fopen实现三个功能

为使用而打开一个流把一个文件和此流相连接给此流返回一个FILR指针参数filename指向要打开的文件名，mode表示打开状态的字符串，其取值如下表

字符串含义 “r” 以只读方式打开文件 “w” 以只写方式打开文件 “a” 以追加方式打开文件 “r+” 以读/写方式打开文件，如无文件出错 “w+” 以读/写方式打开文件，如无文件生成新文件

一个文件可以以文本模式或二进制模式打开，这两种的区别是：在文本模式中回车被当成一个字符’’\n’‘，而二进制模式认为它是两个字符0x0D,0x0A；如果在文件中读到0x1B，文本模式会认为这是文件结束符，也就是二进制模型不会对文件进行处理，而文本方式会按一定的方式对数据作相应的转换。

系统默认的是以文本模式打开，可以修改全部变量_fmode的值来修改这个设置，例如_fmode=O_TEXT；就设置默认打开方式为文本模式；而_fmode=O_BINARY；则设置默认打开方式是二进制模式。

我们也可以在模式字符串中指定打开的模式，如”rb”表示以二进制模式打开只读文件，”w+t”或”wt+”表示以文本模式打开读/写文件。

此函数返回一个FILE指针，所以申明一个FILE指针后不用初始化，而是用fopen()来返回一个指针并与一个特定的文件相连，如果成败，返回NULL。

例:

FILE *fp; 
if(fp=fopen("123.456","wb"))
puts("打开文件成功");
else 
puts("打开文件成败");

2.fclose() fclose()的功能就是关闭用fopen()打开的文件，其原型是：int fclose(FILE *fp);如果成功，返回0,失败返回EOF。

在程序结束时一定要记得关闭打开的文件，不然可能会造成数据丢失的情况，我以前就经常犯这样的毛病。

例：fclose(fp);

3.fputc() 向流写一个字符，原型是int fputc(int c, FILE *stream); 成功返回这个字符,失败返回EOF。

例：fputc(‘‘X’‘,fp);

4.fgetc() 从流中读一个字符，原型是int fputc(FILE *stream); 成功返回这个字符,失败返回EOF。

例：char ch1=fgetc(fp);

fseek() 此函数一般用于二进制模式打开的文件中，功能是定位到流中指定的位置，原型是int fseek(FILE *stream, long offset, int whence);如果成功返回0，参数offset是移动的字符数，whence是移动的基准，取值是

符号常量值基准位置 SEEK_SET 0 文件开头 SEEK_CUR 1 当前读写的位置 SEEK_END 2 文件尾部

例：fseek(fp,1234L,SEEK_CUR);//把读写位置从当前位置向后移动1234字节(L后缀表示长整数)

fseek(fp,0L,2);//把读写位置移动到文件尾

6.fputs() 写一个字符串到流中，原型int fputs(const char *s, FILE *stream);

例：fputs(“I Love You”,fp);

7.fgets() 从流中读一行或指定个字符，原型是char *fgets(char *s, int n, FILE *stream); 从流中读取n-1个字符，除非读完一行，参数s是来接收字符串，如果成功则返回s的指针，否则返回NULL。

例：如果一个文件的当前位置的文本如下

Love ,I Have

But ……..

如果用

fgets(str1,4,file1);

则执行后str1=”Lov”，读取了4-1=3个字符，而如果用

fgets(str1,23,file1);

则执行str=”Love ,I Have”，读取了一行(不包括行尾的’’\n’’)。

8.fprintf() 按格式输入到流，其原型是int fprintf(FILE *stream, const char *format[, argument, …]);其用法和printf()相同，不过不是写到控制台，而是写到流罢了

例：fprintf(fp,”%2d%s”,4,”Hahaha”);

9.fscanf() 从流中按格式读取，其原型是int fscanf(FILE *stream, const char *format[, address, …]);其用法和scanf()相同，不过不是从控制台读取，而是从流读取罢了。

例：fscanf(fp,”%d%d” ,&x,&y);

10.feof() 检测是否已到文件尾，是返回真，否则返回0，其原型是int feof(FILE *stream);

例：if(feof(fp))printf(“已到文件尾”);

11.ferror() 原型是int ferror(FILE *stream);返回流最近的错误代码，可用clearerr()来清除它，clearerr()的原型是void clearerr(FILE *stream);

例：printf(“%d”,ferror(fp));

12.rewind() 把当前的读写位置回到文件开始，原型是void rewind(FILE *stream);其实本函数相当于fseek(fp,0L,SEEK_SET);

例：rewind(fp);

12.remove() 删除文件，原型是int remove(const char *filename); 参数就是要删除的文件名，成功返回0。

例：remove(“c:\\io.sys”);

13.fread() 从流中读指定个数的字符，原型是size_t fread(void *ptr, size_t size, size_t n, FILE *stream);参数ptr是保存读取的数据，void*的指针可用任何类型的指针来替换，如char*、int *等等来替换；size是每块的字节数；n是读取的块数，如果成功，返回实际读取的块数(不是字节数)，本函数一般用于二进制模式打开的文件中。

例：

char x[4230]; FILE *file1=fopen(“c:\\msdos.sys”,”r”); fread(x,200,12 ,file1);//共读取200*12=2400个字节

14.fwrite() 与fread对应，向流中写指定的数据，原型是size_t fwrite(const void *ptr, size_t size, size_t n, FILE *stream);参数ptr是要写入的数据指针，void*的指针可用任何类型的指针来替换，如char*、int *等等来替换；size是每块的字节数；n是要写的块数，如果成功，返回实际写入的块数(不是字节数)，本函数一般用于二进制模式打开的文件中。

例：

char x[]=”I Love You”; fwire(x, 6,12,fp);//写入6*12=72字节

将把”I Love”写到流fp中12次，共72字节

15.tmpfile() 其原型是FILE *tmpfile(void); 生成一个临时文件，以”w+b”的模式打开，并返回这个临时流的指针，如果失败返回NULL。在程序结束时，这个文件会被自动删除。

例：FILE *fp=tmpfile();

16.tmpnam(); 其原型为char *tmpnam(char *s); 生成一个唯一的文件名，其实tmpfile()就调用了此函数，参数s用来保存得到的文件名，并返回这个指针，如果失败，返回NULL。

例：tmpnam(str1);

二、直接I/O文件操作这是C提供的另一种文件操作，它是通过直接存/取文件来完成对文件的处理，而上篇所说流式文件操作是通过缓冲区来进行；流式文件操作是围绕一个FILE指针来进行，而此类文件操作是围绕一个文件的“句柄”来进行，什么是句柄呢？它是一个整数，是系统用来标识一个文件(在WINDOWS中，句柄的概念扩展到所有设备资源的标识)的唯一的记号。此类文件操作常用的函数如下表，这些函数及其所用的一些符号在io.h和fcntl.h中定义，在使用时要加入相应的头文件。

函数说明 open() 打开一个文件并返回它的句柄 close() 关闭一个句柄 lseek() 定位到文件的指定位置 read() 块读文件 write() 块写文件 eof() 测试文件是否结束 filelength() 取得文件长度 rename() 重命名文件 chsize() 改变文件长度

下面就对这些函数一一说明：

1.open() 打开一个文件并返回它的句柄，如果失败，将返回一个小于0的值，原型是int open(const char *path, int access [, unsigned mode]); 参数path是要打开的文件名，access是打开的模式，mode是可选项。表示文件的属性，主要用于UNIX系统中，在DOS/WINDOWS这个参数没有意义。其中文件的打开模式如下表。

符号含义符号含义符号含义 O_RDONLY 只读方式 O_WRONLY 只写方式 O_RDWR 读/写方式 O_NDELAY 用于UNIX系统 O_APPEND 追加方式 O_CREAT 如果文件不存在就创建 O_TRUNC 把文件长度截为0 O_EXCL 和O_CREAT连用，如果文件存在返回错误 O_BINARY 二进制方式 O_TEXT 文本方式

对于多个要求，可以用”

“运算符来连接，如O_APPEND

O_TEXT表示以文本模式和追加方式打开文件。

例：int handle=open(“c:\\msdos.sys”,O_BINARY

O_CREAT

O_WRITE)

2.close() 关闭一个句柄，原型是int close(int handle);如果成功返回0

例：close(handle)

3.lseek() 定位到指定的位置，原型是：long lseek(int handle, long offset, int fromwhere);参数offset是移动的量，fromwhere是移动的基准位置，取值和前面讲的fseek()一样，SEEK_SET：文件首部；SEEK_CUR：文件当前位置；SEEK_END：文件尾。此函数返回执行后文件新的存取位置。

例：

lseek(handle,-1234L,SEEK_CUR);//把存取位置从当前位置向前移动1234个字节。 x=lseek(hnd1,0L,SEEK_END);//把存取位置移动到文件尾，x=文件尾的位置即文件长度

4.read() 从文件读取一块，原型是int read(int handle, void *buf, unsigned len);参数buf保存读出的数据，len是读取的字节。函数返回实际读出的字节。

例：char x[200];read(hnd1,x,200);

5.write() 写一块数据到文件中，原型是int write(int handle, void *buf, unsigned len);参数的含义同read()，返回实际写入的字节。

例：char x[]=”I Love You”;write(handle,x,strlen(x));

7.eof() 类似feof()，测试文件是否结束，是返回1，否则返回0;原型是：int eof(int handle);

例：while(!eof(handle1)){……};

8.filelength() 返回文件长度，原型是long filelength(int handle);相当于lseek(handle,0L,SEEK_END)

例：long x=filelength(handle);

9.rename() 重命名文件，原型是int rename(const char *oldname, const char *newname); 参数oldname是旧文件名，newname是新文件名。成功返回0

例：rename(“c:\\config.sys”,”c:\\config.w40”);

10.chsize(); 改变文件长度，原型是int chsize(int handle, long size);参数size表示文件新的长度，成功返回0，否则返回-1，如果指定的长度小于文件长度，则文件被截短；如果指定的长度大于文件长度，则在文件后面补’’\0’‘。

例：chsize(handle,0x12345);

如果熟悉汇编可能会发现这种方式和汇编语言的DOS功能调用句柄式文件操作很像，比如open()就像DOS服务的3CH号功能调用，其实这种操作还有两种类型的函数就是直接用DOS功能来完成的，如_open()，_dos_open()等等。有兴趣可自已查询BCB的帮助。

同流式文件操作相同，这种也提供了Unicode字符操作的函数，如_wopen()等等，用于9X/NT下的宽字符编程，有兴趣可自已查询BCB的帮助。

另外，此种操作还有lock(),unlock(),locking()等用于多用户操作的函数，但在BCB中用得并不多，我就不介绍了，但如果要用C来写CGI，这些就必要的常识了，如果你有这方面的要求，那就得自已好好看帮助了。

在C++中，有一个stream这个类，所有的I/O都以这个“流”类为基础的，包括我们要认识的文件I/O，stream这个类有两个重要的运算符：

1、插入器(<<) 向流输出数据。比如说系统有一个默认的标准输出流(cout)，一般情况下就是指的显示器，所以，cout<<“Write Stdout”<<’’\n’‘;就表示把字符串”Write Stdout”和换行字符(‘’\n’‘)输出到标准输出流。

2、析取器(>>) 从流中输入数据。比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

在C++中，对文件的操作是通过stream的子类fstream(file stream)来实现的，所以，要用这种方式操作文件，就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。

一、打开文件在fstream类中，有一个成员函数open()，就是用来打开文件的，其原型是：

void open(const char* filename,int mode,int access);

参数：

filename：　　要打开的文件名 mode：　　　　要打开文件的方式 access：　　　打开文件的属性打开文件的方式在类ios(是所有流式I/O类的基类)中定义，常用的值如下：

ios::app：　　　以追加的方式打开文件 ios::ate：　　　文件打开后定位到文件尾，ios:app就包含有此属性 ios::binary：　以二进制方式打开文件，缺省的方式是文本方式。两种方式的区别见前文 ios::in：　　　文件以输入方式打开 ios::out：　　　文件以输出方式打开 ios::nocreate：不建立文件，所以文件不存在时打开失败　 ios::noreplace：不覆盖文件，所以打开文件时如果文件存在失败 ios::trunc：　　如果文件存在，把文件长度设为0 可以用“或”把以上属性连接起来，如ios::out|ios::binary

打开文件的属性取值是：

0：普通文件，打开访问 1：只读文件 2：隐含文件 4：系统文件可以用“或”或者“+”把以上属性连接起来，如3或1|2就是以只读和隐含属性打开文件。

例如：以二进制输入方式打开文件c:\config.sys

fstream file1; file1.open(“c:\\config.sys”,ios::binary|ios::in,0);

如果open函数只有文件名一个参数，则是以读/写普通文件打开，即：

file1.open(“c:\\config.sys”);<=>file1.open(“c:\\config.sys”,ios::in

ios::out,0);

另外，fstream还有和open()一样的构造函数，对于上例，在定义的时侯就可以打开文件了：

fstream file1(“c:\\config.sys”);

特别提出的是，fstream有两个子类：ifstream(input file stream)和ofstream(outpu file stream)，ifstream默认以输入方式打开文件，而ofstream默认以输出方式打开文件。

ifstream file2(“c:\\pdos.def”);//以输入方式打开文件 ofstream file3(“c:\\x.123”);//以输出方式打开文件

所以，在实际应用中，根据需要的不同，选择不同的类来定义：如果想以输入方式打开，就用ifstream来定义；如果想以输出方式打开，就用ofstream来定义；如果想以输入/输出方式来打开，就用fstream来定义。

二、关闭文件打开的文件使用完成后一定要关闭，fstream提供了成员函数close()来完成此操作，如：file1.close();就把file1相连的文件关闭。

三、读写文件读写文件分为文本文件和二进制文件的读取，对于文本文件的读取比较简单，用插入器和析取器就可以了；而对于二进制的读取就要复杂些，下要就详细的介绍这两种方式

1、文本文件的读写文本文件的读写很简单：用插入器(<<)向文件输出；用析取器(>>)从文件输入。假设file1是以输入方式打开，file2以输出打开。示例如下：

file2<<“I Love You”;//向文件写入字符串”I Love You” int I; file1>>I;//从文件输入一个整数值。

这种方式还有一种简单的格式化能力，比如可以指定输出为16进制等等，具体的格式有以下一些

操纵符功能输入/输出 dec 格式化为十进制数值数据输入和输出 endl 输出一个换行符并刷新此流输出 ends 输出一个空字符输出 hex 格式化为十六进制数值数据输入和输出 oct 格式化为八进制数值数据输入和输出 setpxecision(int p) 设置浮点数的精度位数输出

比如要把123当作十六进制输出：file1<<hex<<123;要把3.1415926以5位精度输出：file1<<setpxecision(5)<<3.1415926。

2、二进制文件的读写 ①put() put()函数向流写入一个字符，其原型是ofstream &put(char ch)，使用也比较简单，如file1.put(‘‘c’’);就是向流写一个字符’‘c’‘。

②get() get()函数比较灵活，有3种常用的重载形式：

一种就是和put()对应的形式：ifstream &get(char &ch);功能是从流中读取一个字符，结果保存在引用ch中，如果到文件尾，返回空字符。如file2.get(x);表示从文件中读取一个字符，并把读取的字符保存在x中。

另一种重载形式的原型是： int get();这种形式是从流中返回一个字符，如果到达文件尾，返回EOF，如x=file2.get();和上例功能是一样的。

还有一种形式的原型是：ifstream &get(char *buf,int num,char delim=’’\n’’)；这种形式把字符读入由 buf 指向的数组，直到读入了 num 个字符或遇到了由 delim 指定的字符，如果没使用 delim 这个参数，将使用缺省值换行符’’\n’‘。例如：

file2.get(str1,127,’‘A’’);//从文件中读取字符到字符串str1，当遇到字符’‘A’‘或读取了127个字符时终止。

③读写数据块要读写二进制数据块，使用成员函数read()和write()成员函数，它们原型如下：

read(unsigned char *buf,int num); write(const unsigned char *buf,int num);

read()从文件中读取 num 个字符到 buf 指向的缓存中，如果在还未读入 num 个字符时就到了文件尾，可以用成员函数 int gcount();来取得实际读取的字符数；而 write() 从buf 指向的缓存写 num 个字符到文件中，值得注意的是缓存的类型是 unsigned char *，有时可能需要类型转换。

例：

unsigned char str1[]="I Love You";
int n[5];
ifstream in("xxx.xxx");
ofstream out("yyy.yyy");
out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中
in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数，注意类型转换
in.close();out.close();

四、检测EOF 成员函数eof()用来检测是否到达文件尾，如果到达文件尾返回非0值，否则返回0。原型是int eof();

例：

if(in.eof())ShowMessage("已经到达文件尾！");

五、文件定位

和C的文件操作方式不同的是，C** I/O系统管理两个与一个文件相联系的指针。一个是读指针，它说明输入操作在文件中的位置；另一个是写指针，它下次写操作的位置。每次执行输入或输出时，相应的指针自动变化。所以，C++的文件定位分为读位置和写位置的定位，对应的成员函数是 seekg()和 seekp()，seekg()是设置读位置，seekp是设置写位置。它们最通用的形式如下：

istream &seekg(streamoff offset,seek_dir origin); ostream &seekp(streamoff offset,seek_dir origin);

streamoff定义于 iostream.h 中，定义有偏移量 offset 所能取得的最大值，seek_dir 表示移动的基准位置，是一个有以下值的枚举：

ios::beg：　　文件开头 ios::cur：　　文件当前位置 ios::end：　　文件结尾这两个函数一般用于二进制文件，因为文本文件会因为系统对字符的解释而可能与预想的值不同。

例：

file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节 file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字节

有了这些知识，我们就可以完成对文件的操作了，当然，还有好多的成员函数我没介绍，但有这些我们已经能完成大多数的需要了，这种文件操作方式是我比较喜欢的一种方法，比C的方法灵活，又比BCB函数和WINAPI函数具有通用性。

下一次，我将介绍BCB提供的文件操作的库函数。

在BCB中也提供了文件操作的函数，这些函数的功能和前面所介绍的大致相同，但这类函数和BCB关系紧密，能使用BCB中的AnsiString等数据类型，在BCB中用这种方式的文件操作是最方便的，下面我就把这种文件操作详细介绍。

在BCB提供的这组文件操作函数中，可分为三种类型，就是：1、文件名函数，2、文件管理函数；3、文件I/O函数。

1、文件名函数文件名函数可以对文件的名称、所在子目录、驱动器和扩展名等进行操作。下表列出这些函数及其功能。

函数说明 ExpandFileName() 返回文件的全路径(含驱动器、路径) ExtractFileExt() 从文件名中抽取扩展名 ExtractFileName() 从文件名中抽取不含路径的文件名 ExtractFilePath() 从文件名中抽取路径名 ExtractFileDir() 从文件名中抽取目录名 ExtractFileDrive() 从文件名中抽取驱动器名 ChangeFileExt() 改变文件的扩展名 ExpandUNCFileName() 返回含有网络驱动器的文件全路径 ExtractRelativePath() 从文件名中抽取相对路径信息 ExtractShortPathName() 把文件名转化为DOS的8·3格式 MatchesMask() 检查文件是否与指定的文件名格式匹配

下面就把这些函数作一一介绍：

⑴ExpandFileName() 原型：extern PACKAGE AnsiString __fastcall ExpandFileName(const AnsiString FileName);

功能：返回文件的全路径(含驱动器、路径)

参数：FileName:要处理的文件名

例：ShowMessage(ExpandFileName(Application->ExeName));//显示你的程序文件名，如C:\MyBCB\Sample1.EXE

⑵ExtractFileExt() 原型：extern PACKAGE AnsiString __fastcall ExtractFileExt(const AnsiString FileName);

功能：从文件名中抽取扩展名

参数：FileName:要处理的文件名（全路径）

例：ShowMessage(ExtractFileExt(Application->ExeName));//显示”.exe”

⑶ExtractFileName() 原型：extern PACKAGE AnsiString __fastcall ExtractFileName(const AnsiString FileName);

功能：从文件名中抽取不含路径的文件名

参数：FileName:要处理的文件名

例：ShowMessage(ExtractFileExt(“c:\\Winnt\\SOL.EXE”));//显示”SOL.EXE”

⑷ExtractFilePath() 原型：extern PACKAGE AnsiString __fastcall ExtractFilePath(const AnsiString FileName);

功能：从文件名中抽取路径名

参数：FileName:要处理的文件名

例：ShowMessage(ExtractFilePath(“Winnt\\SOL.EXE”));//显示”Winnt\”

⑸ExtractFileDir() 原型：extern PACKAGE AnsiString __fastcall ExtractFileDir(const AnsiString FileName);

功能：从文件名中抽取目录名(和上个函数不同，不包括最后的”\”)

参数：FileName:要处理的文件名

例：ShowMessage(ExtractFileDir(“Winnt\\SOL.EXE”));//显示”Winnt”,注意和上个函数的区别

⑹ExtractFileDrive() 原型：extern PACKAGE AnsiString __fastcall ExtractFileDrive(const AnsiString FileName);

功能：从文件名中抽取驱动器名

参数：FileName:要处理的文件名

例：ShowMessage(ExtractFileDrive(“c:\\Winnt\\SOL.EXE”));//显示”c:”

⑺ChangeFileExt() 原型：extern PACKAGE System::AnsiString __fastcall ChangeFileExt(const System::AnsiString FileName, const System::AnsiString Extension);

功能：更改文件名的扩展名，不是对真正的文件进行改名，只是对文件名这个字符串进行处理

参数：FileName:要改名的文件名，Extension：新的扩展名

例：ShowMessage(ChangeFileExt(“c:\\Winnt\\SOL.EXE”,”.OOO”));//显示”c:\winnt\SOL.OOO”

⑻ExpandUNCFileName() 原型：extern PACKAGE AnsiString __fastcall ExpandUNCFileName(const AnsiString FileName);

功能：返回含有网络驱动器的文件全路径，格式为：\\机器名\共享名\文件名

参数：FileName:要处理的文件名

例：ShowMessage(ExpandUNCFileName(“F:\\Winnt\\SOL.EXE”));/*如果F:是映射的网络驱动器\\NT40\WINNT，则显示”\\NT40\WINNT\SOL.EXE”*/

⑼ExtractRelativePath() 原型：extern PACKAGE AnsiString __fastcall ExtractRelativePath(const AnsiString BaseName, const AnsiString DestName);

功能：从文件名中抽取相对路径信息，如”..\sss\ss.asd”这种形式

参数：BaseName：基准文件名；DestName：目标文件名

例：ShowMessage(ExtractRelativePath(“D:\\Source\\c\\1.123”,”D:\\Source\\Asm\\dz.asm”));/*显示”..\asm\dz.asm”*/

⑽ExtractShortPathName() 原型：extern PACKAGE AnsiString __fastcall ExtractShortPathName(const AnsiString FileName);

功能：把文件名转换为DOS的8、3格式

参数：FileName:要处理的文件名

例：ShowMessage(ExtractShortPathName(“E:\\Program Files\\Dual Wheel Mouse\\4dmain.exe”));/*显示”E:\Progra~1\dualwh~1\4dmain.exe”*/

⑾MatchesMask() 原型：extern PACKAGE bool __fastcall MatchesMask(const AnsiString Filename, const AnsiString Mask);

功能：检查文件是否与指定的文件名格式匹配

参数：FileName:要处理的文件名；Mask:文件名格式，支持通配符

例：ShowMessage(MatchesMask(“Lxf.exe”,”*.?x?));//显示”true”

2、文件管理函数这类函数包括设置和读取驱动器、子目录和文件的有关的各种操作，下表列出这类操作常用的函数及其功能。

函数功能 CreateDir() 创建新的子目录 DeleteFile() 删除文件 DirectoryExists() 判断目录是否存在 DiskFree() 获取磁盘剩余空间 DiskSize() 获取磁盘容量 FileExists() 判断文件是否存在 FileGetAttr() 获取文件属性 FileGetDate() 获取文件日期 GetCurrentDir() 获取当前目录 RemoveDir() 删除目录 SetCurrentDir() 设置当前目录

下面就把这些函数作一一介绍：

⑴CreateDir() 原型：extern PACKAGE bool __fastcall CreateDir(const System::AnsiString Dir);

功能：建立子目录，如果成功返回true，否则返回false

参数：Dir:要建立的子目录的名字

例：Create(“ASM”);//在当前目录下建立一个名为ASM的子目录

⑵DeleteFile() 原型：extern PACKAGE bool __fastcall DeleteFile(const System::AnsiString FileName);

功能：删除文件，如果成功返回true，否则返回false

参数：FileName:要删除的文件名

例：if(OpenDialog1~~Execute())DeleteFile(OpenDialog1~~>FileName);

⑶DirectoryExists() 原型：extern PACKAGE bool __fastcall DirectoryExists(const System:: AnsiString Name);

功能：检测目录是否存在，如果存在返回true，否则返回false

参数：Name:要检测的目录名

例：if(!DirectoryExists(“ASM”))CreateDir(“ASM”);//如果ASM这个目录不存在则创建之

⑷DiskFree() 原型：extern PACKAGE _int64_fastcall DiskFree(Byte Drive);

功能：检测磁盘剩余空间，返回值以字节为单位，如果指定的磁盘无效，返回-1

参数：Drive：磁盘的代号，0表示当前盘, 1=A,2=B,3=C 以此类推

例：ShowMessage(DiskFree(0));//显示当前盘的剩余空间

⑸DiskSize() 原型：extern PACKAGE _int64_fastcall DiskSize(Byte Drive);

功能：检测磁盘容量，返回值以字节为单位，如果指定的磁盘无效，返回-1

参数：Drive：磁盘的代号，0表示当前盘, 1=A,2=B,3=C 以此类推

例：ShowMessage(DiskFree(0));//显示当前盘的容量

⑹FileExists() 原型：extern PACKAGE bool __fastcall FileExists(const AnsiString FileName);

功能：检测文件是否存在，如果存在返回true，否则返回false

参数：FileName:要检测的文件名

例：if(FileExists(“AAA.ASM”))DeleteFile(“AAA.ASM”);

⑺FileGetAttr() 原型：extern PACKAGE int __fastcall FileGetAttr(const AnsiString FileName);

功能：取得文件属性，如果出错返回-1

返回值如下表，如果返回$00000006表示是一个具有隐含和系统属性的文件(4+2)

常量值含义 faReadOnly $00000001 只读文件 faHidden $00000002 隐含文件 faSysFile $00000004 系统文件 faVolumeID $00000008 卷标 faDirectory $00000010 目录 faArchive $00000020 归档文件

例：if(FileGetAttr(“LLL.TXT”)&0x2)ShowMessage(“这是一个有隐含属性的文件”);

与此对应的有FileSetAttr() ，请自已查阅帮助系统

⑻FileGetDate() 原型：extern PACKAGE int __fastcall FileGetDate(int Handle);

功能：返回文件的建立时间到1970-1-1日0时的秒数

参数：Handle:用FileOpen()打开的文件句柄。

例：

int i=FileOpen(“C:\\autoexec.bat”,fmOpenRead); ShowMessage(FileGetDate(i)); FileClose(i);

与此对应的有FileSetDate()，请自已查阅帮助系统

⑼GetCurrentDir() 原型：extern PACKAGE AnsiString __fastcall GetCurrentDir();

功能：取得当前的目录名

例：ShowMessage(GetCurrentDir());

⑽RemoveDir() 原型：extern PACKAGE bool __fastcall RemoveDir(const AnsiString Dir);

功能：删除目录，如果成功返回true，否则返回false

参数：Dir:要删除的目录名

例：if(DiectoryExists(“ASM”))RemoveDir(“ASM”);

⑾SetCurrentDir() 原型：extern PACKAGE bool __fastcall SetCurrentDir(const AnsiString Dir);

功能：设置当前目录，如果成功返回true，否则返回false

参数：Dir:要切换到的目录名

例：SetCurrentDir(“C:\\WINDOWS”);

3、文件I/O函数这类函数完成对文件的读写相关的操作，这种类型的操作和C的基于I/O文件操作类似，下表列出这类操作常用的函数及其功能。

FileOpen() 打开文件 FileClose() 关闭文件 FileRead() 读文件 FileSeek() 文件定位 FileWrite() 写文件 FileCreate() 创建文件

下面就对这些函数作详细介绍。

⑴FileOpen() 原型：extern PACKAGE int __fastcall FileOpen(const AnsiString FileName, int Mode);

功能：打开文件，如果成功返回其句柄，否则返回-1

参数：FileName:要打开的文件名；Mode：打开的方式，取值如下表，可用”或”(“

“)运算符连接。

常量值说明

fmOpenRead 0 以只读属性打开 fmOpenWrite 1 以只写属性打开 fmOpenReadWrite 2 以读/写属性打开 fmShareCompat 0 兼容FCB方式(汇编中有相应的DOS功能调用，感兴趣自已查阅相关资料) fmShareExclusive 16 共享方式：以独占方式打开，在关闭以前，别人不能访问 fmShareDenyWrite 32 共享方式：拒绝写访问 fmShareDenyRead 48 共享方式：拒绝读访问 fmShareDenyNone 64 共享方式：无限制，允许读写例：int i=FileOpen(“C:\\WINDOWS\\Win.ini”,fmOpenReadWrite|fmShareExclusive);

⑵FileClose() 原型：extern PACKAGE void __fastcall FileClose(int Handle);

功能：关闭打开的句柄。

参数：Handle:要关闭的句柄

例：FileClose(i);

⑶FileRead() 原型：extern PACKAGE int __fastcall FileRead(int Handle, void *Buffer, int Count);

功能：读文件，返回实际读取的字节数，句柄必须首先由FileOpen或FileCreate创建。

参数：Handle:要读取的句柄；Buffer:存放读取的数据的缓冲区；Count:想读取的字节数

例：char str[400];FileRead(hnd1,str,400);

⑷FileSeek() 原型：extern PACKAGE int __fastcall FileSeek(int Handle, int Offset, int Origin);

功能：移动文件读取指针，成功返回文件指针的位置，失败返回-1

参数：Handle:相关联的句柄；Offset:移动的量；Orgin:移动的基准，0=文件头，1=当前位置，2=文件尾。

例：ShowMessage(FileSeek(hnd1,0,2));//取得文件的长度

⑸FileWrite() 原型：extern PACKAGE int __fastcall FileWrite(int Handle, const void *Buffer, int Count);

功能：写文件，返回实际写入的字节数，句柄必须首先由FileOpen或FileCreate创建。

参数：Handle:要写入的句柄；Buffer:存放写入数据的缓冲区；Count:想写入的字节数

例：char str[]=”I Love You”;FileWrite(hnd1,str,strlen(str));

⑹FileCreate() 原型：extern PACKAGE int __fastcall FileCreate(const AnsiString FileName);

功能：创建文件。成功返回其句柄，否则返回-1

参数：FileName:要创建的文件名

例：if(!FileExists(“KC.C”))hnd1=FileCreate(“KC.C”);

C中的Variable length arrays (变长数组)

2010-02-10T00:00:00+00:00

Variable length arrays 是C99的特性，而不是 C++98 的，关于c99标准的变长数组, 在标准的6.7.5.2 Array declarators里面有这样的说明: 2.Only ordinary identifiers (as defined in 6.2.3) with both block scope or function prototype scope and no linkage shall have a variably modified type. If an identifier is declared to be an object with static storage duration, it shall not have a variable length array type. 换而言之, 变长数组不能是在静态存储区(包括全局变量和静态变量)中的。另外，VLA 需要支持 sizeof 运算，动态sizeof 也是C99的一个特有特性。目前很多C+编译器尚不能支持动态数组特性(VC2005不支持此特性， GCC3.2之后支持，之前的版本没有调查，不知道是从哪个版本开始支持此特性的)。gcc的文档里面说:Variable-length automatic arrays are allowed in ISO C99, and as an extension GCC accepts them in C89 mode and in C+。所以，使用GCC，即使你打开 -ansi (等价于 –std=c89)选项，也仍然可以使用动态数组。其实C99的VLA也不是真正意义上的变长数组—它只是在运行时可以根据一个变量生成一个数组，此数组此后并不会变化，而真正意义的变长数组可以在实际使用时可以动态伸缩。过去的C 和现在的C++中，自动变量的偏移都是预定的，但是VLA不能这样实现。下面的例子中，由于b, c大小不确定，所以它们的地址必须是运行时确定的

void test(int tmp)
{
	int a;
	scanf("%d", &a);
	int b[tmp];
	int c[a];
	printf ("size(b) = %d, size(c) = %d\n", sizeof(b)/sizeof(int), sizeof(c)/sizeof(int));
}

VLA在栈上分配空间，这个速度很快。我们举一个典型的32位编译器下函数实现为例子。这个实现中，下面两个寄存器关注函数堆栈：

ebp：函数占有内容起点即帧(frame)的位置， esp：当前栈顶

一般来说，一个函数中自动变量个数和大小都是确定的。比如共有4个int，一个大小为10的 float 数组。编译器可以简单的 esp -= 56 就留出所有空间(以32位PC机为例)。每个变量相对 ebp 的偏移也是确定的，所以，若他访问 int a，

$a = 4，他会这样访问： $a [ ebp ]

对于 VLA 来说，事情复杂一些。现在有一个 VLA c。他的大小是不确定的 —— 所以它的偏移也是不确定的：如果它之前有另外一个 VLA b，它不可能知道自己排到哪里。目前 GCC 中的做法是，在可变数组较少的情况下，直接用寄存器+偏移的方式来存取；在较多的情况下，都是先从堆栈中得到数组的起始地址, 然后再用偏移量的方式存取数组的元素。

这个操作是非常快的。不过有一个问题是，栈的大小是固定的，而且不大。你不能分配很大的东西。另外这个数组是临时的 —— 一旦退出当前作用域，他就可以被任何其他函数刷掉。

变长数组的特性综述（摘自[2]）：

变长数组是分配在堆栈上的, 其实从语义的角度也应该是这样, 变长数组还是一个数组, 还是一个局部变量, 在c语言中, 局部变量是分配在堆栈上的, malloc才是分配在堆上面的. 这里面没有不存在什么内存泄漏, 因为堆栈上的内存是不需要程序员管理的
变长数组和其他变量共同存在于一个作用域之内时, 变长数组是在最后分配的, 也就是处在堆栈的最下面(地址最低). 这也是变长数组不同于普通变量的情况, 普通变量的内存分配是按照定义顺序来的, 先定义的先分配, 但是变长数组不是这样的, 在一个作用域内变长数组都是放到最后分配的, 原因很简单, 变长数组的大小在编译时无法确定, 所以如果在变长数组后面分配普通变量的空间, 那么对后面普通变量的存取就不方便了,当然简单的情况可以通过优化解决, 但是如果有很多的变量数组和普通变量混合在一起的话,优化很难做到很好, 所以把变长数组都放在最后面分配, 是一个比较合理的办法; 当然, 不是说一定要放在最后, 按照普通的定义顺序来分配空间也是可以的,只是在存取可变数组后面的变量的时候, 需要首先找到可变数组的起始地址, 然后再往下(低地址) 找到后面变量的地址, 存取相应的变量。目前gcc所使用的放到最后的做法, 也可以理解成一种优化. 。
对变长数组的元素存取, 可以把首地址放在寄存器里面, 也可以在把首地址放在堆栈里面,然后存取元素的时候先取出首地址, 然后在通过偏移量的方式存取里面的元素.

4.变长数组不能在静态存储区中, 这个很显然, 静态存储区在编译时就确定分配内存的大小,不像堆栈一样是动态的, 变长数组显然不能定义在静态存储区中.

变长数组的意义, 我觉得在c里面还是有一些意义, 如果是在对性能,内存要求十分严格的地方, 允许声明变长数组还是比较方便的, 因为原来需要一块连续内存的地方要么声明的大一些,保证肯定够用, 但这样就浪费了, 在对内存要求严格的地方就不好了, 另外一种做法就是malloc动态分配, 但是这样的缺点是需要手动管理, 要手动free, 程序如果大的话内存管理不好的话容易内存泄漏,所以在c里面还是有一些意义. 但是在c+里面已经有vector了, 而且c+也不太多应用在对性能,内存要求非常高的地方,

6.使用变长数组, 最重要的当然是要检查数组的size的合法性了, 我前面举例为了减少干扰因素, 都没有做检查, 实际的程序肯定要做这个检查, 则面试的时候这样的程序肯定立刻被kick. 另外, 就是又多了一种堆栈溢出的方法,数组大小如果是负的话又可以跳到不该跳到的地方了

转自：http://hi.baidu.com/fenqin/blog/item/e86a5c602c3364dd8db10d9c.html

鲎(hou)

2010-02-10T00:00:00+00:00

鲎亦称马蹄蟹。肢口纲(Merostomata)剑尾目(Xiphosura)海生节肢动物，共4种，见于亚洲和北美东海岸。虽又称马蹄蟹，但不是蟹，而与蝎、蜘蛛以及已绝灭的三叶虫有亲缘关系。鲎(horseshoe crab)是一类与三叶虫 (现在只有化石)一样古老的动物。鲎的祖先出现在地质历史时期古生代的泥盆纪,当时恐龙尚未崛起，原始鱼类刚刚问世，随着时间的推移，与它同时代的动物或者进化、或者灭绝，而惟独只有鲎从4 亿多年前问世至今仍保留其原始而古老的相貌，所以鲎有“活化石”之称。又具有很高的药用价值血液是蓝色的。含有Cu

维基百科中的数据压缩算法

2010-02-10T00:00:00+00:00

http://zh.wikipedia.org/zh-cn/%E6%95%B0%E6%8D%AE%E5%8E%8B%E7%BC%A9

mysql的innodb_flush_log_at_trx_commit

2010-02-02T00:00:00+00:00

mysql的innodb_flush_log_at_trx_commit

innodb_buffer_pool_size 如果用Innodb，那么这是一个重要变量。相对于MyISAM来说，Innodb对于buffer size更敏感。MySIAM可能对于大数据量使用默认的key_buffer_size也还好，但Innodb在大数据量时用默认值就感觉在爬了。 Innodb的缓冲池会缓存数据和索引，所以不需要给系统的缓存留空间，如果只用Innodb，可以把这个值设为内存的70%-80%。和 key_buffer相同，如果数据量比较小也不怎么增加，那么不要把这个值设太高也可以提高内存的使用率。 innodb_additional_pool_size 这个的效果不是很明显，至少是当操作系统能合理分配内存时。但你可能仍需要设成20M或更多一点以看Innodb会分配多少内存做其他用途。 innodb_log_file_size 对于写很多尤其是大数据量时非常重要。要注意，大的文件提供更高的性能，但数据库恢复时会用更多的时间。我一般用64M-512M，具体取决于服务器的空间。 innodb_log_buffer_size 默认值对于多数中等写操作和事务短的运用都是可以的。如果经常做更新或者使用了很多blob数据，应该增大这个值。但太大了也是浪费内存，因为1秒钟总会 flush（这个词的中文怎么说呢？）一次，所以不需要设到超过1秒的需求。8M-16M一般应该够了。小的运用可以设更小一点。 innodb_flush_log_at_trx_commit （这个很管用）抱怨Innodb比MyISAM慢 100倍？那么你大概是忘了调整这个值。默认值1的意思是每一次事务提交或事务外的指令都需要把日志写入（flush）硬盘，这是很费时的。特别是使用电池供电缓存（Battery backed up cache）时。设成2对于很多运用，特别是从MyISAM表转过来的是可以的，它的意思是不写入硬盘而是写入系统缓存。日志仍然会每秒flush到硬盘，所以你一般不会丢失超过1-2秒的更新。设成0会更快一点，但安全方面比较差，即使MySQL挂了也可能会丢失事务的数据。而值2只会在整个操作系统挂了时才可能丢数据。

转自:http://swachian.javaeye.com/blog/193788

C++中虚析构函数的作用

2010-02-02T00:00:00+00:00

我们知道，用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** 程序员都知道这样的危险性。当然，如果在析构函数中做了其他工作的话，那你的所有努力也都是白费力气。所以，文章开头的那个问题的答案就是－－这样做是为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。当然，并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。所以，只有当一个类被用来作为基类的时候，才把析构函数写成虚函数。

转自:http://blog.csdn.net/starlee/archive/2006/03/09/619827.aspx

c/c++支持可变参数的函数

2010-02-02T00:00:00+00:00

c/c++支持可变参数的函数

一、为什么要使用可变参数的函数？一般我们编程的时候，函数中形式参数的数目通常是确定的，在调用时要依次给出与形式参数对应的所有实际参数。但在某些情况下希望函数的参数个数可以根据需要确定，因此c语言引入可变参数函数。这也是c功能强大的一个方面，其它某些语言，比如fortran就没有这个功能。典型的可变参数函数的例子有大家熟悉的printf()、scanf()等。二、c/c++如何实现可变参数的函数？为了支持可变参数函数，C语言引入新的调用协议，即C语言调用约定 _cdecl . 采用C/C++语言编程的时候，默认使用这个调用约定。如果要采用其它调用约定，必须添加其它关键字声明，例如WIN32 API使用PASCAL调用约定，函数名字之前必须加_stdcall关键字。采用C调用约定时，函数的参数是从右到左入栈，个数可变。由于函数体不能预先知道传进来的参数个数，因此采用本约定时必须由函数调用者负责堆栈清理。举个例子：

//C调用约定函数
int __cdecl Add(int a, int b)
{
	return (a + b);
}

函数调用： Add(1, 2); //汇编代码是： push 2 ;参数b入栈 push 1 ;参数a入栈 call @Add ;调用函数。其实还有编译器用于定位函数的表达式这里把它省略了 add esp,8 ;调用者负责清栈

如果调用函数的时候使用的调用协议和函数原型中声明的不一致，就会导致栈错误，这是另外一个话题，这里不再细说。另外c/c++编译器采用宏的形式支持可变参数函数。这些宏包括va_start、va_arg和va_end等。之所以这么做，是为了增加程序的可移植性。屏蔽不同的硬件平台造成的差异。支持可变参数函数的所有宏都定义在stdarg.h 和 varargs.h中。例如标准ANSI形式下，这些宏的定义是：

typedef char * va_list; //字符串指针
#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap)      ( ap = (va_list)0 )

使用宏_INTSIZEOF是为了按照整数字节对齐指针，因为c调用协议下面，参数入栈都是整数字节(指针或者值)。三、如何定义这类的函数。可变参数函数在不同的系统下，采用不同的形式定义。 1、用ANSI标准形式时，参数个数可变的函数的原型声明是：

type funcname(type para1, type para2, ...);

关于这个定义，有三点需要说明：一般来说，这种形式至少需要一个普通的形式参数，可变参数就是通过三个’.’来定义的。所以”……”不表示省略，而是函数原型的一部分。type是函数返回值和形式参数的类型。例如：

int MyPrintf(char const* fmt, ...);

但是，我们也可以这样定义函数：

void MyFunc(...);

但是，这样的话，我们就无法使用函数的参数了，因为无法通过上面所讲的宏来提取每个参数。所以除非你的函数代码中的确没有用到参数表中的任何参数，否则必须在参数表中使用至少一个普通参数。注意，可变参数只能位于函数参数表的最后。不能这样：

void MyFunc(..., int i);

2、采用与UNIX 兼容系统下的声明方式时，参数个数可变的函数原型是：

type funcname(va_alist);

但是要求函数实现的时候，函数名字后面必须加上va_dcl.例如：

#include 
int average( va_list );
void main( void )
{
   ...//代码
}
/* UNIX兼容形式*/
int average( va_alist )
va_dcl
{
   ...//代码
}

这种形式不需要提供任何普通的形式参数。type是函数返回值的类型。va_dcl是对函数原型声明中参数va_alist的详细声明，实际是一个宏定义。根据平台的不同，va_dcl的定义稍有不同。在varargs.h中，va_dcl的定义后面已经包括了一个分号。因此函数实现的时候，va_dcl后不再需要加上分号了。 3、采用头文件stdarg.h编写的程序是符合ANSI标准的，可以在各种操作系统和硬件上运行;而采用头文件varargs.h的方式仅仅是为了与以前的程序兼容，两种方式的基本原理是一致的，只是在语法形式上有一些细微的区别。所以一般编程的时候使用stdarg.h.下面的所有例子代码都采用ANSI标准格式。

四、可变参数函数的基本使用方法下面通过若干例子，说明如何实现可变参数函数的定义和调用。

//================================ 例子程序1 ===============
#include < stdio.h >
#include < string.h >
#include < stdarg.h >
/* 函数原型声明，至少需要一个确定的参数，注意括号内的省略号 */
int demo( char *, ... );
void main( void )
{
	demo("DEMO", "This", "is", "a", "demo!", "\0");
}
int demo( char *msg, ... )
{
	va_list argp; /* 定义保存函数参数的结构 */
	int argno = 0; /* 纪录参数个数 */
	char *para; /* 存放取出的字符串参数 */
	// 使用宏va_start, 使argp指向传入的第一个可选参数，
	// 注意 msg是参数表中最后一个确定的参数，并非参数表中第一个参数
	va_start( argp, msg );
	while (1)
	{
		//取出当前的参数，类型为char *
		//如果不给出正确的类型，将得到错误的参数
		para = va_arg( argp, char *);
		if ( strcmp( para, "\0") == 0 ) /* 采用空串指示参数输入结束 */
		   break;
		printf("参数 #%d 是: %s\n", argno, para);
		argno++;
	}
	va_end( argp ); /* 将argp置为NULL */
	return 0;
}

//输出结果参数 #0 是: This 参数 #1 是: is 参数 #2 是: a 参数 #3 是: demo! 注意到上面的例子没有使用第一个参数，下面的例子将使用所有参数

//================================ 例子程序2 ===============
#include <stdio.h>
#include <stdarg.h>
int average( int first, ... ); //输入若干整数，求它们的平均值
void main( void )
{
   /* 调用3个整数(-1表示结尾) */
   printf( "Average is: %d\n", average(2,3,4, -1));
   /*调用4个整数*/
   printf( "Average is: %d\n", average(5,7,9, 11,-1));
   /*只有结束符的调用*/
   printf( "Average is: %d\n", average(-1) );
}
/* 返回若干整数平均值的函数 */
int average( int first, ... )
{
   int count = 0, sum = 0, i = first;
   va_list marker;
   va_start( marker, first ); //初始化
   while( i != -1 )
   {
      sum += i; //先加第一个参数
      count++;
      i = va_arg( marker, int);//取下一个参数
   }
   va_end( marker );
   return( sum ? (sum / count) : 0 );
}

//输出结果 Average is: 3 Average is: 8 Average is: 0

五、关于可变参数的传递问题有人问到这个问题，假如我定义了一个可变参数函数，在这个函数内部又要调用其它可变参数函数，那么如何传递参数呢？上面的例子都是使用宏va_arg逐个把参数提取出来使用，能否不提取，直接把它们传递给另外的函数呢？我们先看printf的实现：

int __cdecl printf (const char *format, ...)
{
	va_list arglist;
	int buffing;
	int retval;
	va_start(arglist, format); //arglist指向format后面的第一个参数
	...//不关心其它代码
	retval = _output(stdout,format,arglist); //把format格式和参数传递给output函数
	...//不关心其它代码
	return(retval);
}

我们先模仿这个函数写一个：

#include <stdio.h>
#include <stdarg.h>
int mywrite(char *fmt, ...)
{
     va_list arglist;
     va_start(arglist, fmt);
     return printf(fmt,arglist);
}
void main()
{
	int i=10, j=20;
	char buf[] = "This is a test";
	double f= 12.345;
	mywrite("String: %s\nInt: %d, %d\nFloat :%4.2f\n", buf, i, j, f);
}

运行一下看看，哈，错误百出。仔细分析原因，根据宏的定义我们知道 arglist是一个指针，它指向第一个可变的参数，但是所有的参数都位于栈中，所以arglist指向栈中某个位置，通过arglist的值，我们可以直接查看栈里面的内容： arglist -> 指向栈里面，内容包括 0067FD78 E0 FD 67 00 //指向字符串”This is a test” 0067FD7C 0A 00 00 00 //整数 i 的值 0067FD80 14 00 00 00 //整数 j 的值 0067FD84 71 3D 0A D7 //double 变量 f，占用8个字节 0067FD88 A3 B0 28 40 0067FD8C 00 00 00 00 如果直接调用 printf(fmt， arglist); 仅仅是把arglist指针的值0067FD78入栈，然后把格式字符串入栈，相当于调用： printf(fmt， 0067FD78); 自然这样的调用肯定会出现错误。我们能不能逐个把参数提取出来，再传递给其它函数呢？先考虑一次性把所有参数传递进去的问题。如果调用的是系统库函数，这种情况下是不可能的。因为提取参数是在运行态，而参数入栈是在编译的时候确定的。无法让编译器预知运行态的事情给出正确的参数入栈代码。而我们在运行态虽然可以提取每个参数，但是无法将参数一次性全部压栈，即使使用汇编代码实现起来也是很困难的，因为不单是一个简单的push代码就可以做到。如果接受参数的函数也是我们自己写的，自然我们可以把arglist指针入栈，然后在函数中自己解析arglist指针里面的参数，逐个提取出来处理。但是这样做似乎没有什么意义，一方面，这个函数没有必要也做成可变参数函数，另一方面直接在第一个函数中解析参数，然后处理不是更简单么？我们唯一可以做到的是，逐个解析参数，然后循环中调用其它可变参数函数，每次传递一个参数。这里又有一个问题，就是参数表中的不可变参数的传递问题，有些情况下不能简单的传递，以上面的例子为例，通常我们解析参数的同时，还需要解析格式字符串：

#include <windows.h>
#include <stdio.h>
#include <stdarg.h>
//测试一下这个，开个玩笑
void t(...)
{
	printf("\n");
}
int mywrite(char *fmt, ...)
{
	va_list arglist;
	va_start(arglist, fmt);
	char temp[255];
	strcpy(temp, fmt); //Copy the Format string
	char Format[255];
	char *p = strchr(temp,'%');
	int i=0;
	int iParam;
	double fParam;
	while(p != NULL)
	{
	   while((*p<'a' || *p>'z') && (*p!=0) ) p++;
	   if(*p == 0)break;
	   p++;
	   //格式字符串
	   int nChar = p - temp;
	   strncpy(Format,temp, nChar);
	   Format[nChar] = 0;
	   //参数
	   if(Format[nChar-1] != 'f')
	   {
		iParam = va_arg( arglist, int);
		printf(Format, iParam);
	   }
	   else
	   {
		fParam = va_arg( arglist, double);
		printf(Format, fParam);
	   }
	   i++;
	   if(*p == 0) break;
	   strcpy(temp, p);
	   p = strchr(temp, '%');
	}
	if(temp[0] != 0)
	   printf(temp);
	return i;
}
void main()
{
	int i=10, j=20;
	char buf[] = "This is a test";
	double f= 123.456;
	mywrite("String: %s\nInt: %d, %d\nFloat :%4.2f\nEnd", buf, i, j, f, 0);
	t("aaa", i);
}

//输出： String: This is a test Int: 10, 20 Float :123.46 End

当然这里的解析是不完善的。

动态加载DLL的方法与注意的问题

2010-02-02T00:00:00+00:00

加载DLL的方法主要有两种：一种是隐式链接，另外一种是动态加载。隐式链接会把DLL中所有标志为__declspec(dllexport)的函数都加载，如果有多个DLL加载时，可能会影响到程序执行的效率。而用动态加载DLL的方式则可以根据需要去加载用到的函数。动态加载DLL的方法： 1.把生成的.DLL文件复制到测试工程DLLTest目录下。这里假设该.DLL文件为add.dll，主要代码是：

__declspec(dllexport) int add(int x, int y)
{
    return x + y;
}

2.在DLLTest工程中添加DllTest.cpp文件. 首先使用LoadLibrary(“add.dll”)加载add.dll文件:

HMODULE hmod = LoadLibrary("add.dll");

然后定义一个函数指针的类型：

typedef int (*AddAddr)(int x, int y);

注意，这里的参数与返回类型务必与add.dll文件中函数add的声明一样。

接着：

AddAddr Add = (AddAddr)GetProcAddress(hmod, "add");
//如果Add值为空，则获取函数的地址失败！
if(!Add)
{
    printf("获取函数地址失败！");
    return;
}

最后，可以测试一下：

printf("test add(): 1+2=%d", add(1,2));

运行结果一看，会出现“获取函数地址失败！”。为什么会这样？

打开命令行，用cd命令到add.dll工程目录的debug目录下，然后使用命令： dumpbin -exports add.dll

则会看到add.dll文件中的add函数的名称为“?add@YAHHHZ”，而不是函数名add，这是C++编译器的命名改编机制。修改原来的代码：

AddAddr Add = (AddAddr)GetProcAddress(hmod, "?add@@YAHHH@Z");

这时运行就成功了。但如果按这样去动态加载DLL，那每次获取函数地址都要使用dumpbin命令去获取，则会很麻烦。

那怎样可以直接使用add而不是 ?add@YAHHHZ这个长长的字符串呢，修改add.dll的add函数，在函数前加上extern “C”，再编译add.dll文件所在的工程，复制新生成的add.dll覆盖DLLTest工程目录下的add.dll，原来的代码获取函数地址时使用add，结果运行就成功了。

而再使用dumpbin -exports add.dll命令，显示add.dll的中的add函数的名称变成了add.

ostringstream函数的使用

2010-02-02T00:00:00+00:00

当存在未知数据大小的时候,可以使用 ostringstream 来代替 sprintf , 避免总是申请大量的缓冲区.用法可以参照下面转载的文章.

另外解决今天遇到的一个问题,如果要重复使用一个ostringstream对象,并且需要在下次使用前清空缓冲区,则可以使用str()函数重设置缓冲区. 如:

ostringstream  osSql;
//first time
osSql<<"SELECT  COUNT(*) FROM t_XXXX";
...
clsConnection.Query( osSql );
....
//second time
osSql.str("");//重新使用一个空的缓冲区
osSql<<"INSERT INTO **********"<<  strBigText  ;
.......

以下转载一篇关于 ostringstream 的用法的文章

在写程序的时候,我们往往需要对字符串进行格式化, 比如写SQL语句的时候. 在ANSI C 中可以sprintf(), 在MFC中可以用CString::Format()对字符串进行格式化. 但前者无法实现字符串的动态增加,比如你定义的字符缓存为100个字节,如果你格式化以后的内容超出了100个字节,那边后面的内容就无法看见. 所以一般来讲都为定义一个足够的字符缓冲,但这样的效率是很差的. 后者虽然可以解决这个问题,但有一点, 他和前者一样,存在着安全隐患. 比如下面的代码

char buf[100]={0};
const char* str = "string";
sprintf(buf,"this is a string : %s , %s", str);

或者

CString s;
s.Format("this is a string: %s, %s",str);

前面那个%s对应第一个参数str,那么第二个%s呢, 指针指向何方? 如果你幸运的话,什么事也不会发生或者你仅仅获得一个你觉得莫名奇妙的字符串值. 但更严重的情况呢, 不用说—-访问越界

如果你使用STL的sstream,那么一切将归于寂然:

#include<sstream>
...
ostringstream str;
str<<"this is a str" << "string"<<"and this is a interger<<3<<endl;

你不必考虑字符串的增长问题, 也不用在写程序时去一一匹配你的format函数的format参数是否一一匹配(如果你的参数很多,那么这项检查工作将是一个让你头痛万分的工作).

一切都是如此的简单.

如果你想获取格式化好的字符串, 通过ostringstream::str()函数就可以返回一个string对象, 调用string::c_str() 或string::data()函数就可以获得一个指向字符缓冲的char*变量.

另外, 我坚决建议用string替代CString . 因为CString在设计时考虑到效率问题, 内存是重复利用的, 即:一个进程中所有的CString对象都使用同一个内存缓冲区,且这个内存区运行时不会释放,直到进程结束为止. 如果缓冲不够,他会无限制往上增长. 如果你设计的系统是一个7*24运行的系统且字符串分析工作量很大,程序中产生了大量的CString对象的话, 你可能会发现你的内存会不断的上涨. string同样有一个很优秀且高效率的内存管理机制,但他不会死守着你的内存不放,这一点你看看STL的源码就知道了.

如果你觉定采用STL,那么建议你使用VC7.0作为开发环境或者GCC , 因为这两款开发工具对STL支持是还算不错.尤其是GCC. 如果你坚持用VC6的话,那么你最好打上SP5补丁包, VC6对STL的支持不够理想.

c/c++ 整形转字符串

2010-02-02T00:00:00+00:00

用itoa

#include   <stdlib.h>   
#include   <stdio.h>   
void   main(void)   
{   
	char   buffer[20];   
	int     i   =   3445;   
	long   l   =   -344115L;   
	unsigned   long   ul   =   1234567890UL;   
	 _itoa(   i,   buffer,   10   );   
	printf(   "String   of   integer   %d   (radix   10):   %s\n",   i,   buffer   );   
	_itoa(   i,   buffer,   16   );   
	printf(   "String   of   integer   %d   (radix   16):   0x%s\n",   i,   buffer   );   
	_itoa(   i,   buffer,   2     );   
	printf(   "String   of   integer   %d   (radix   2):   %s\n",   i,   buffer   );   
	_ltoa(   l,   buffer,   16   );   
	printf(   "String   of   long   int   %ld   (radix   16):   0x%s\n",   l,     
	_ultoa(   ul,   buffer,   16   ); 
	printf(   "String   of   unsigned   long   %lu   (radix   16):   0x%s\n",   ul, buffer   );
}

用ostringstream，传说比itoa安全

#include   <sstream>   
......   
int   i=123;   
ostringstream   oss;   
oss<<i;   
string   s=oss.str();   
......

用springf，常用

int   i=123;   
char   csTemp[20];   
string   str;   

sprintf(cs,   "%d",   i);   
str   =   cs;

InnoDB 启动选项

2010-02-02T00:00:00+00:00

2 InnoDB 启动选项

为了在 MySQL-Max-3.23 中使用 InnoDB 表，你必须在配置文件‘my.cnf’或‘my.ini’（WINDOWS系统）中的 [mysqld] 区中详细指定配置参数。

作为最小设置，在 3.23 中你必须在 innodb_data_file_path 上指定数据文件名能及大小。如果在‘my.cnf’中没有指定innodb_data_home_dir，系统将在 MySQL 的 datadir 目录下创建数据文件。如果将 innodb_data_home_dir 设为一个空串，那可以在 innodb_data_file_path 中给定一个绝对路径。在 MySQL-4.0 中可以不设定 innodb_data_file_path ：MySQL-4.0 将默认地在 datadir 目录下建立一个 10 MB 大小自扩充(auto-extending)的文件‘ibdata1’(在MySQL-4.0.0 与 4.0.1 中数据文件的大小为 64 MB 并且是非自扩充的(not auto-extending))。

为了得到更好的性能你必须所示的例子明确地设定 InnoDB 启动参数。

从 3.23.50 版和 4.0.2 版开始，InnoDB 允许在 innodb_data_file_path 中设置的最一个数据文件描述为 auto-extending。 innodb_data_file_path 语法如下所示：

pathtodatafile:sizespecification;pathtodatafile:sizespec;… …;pathtodatafile:sizespec[:autoextend[:max:sizespecification]]

如果用 autoextend 选项描述最后一个数据文件，当 InnoDB 用尽所有表自由空间后将会自动扩充最后一个数据文件，每次增量为 8 MB。示例：

innodb_data_home_dir = innodb_data_file_path = /ibdata/ibdata1:100M:autoextend

指定 InnoDB 只建立一个最初大小为 100 MB 并且当表空间被用尽时以 8MB 每块增加的数据文件。如果硬盘空间不足，可以再添加一个数据文件并将其放在其它的硬盘中。举例来说：先检查硬盘空间的大小，设定 ibdata1 文件使它接近于硬盘空余空间大小并为 1024 * 1024 bytes (= 1 MB)的倍数，将 ibdata1 明确地指定在 innodb_data_file_path 中。在此之后可以添加另一个数据文件：

innodb_data_home_dir = innodb_data_file_path = /ibdata/ibdata1:988M;/disk2/ibdata2:50M:autoextend

注意：设定文件大小时一定要注意你的OS是否有最大文件尺寸为2GB的限制！InnoDB是不会注意你的OS文件尺寸限制的，在一些文件系统中你可能要设定最大容量限制：

innodb_data_home_dir = innodb_data_file_path = /ibdata/ibdata1:100M:autoextend:max:2000M

一个简单的 my.cnf 例子。假设你的计算机有 128 MB RAM 和一个硬盘。下面的例子是为了使用 InnoDB 而在 my.cnf 或 my.ini 文件中可能所作的一些配置。我们假设你运行的是 MySQL-Max-3.23.50 及以上版本，或 MySQL-4.0.2 及以上版本。

这个示例适合大部分不需要将 InnoDB 数据文件和日志文件放在几个盘上的 Unix 和 Windows 用户。这个例子在 MySQL 的datadir 目录(典型的为 /mysql/data)中创建一个自扩充(auto-extending)的数据文件 ibdata1 和两个 InnoDB 运行日志文件ib_logfile0 和 ib_logfile1 以及 ib_arch_log_0000000000 档案文件。

[mysqld] #在这里加入其它的 MySQL 服务器配置 #… # 数据文件必须 # 能够容下数据与索引 # 确定有足够的 # 磁盘空间 innodb_data_file_path = ibdata1:10M:autoextend # 设置缓冲池的大小为 # 你的主内存大小的 # 50 - 80 % set-variable = innodb_buffer_pool_size=70M set-variable = innodb_additional_mem_pool_size=10M # 设置日志文件的大小约为 # 缓冲池(buffer pool) # 大小的 25 % set-variable = innodb_log_file_size=20M set-variable = innodb_log_buffer_size=8M # 如果丢失最近几个事务影响 # 不大的话可以设置 # .._flush_log_at_trx_commit = 0 innodb_flush_log_at_trx_commit=1

InnoDB 不会自己建立目录，必须自己使用操作系统命令建立相应的目录。检查你的 MySQL 服务程序在 datadir 目录里有足够的权限建立文件。

注意：在某些文件系统中数据文件大小必须小于2G！所有运行日志文件的大小总和必须小于 2G 或 4G,这依赖于具体的 MySQL 系统版本。数据文件的总和必须大于等于 10 MB.

当第一次建立 InnoDB 数据库时，建议最好以命令行方式启动 MySQL 服务。这样 InnoDB 数据库建立时的提示信息将在屏幕上显示，从而可以看到建立过程。下面第 3 节所示就是 InnoDB 数据库建立时的屏幕显示。例如，在 Windows 下使用下列指令启动 mysqld-max.exe ：

your-path-to-mysqld>mysqld-max –console

在 Windows 系统下 my.cnf 或 my.ini 放在哪里？规则如下：

只能存在一个 my.cnf 或 my.ini 文件 my.cnf 文件必须放在 C: 的根目录下 my.ini 文件必须放在 WINDIR 目录下，例：C:\WINDOWS 或 C:\WINNT。可以使用 MS-DOS 的 SET 命令查看 WINDIR 目录值如果你的 PC 使用启动引导程序引导系统而 C: 不是启动磁盘，那只能唯一地使用 my.ini 作为设置文件

Unix 下在哪里指定配置文件？在 Unix 下 mysqld 按下列顺序搜索配置文件：

/etc/my.cnf 全局选项 COMPILATION_DATADIR/my.cnf 服务器范围的选项 defaults-extra-file 采用 –defaults-extra-file=…. 设置的默认文件 ~/.my.cnf 用户指定文件 COMPILATION_DATADIR 是 MySQL 的数据文件目录，它是在 mysqld 被编译时以 ./configure 设置指定 (典型的是 /usr/local/mysql/data 二进制安装或 /usr/local/var 以源安装)。

如果不有确定 mysqld 从哪里读取 my.cnf 或 my.ini，可以在第一命令行上详细指定它的目录：mysqld –defaults-file=your_path_to_my_cnf。

InnoDB 的数据文件目录是对 innodb_data_home_dir 与 innodb_data_file_path 的数据文件名或目录联合，如果需要将在它们之间增加一个“/”或“\”。如果关键字innodb_data_home_dir 没有在 my.cnf 中明确指定，它的默认值为“.”，即目录“./”，这意味着 MySQL 的 datadir of MySQL.

一个高级的 my.cnf 示例。假设你有一台 2 GB RAM 和3个 60 GB 硬盘(路径分别为 “/”, “/dr2” 和 “/dr3”)装有 Linux。下面的例子是为了使用 InnoDB 而在 my.cnf 文件中可能所作的一些配置。

注意：InnoDB 不会自己创建文件目录：你必须自己创建它们。使用 Unix 或 MS-DOS mkdir 命令建立相应的数据与日志文件目录。

[mysqld] #在这里加入其它的 MySQL 服务器配置 #… # 如果不使用InnoDB表将一列一行注释去除 # skip-innodb # # 数据文件必须 # 能够容下数据与索引 # 确定有足够的 # 磁盘空间 innodb_data_file_path = /ibdata/ibdata1:2000M;/dr2/ibdata/ibdata2:2000M:autoextend # 设置缓冲池的大小为 # 你的主内存大小的 # 50 - 80 %，但是 # 在 Linux x86 总内存 # 使用必须小于 2 GB set-variable = innodb_buffer_pool_size=1G set-variable = innodb_additional_mem_pool_size=20M innodb_log_group_home_dir = /dr3/iblogs # .._log_arch_dir 必须和 # .._log_group_home_dir一样； # 从 4.0.6开始，可以省略它 innodb_log_arch_dir = /dr3/iblogs set-variable = innodb_log_files_in_group=3 # 设置日志文件的大小约为 # 缓冲池(buffer pool) # 大小的 15 % set-variable = innodb_log_file_size=150M set-variable = innodb_log_buffer_size=8M # 如果丢失最近几个事务影响 # 不大的话可以设置 # .._flush_log_at_trx_commit = 0 innodb_flush_log_at_trx_commit=1 set-variable = innodb_lock_wait_timeout=50 #innodb_flush_method=fdatasync #set-variable = innodb_thread_concurrency=5

注意：我们已在不同的硬盘上放置了两个数据文件， InnoDB 将从数据文件的底部填充表空间。在某些情况下所有的数据被分配到不同的物理硬盘中会提高数据库的性能。将日志文件与数据文件分别放在不同的物理硬盘中对提高性能通常是很有益的。你同样可以使用一个 RAW 磁盘分区( raw disk partitions(raw devices)) 作为数据文件，在一些 Unixe 系统中这将提高 I/O 能力。如何在 my.cnf 中详细指定它们请查看第 12.1 节。

警告：在 Linux x86 上必须小心不能将内存使用设置太高， glibc 会把进程堆增长到线程堆栈之上，这将会使服务器崩溃。下面的接近或超过于 2G 将会很危险：

innodb_buffer_pool_size + key_buffer + max_connections * (sort_buffer + record_buffer) + max_connections * 2 MB

每个线程将使用 2MB(MySQL AB 二进制版本为 256 KB)的堆栈，在最坏的环境下还会使用 sort_buffer + record_buffer 的附加内存。

如何调整其它的 mysqld 服务器参数？查看 MySQL 用户手册可以得到更详细的信息。适合大多数用户的典型参数如下所示：

skip-locking set-variable = max_connections=200 set-variable = record_buffer=1M set-variable = sort_buffer=1M # 设置索引缓冲(key_buffer)大小为 # 你的 RAM 的 5 - 50% ，这主要依赖于 # 系统中 MyISAM 表使用量。 # 但是必须保证索引缓冲(key_buffer)与 InnoDB # 的缓冲池(buffer pool)大小总和 # 小于 RAM 的 80%。 set-variable = key_buffer=…

注意：在 my.cnf 文件中有些参数是为了设置数字的，它们的设置格式为：set-variable = innodb… = 123，而其它(字符串和逻辑型)的采用另一设置格式：innodb_… = … .

各设置参数的含义如下：

innodb_data_home_dir 这是InnoDB表的目录共用设置。如果没有在 my.cnf 进行设置，InnoDB 将使用MySQL的 datadir 目录为缺省目录。如果设定一个空字串,可以在innodb_data_file_path 中设定绝对路径。

innodb_data_file_path 单独指定数据文件的路径与大小。数据文件的完整路径由 innodb_data_home_dir 与这里所设定值的组合。文件大小以 MB 单位指定。因此在文件大小指定后必有“M”。 InnoDB 也支持缩写“G”， 1G = 1024M。从 3.23.44 开始，在那些支持大文件的操作系统上可以设置数据文件大小大于 4 GB。而在另一些操作系统上数据文件必须小于 2 GB。数据文件大小总和至少要达到 10 MB。在 MySQL-3.23 中这个参数必须在 my.cnf 中明确指定。在 MySQL-4.0.2 以及更新版本中则不需如此，系统会默认在 MySQL 的 datadir 目录下创建一个 16 MB 自扩充(auto-extending)的数据文件 ibdata1。你同样可以使用一个原生磁盘分区(RAW raw disk partitions(raw devices)) 作为数据文件，如何在 my.cnf 中详细指定它们请查看第 12.1 节。 innodb_mirrored_log_groups 为了保护数据而设置的日志文件组的拷贝数目，默认设置为 1。在 my.cnf 中以数字格式设置。 innodb_log_group_home_dir InnoDB 日志文件的路径。必须与 innodb_log_arch_dir 设置相同值。如果没有明确指定将默认在 MySQL 的 datadir 目录下建立两个 5 MB 大小的 ib_logfile… 文件。 innodb_log_files_in_group 日志组中的日志文件数目。InnoDB 以环型方式(circular fashion)写入文件。数值 3 被推荐使用。在 my.cnf 中以数字格式设置。 innodb_log_file_size 日志组中的每个日志文件的大小(单位 MB)。如果 n 是日志组中日志文件的数目，那么理想的数值为 1M 至下面设置的缓冲池(buffer pool)大小的 1/n。较大的值，可以减少刷新缓冲池的次数，从而减少磁盘 I/O。但是大的日志文件意味着在崩溃时需要更长的时间来恢复数据。日志文件总和必须小于 2 GB，3.23.55 和 4.0.9 以上为小于 4 GB。在 my.cnf 中以数字格式设置。 innodb_log_buffer_size InnoDB 将日志写入日志磁盘文件前的缓冲大小。理想值为 1M 至 8M。大的日志缓冲允许事务运行时不需要将日志保存入磁盘而只到事务被提交(commit)。因此，如果有大的事务处理，设置大的日志缓冲可以减少磁盘I/O。在 my.cnf 中以数字格式设置。 innodb_flush_log_at_trx_commit 通常设置为 1，意味着在事务提交前日志已被写入磁盘，事务可以运行更长以及服务崩溃后的修复能力。如果你愿意减弱这个安全，或你运行的是比较小的事务处理，可以将它设置为 0 ，以减少写日志文件的磁盘 I/O。这个选项默认设置为 0。 innodb_log_arch_dir The directory where fully written log files would be archived if we used log archiving. 这里设置的参数必须与innodb_log_group_home_dir 相同。从 4.0.6 开始，可以忽略这个参数。 innodb_log_archive 这个值通常设为 0。既然从备份中恢复(recovery)适合于 MySQL 使用它自己的 log files，因而通常不再需要 archive InnoDB log files。这个选项默认设置为 0。 innodb_buffer_pool_size InnoDB 用来高速缓冲数据和索引内存缓冲大小。更大的设置可以使访问数据时减少磁盘 I/O。在一个专用的数据库服务器上可以将它设置为物理内存的 80 %。不要将它设置太大，因为物理内存的使用竞争可能会影响操作系统的页面调用。在 my.cnf 中以数字格式设置。 innodb_additional_mem_pool_size InnoDB 用来存储数据字典(data dictionary)信息和其它内部数据结构(internal data structures)的存储器组合(memory pool)大小。理想的值为 2M，如果有更多的表你就需要在这里重新分配。如果 InnoDB 用尽这个池中的所有内存，它将从操作系统中分配内存，并将错误信息写入 MySQL 的错误日志中。在 my.cnf 中以数字格式设置。 innodb_file_io_threads InnoDB 中的文件 I/O 线程。通常设置为 4，但是在 Windows 下可以设定一个更大的值以提高磁盘 I/O。在 my.cnf 中以数字格式设置。 innodb_lock_wait_timeout 在回滚(rooled back)之前，InnoDB 事务将等待超时的时间(单位秒)。InnoDB 会自动检查自身在锁定表与事务回滚时的事务死锁。如果使用LOCK TABLES 命令，或在同一个事务中使用其它事务安全型表处理器(transaction safe table handlers than InnoDB)，那么可能会发生一个 InnoDB 无法注意到的死锁。在这种情况下超时将用来解决这个问题。这个参数的默认值为 50 秒。在 my.cnf 中以数字格式设置。 innodb_flush_method 这个参数仅仅与 Unix 相关。这个参数默认值为 fdatasync。另一个设置项为 O_DSYNC。这仅仅影响日志文件的转储，在 Unix 下以 fsync 转储数据。InnoDB 版本从 3.23.40b 开始，在 Unix 下指定 fdatasync 为使用 fsync 方式、指定 O_DSYNC 为使用 O_SYNC 方式。由于这在某些 Unix 环境下还有些问题所以在 ‘data’ versions 并没有被使用。 innodb_force_recovery 警告：此参数只能在你希望从一个被损坏的数据库中转储(dump)数据的紧急情况下使用！可能设置的值范围为 1 - 6。查看下面的章节 ‘Forcing recovery’ 以了解这个参数的具体含义。参数设置大于 0 的值代表着 InnoDB 防止用户修改数据的安全度。从 3.23.44 开始，这个参数可用。在my.cnf 中以数字格式设置。 innodb_fast_shutdown InnoDB 缺少在关闭之前清空插入缓冲。这个操作可能需要几分钟，在极端的情况下可以需要几个小时。如果这个参数据设置为 1 ，InnoDB 将跳过这个过程而直接关闭。从 3.23.44 和 4.0.1 开始，此参数可用。从 3.23.50 开始，此参数的默认值为 1。 innodb_thread_concurrency InnoDB 会试图将 InnoDB 服务的使用的操作系统进程小于或等于这里所设定的数值。此参数默认值为 8。如果计算机系统性能较低或innodb_monitor 显示有很多线程等侍信号，应该将这个值设小一点。如果你的计算机系统有很我的处理器与磁盘系统，则可以将这个值设高一点以充分利用你的系统资源。建议设值为处理器数目+ 磁盘数目。从 3.23.44 和 4.0.1 开始，此参数可用。在 my.cnf 中以数字格式设置。

windows C++ 用信号量控制线程

2010-02-01T00:00:00+00:00

很好的控制线程，让线程互斥，互相协调工作，共享数据，这个问题有很多种解决办法，不过我个人觉得使用信号量控制线程特别方便。会想到用多线程控制程序，是由于上学期我们要做一个控制电机转速的课程设计，开始编写的程序都是一个线程控制的。后来课程设计结束了，一次在看多线程的演示程序的时候突然想到，原来的那个电机控制程序完全可以写成多线程，可是由于课程设计结束了，没有硬件供你调试，就自己写了个多线程的练习程序。控制信号量几个主要的函数： Cpp代码

WaitForSingleObject();//等待信号量有效
CreatSemaphore();//申请信号量
OpenSemaphore();//打开信号量
ReleaseSemaphore();//释放信号量

下面来看看控制多线程要用到的东西： Cpp代码

HANDLE ptrSpdUpDown;
HANDLE ptrUpDownDraw;
HANDLE ptrDrawSpd; //申请指向信号量的句柄
ptrSpdUpDown = ::CreateSemaphore(NULL, 0, 1, NULL);
ptrUpDownDraw = ::CreateSemaphore(NULL, 0, 1, NULL);
ptrDrawSpd = ::CreateSemaphore(NULL, 1, 1, NULL);//实例化三个信号量
bOnOff=true;//线程状态控制量 开启三个线程
m_tWriteSpeed=AfxBeginThread(
	WriteSpeed,
	&m_sWriteSpeed,
	THREAD_PRIORITY_NORMAL,
	0,
	CREATE_SUSPENDED);
m_tWriteSpeed->ResumeThread();
m_tWriteUpDown=AfxBeginThread(
	WriteUpDown,
	&m_sWriteUpDown,
	THREAD_PRIORITY_NORMAL,
	0,
	CREATE_SUSPENDED);
m_tWriteUpDown->ResumeThread();
m_tDrawWindow=AfxBeginThread(
	DrawWindow,
	&m_sDrawWindow,
	THREAD_PRIORITY_NORMAL,
	0,
	CREATE_SUSPENDED);
m_tDrawWindow->ResumeThread();
//三个线程函数
UINT WriteSpeed(LPVOID p)
{
	int iNo=1;
	CString sTr;
	CString sMe;
	CEdit *ptr=(CEdit *)p;
	while(bOnOff)
	{
		WaitForSingleObject(ptrDrawSpd,INFINITE);
		ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe+"已经接到信号");
		::Sleep(1000);
		srand((int)time(0));//种种子数
		iSpeed=iUp+iDown+rand();
		ReleaseSemaphore(ptrSpdUpDown,1,NULL);
		sTr.Format("%d",iNo);
		sMe.Format("%d",iSpeed);
		ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe);
		iNo++;
	}
	return 0;
}
UINT WriteUpDown(LPVOID p)
{
	int iNo=1;
	CString sTr;
	CString sMe;
	CEdit *ptr=(CEdit *)p;
	while(bOnOff)
	{
		WaitForSingleObject(ptrSpdUpDown,INFINITE);
		ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe+"已经接到信号");
		::Sleep(1000);
		srand((int)time(0));//种种子数
		iUp=iSpeed-rand();
		iDown=iSpeed+rand();
		ReleaseSemaphore(ptrUpDownDraw,1,NULL);
		sTr.Format("%d",iNo);
		sMe.Format("%d",iUp);
		ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe);
		iNo++;
	}
	return 0;
}
UINT DrawWindow(LPVOID p)
{
	int iNo=1;
	CString sTr;
	CEdit *ptr=(CEdit *)p;
	while(bOnOff)
	{
		WaitForSingleObject(ptrUpDownDraw,INFINITE);
		ptr->SetWindowText("线程DrawWindow正在运行"+sTr+"已经接到信号");
		::Sleep(1000);
		sTr.Format("%d",iNo);
		ptr->SetWindowText("线程DrawWindow正在运行"+sTr);
		iNo++;
		ReleaseSemaphore(ptrDrawSpd,1,NULL);
	}
	return 0;
}

上面的方法是先申请信号量的句柄然后再实例化信号量下面这种方法是直接申请信号量两种方法基本相同 Cpp代码

CSemaphore ptrSpdUpDown(0, 1);
CSemaphore ptrUpDownDraw(0, 1);
CSemaphore ptrDrawSpd(1, 1);//#include <atlsync.h>注意在stdafx.h手动包含这个文件

int main(int argc, char* argv[])
{
	print("hello world!");
	return 0;
}

在各个线程函数中不用WaitForSingleObject了要使用Lock()UnLock(); 下面是使用CSemaphore后在各个线程函数中使用Lock()UnLock()替换掉WaitForSingleObject的结果 Cpp代码

UINT WriteSpeed(LPVOID p)
{
	int iNo=1;
	CString sTr;
	CString sMe;
	CEdit *ptr=(CEdit *)p;
	while(bOnOff)
	{
		<strong>ptrDrawSpd.Lock();</strong> 
		ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe+"已经接到信号");
		::Sleep(1000);
		srand((int)time(0));//种种子数
		iSpeed=iUp+iDown+rand();
		ReleaseSemaphore(ptrSpdUpDown,1,NULL);
		<strong>ptrSpdUpDown.Unlock();</strong>
		sTr.Format("%d",iNo);
		sMe.Format("%d",iSpeed);
		ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe);
		iNo++;
	}
	return 0;
}
UINT WriteUpDown(LPVOID p)
{
	int iNo=1;
	CString sTr;
	CString sMe;
	CEdit *ptr=(CEdit *)p;
	while(bOnOff)
	{
		<strong>ptrSpdUpDown.Lock();</strong>
		ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe+"已经接到信号");
		::Sleep(1000);
		srand((int)time(0));//种种子数
		iUp=iSpeed-rand();
		iDown=iSpeed+rand();
		ReleaseSemaphore(ptrUpDownDraw,1,NULL);
		<strong>ptrUpDownDraw.Unlock();</strong>
		sTr.Format("%d",iNo);
		sMe.Format("%d",iUp);
		ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe);
		iNo++;
	}
	return 0;
}
UINT DrawWindow(LPVOID p)
{
	int iNo=1;
	CString sTr;
	CEdit *ptr=(CEdit *)p;
	while(bOnOff)
	{
		<strong>ptrUpDownDraw.Lock();</strong>
		ptr->SetWindowText("线程DrawWindow正在运行"+sTr+"已经接到信号");
		::Sleep(1000);
		sTr.Format("%d",iNo);
		ptr->SetWindowText("线程DrawWindow正在运行"+sTr);
		iNo++;
		ReleaseSemaphore(ptrDrawSpd,1,NULL);
		<strong>ptrDrawSpd.Unlock();</strong>
	}
	return 0;
}

C++内存泄漏检测拾遗

2010-02-01T00:00:00+00:00

时间:2009-10-07 cnblogs 放牛娃在MFC开发环境中，当运行退出了，Visual Studio会在输出窗口提示是否有内存泄漏。也可以借助MFC类CMemoryState动态地检测并输出内存泄漏信息。在非MFC框架中，需要借助CRT函数实现这些功能。

调用_CrtDumpMemoryLeaks（）函数会在输出窗口中输出当前的内存泄漏。若在程序开始处加上：_CrtSetDbgFlag（ _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ）；语句，CRT会在程序的每个出口处自动调用_CrtDumpMemoryLeaks函数，因此程序终止时会在输出窗口显示所有的内存泄漏。 2.利用_CrtMemState结构定点监测内存泄漏，例：

//定义3个内存状态
_CrtMemState s1,s2,s3;
//记录开始的内存状态
_CrtMemCheckpoint( &s1 );
int* p = new int;
//记录结束时的内存状态
_CrtMemCheckpoint( &s2 );
//比较2个内存状态,并将差异保存到s3中
if( _CrtMemDifference( &s3, &s1, &s2 ) )
{
	//输出内存泄漏信息
	_CrtMemDumpAllObjectsSince( &s3 );
}

重定向输出信息。内存泄漏提示默认是输出在输出窗口中，可以通过_CrtSetReportMode重定向其输出位置。例（重定向输出到指定文件）：

CAtlFile hFile;
hFile.Create( _T("D:\\report.txt"), GENERIC_WRITE, FILE_SHARE_WRITE, CREATE_ALWAYS );
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, hFile );

此外还可以重定向为窗体提示（带有”终止”、”继续”、”忽略”按钮的窗体），断言就是输出为此窗体。还可以通过_CrtSetReportHook函数在输出到指定目的地之前拦截消息。如：

_CrtSetReportHook(MyReportingFunction);
//MyReportingFunction的定义如下：
int MyReportingFunction( int nReportType, char *szMsg, int *pRetVal )
{
	*pRetVal = 0;
	if( nReportType == _CRT_WARN )
	{
		AtlMessageBox( NULL, _U_STRINGorID( CA2T(szMsg)));
	}
	return 0;
}

http://www.bianceng.cn/Programming/vc/200910/11576.htm

vs2008哪些工程文件可以删除

2010-01-26T00:00:00+00:00

当签入文件，Visual c + + 将自动提示您签入项目工作区窗格加上项目生成文件 (.mak) 中的所有文件。在大多数的情况下这些只是将需要打开并重新生成 Visual c + + 项目的源文件。

您可以将二进制文件添加到 Visual c + + 项目。它们将显示在项目工作区窗格中，Visual c + + 将尝试将它们添加到源代码管理。鍦ㄦ煇浜涙儏鍐典笅这是理想（对于实例位图）和在其他情况中这是不值得（对于实例导入库）。

下面是（非详尽）的文件扩展名的文件应添加到源代码管理，正常情况下的列表：

.mak, .dsp, .c, .rc, .rc2, .ico, .bmp, .txt, .def, .hpj, .bat, .rtf, .odl, .inf, .reg, .cnt, .cpp, .cxx, .h, .hpp, .hxx, .inl, .tpl, .vtp, and .mst.

重新通常，这些文件不能轻松地生成。没有需要共享源代码控件通过生成文件时要考虑的问题。在 Visual c + + 联机文档中讨论了这些问题。请参见下面的参考部分。

下面是（非详尽）的文件扩展名的文件不应该添加到源代码管理，正常情况下的列表：

.pch, .mdp, .ncb, .clw, .obj, .exe, .aps, .cpl, .awk, .exp, .lib, .idb, .opt, .pdb, .map, .res, .ilk, .scc, .bsc, .sbr, .dll, and .tlb.

通常，这些文件自动重新生成由 Visual c + + 中打开、编辑，和生成项目。

def dll

2010-01-21T00:00:00+00:00

VS20XX使用DEF文件来生成DLL与Lib http://blog.csdn.net/xiaojianpitt/archive/2009/12/03/4934295.aspx

VS中def文件对于生成dll和lib文件的作用 http://blog.csdn.net/caomiao2006/archive/2009/11/06/4777532.aspx

用vc创建动态连接库时，如何生成.def文件？ http://topic.csdn.net/t/20040618/14/3103849.html

DEF文件格式 http://andylin02.javaeye.com/blog/441300

extern “C”的用法 http://dev.csdn.net/article/66/66384.shtm http://blog.chinaunix.net/u3/96097/showart.php?id=2048024 http://blog.csdn.net/citysheep/archive/2009/02/22/3923073.aspx

DOCTYPE 切換運作的方式

2010-01-11T00:00:00+00:00

若有完整 URI 的 XHTML DOCTYPE，則切到標準模式，用 W3C 規則來讀網頁裡的 CSS 與 XHTML。若有不完整或過時的 DOCTYPE 或沒有 DOCTYPE，就切成相容模式，用傳統方法來處理網頁。完整的長得像這樣，會讓瀏覽器切到標準模式:

<!DOCTYPE html PUBLIC “-/W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”> 這是 XHTML 1.0 Strict DOCTYPE，還有 Transitional 跟 Frameset DOCTYPE。

不完整的像這樣，會切到相容模式:

<!DOCTYPE html PUBLIC “-/W3C//DTD XHTML 1.0 Strict//EN” “/DTD/xhtml1-strict.dtd”> 兩者差異只在於前者用絕對路徑，後者用相對路徑。當然，這是個正確的網址，你可以連去下載到該份 DTD，可是瀏覽器看到它時，不會真的去下載這 DTD，它只是用來判斷要切換成哪種模式罷了。 (另，IE 並不守規矩，網頁中只要出現 XHTML DOCTYPE，不論是否是完整網址，IE 都會切成標準模式。但為了其他瀏覽器，建議還是用完整路徑) (但，就算有完整路徑，只要網頁開頭有

這東東，稱為 XML Prolog，IE6就會切成相容模式 =.=)

以下列出各 DTD。

XHTML 1.0 Strict 可讓所有支援 DOCTYPE 的瀏覽器切成標準模式，但是對 Opera 7.0 之前的版本，或 IE6 之前的版本無效。

<!DOCTYPE html PUBLIC “-/W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”> XHTML 1.0 Transitional 讓 IE6+/Win 及 IE5+/Mac 切成標準模式。使第一代 Gecko 瀏覽器(Mozilla 1.0，Netscape 6)切成標準模式。使第二代 Gecko 瀏覽器(Mozilla 1.01，Netscape7+，Chimera 0.6+)切成近乎標準模式。對 Opera 7.0 之前的版本，或 IE6 之前的版本無效。

<!DOCTYPE html PUBLIC “-/W3C//DTD XHTML 1.0 Transtitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”> XHTML 1.0 Frameset 讓 IE6+/Win 及 IE5+/Mac 切成標準模式。使第一代 Gecko 瀏覽器(Mozilla 1.0，Netscape 6)切成標準模式。使第二代 Gecko 瀏覽器(Mozilla 1.01，Netscape7+，Chimera 0.6+)切成近乎標準模式。對 Opera 7.0 之前的版本，或 IE6 之前的版本無效。

<!DOCTYPE html PUBLIC “-/W3C//DTD XHTML 1.0 Frameset//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd”> XHTML 1.1 此規格等同於 Strict，可讓所有支援 DOCTYPE 的瀏覽器切成標準模式，但是對 Opera 7.0 之前的版本，或 IE6 之前的版本無效。

<!DOCTYPE html PUBLIC “-/W3C//DTD XHTML 1.1EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1.dtd”> HTML 4.01 Strict 會讓 IE 切成標準模式，新版的 Gecko 切成近乎標準模式。

<!DOCTYPE html PUBLIC “-/W3C//DTD HTML 4.01//EN” “http://www.w3.org/TR/html4/strict.dtd”> 但若用完整的 HTML 4.0 DOCTYPE，卻會使 IE 跟 Gecko 切成相容模式!

所以講了這麼多，目前的最佳解就是採用 XHTML (Transitional)。

STL中map用法详解

2009-12-30T00:00:00+00:00

作者：不详　来源：互联网

由于STL是一个统一的整体，map的很多用法都和STL中其它的东西结合在一起；map中由于它内部有序，由红黑树保证，因此很多函数执行的时间复杂度都是log2N的，如果用map函数可以实现的功能，而STL Algorithm也可以完成该功能，建议用map自带函数，效率高一些…… Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。下面举例说明什么是一对一的数据映射。比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用map可能轻易描述，很明显学号用int描述，姓名用字符串描述(本篇文章中不用char *来描述字符串，而是采用STL中string来描述),下面给出map描述代码：

map<int, string> mapStudent;

map的构造函数

map共提供了6个构造函数，这块涉及到内存分配器这些东西，略过不表，在下面我们将接触到一些map的构造方法，这里要说下的就是，我们通常用如下方法构造一个map：

map<int, string> mapStudent;

数据的插入

在构造map容器后，我们就可以往里面插入数据了。这里讲三种插入数据的方法：

第一种：用insert函数插入pair数据，下面举例说明(以下代码虽然是随手写的，应该可以在VC和GCC下编译通过，大家可以运行下看什么效果，在VC下请加入这条语句，屏蔽4786警告＃pragma warning (disable:4786) )

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent.insert(pair<int, string>(1, "student_one"));
	mapStudent.insert(pair<int, string>(2, "student_two"));
	mapStudent.insert(pair<int, string>(3, "student_three"));
	map<int, string>::iterator  iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
		cout<<iter->first<<"   "<<iter->second<<end;
	}
}

第二种：用insert函数插入value_type数据，下面举例说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent.insert(map<int, string>::value_type (1, "student_one"));
	mapStudent.insert(map<int, string>::value_type (2, "student_two"));
	mapStudent.insert(map<int, string>::value_type (3, "student_three"));
	map<int, string>::iterator  iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	cout<<iter->first<<"   "<<iter->second<<end;
	}
}

第三种：用数组方式插入数据，下面举例说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent[1] =  "student_one";
	mapStudent[2] =  "student_two";
	mapStudent[3] =  "student_three";
	map<int, string>::iterator  iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	cout<<iter->first<<"   "<<iter->second<<end;
	}
}

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值，用程序说明

mapStudent.insert(map<int, string>::value_type (1, "student_one"));
mapStudent.insert(map<int, string>::value_type (1, "student_two"));

上面这两条语句执行后，map中1这个关键字对应的值是”student_one”，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入成功的问题了，可以用pair来获得是否插入成功，程序如下

pair<map<int, string>::iterator, bool> Insert_Pair;
insert_Pair = mapStudent.insert(map<int, string>::value_type (1, "student_one"));

我们通过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，如果插入成功的话Insert_Pair.second应该是true的，否则为false。

下面给出完成代码，演示插入成功与否问题

#include <map>
#include <string>
#include <iostream>
using namespace std;
Int main()
{
	map<int, string> mapStudent;
	pair<map<int, string>::iterator, bool> Insert_Pair;
	insert_Pair ＝ mapStudent.insert(pair<int, string>(1, "student_one"));
	if(Insert_Pair.second == true)
	{
		cout<<"Insert Successfully"<<endl;
	}
	else
	{
		cout<<"Insert Failure"<<endl;
	}
	insert_Pair ＝ mapStudent.insert(pair<int, string>(1, "student_two"));
	if(Insert_Pair.second == true)
	{
		cout<<"Insert Successfully"<<endl;
	}
	else
	{
		cout<<"Insert Failure"<<endl;
	}
	map<int, string>::iterator  iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
		cout<<iter->first<<"   "<<iter->second<<end;
	}
}

大家可以用如下程序，看下用数组插入在数据覆盖上的效果

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent[1] =  "student_one";
	mapStudent[1] =  "student_two";
	mapStudent[2] =  "student_three";
	map<int, string>::iterator  iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
		cout<<iter->first<<"   "<<iter->second<<end;
	}
}

map的大小

在往map里面插入了数据，我们怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：

int nSize = mapStudent.size();

数据的遍历

这里也提供三种方法，对map进行遍历

第一种：应用前向迭代器，上面举例程序中到处都是了，略过不表

第二种：应用反相迭代器，下面举例说明，要体会效果，请自个动手运行程序

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent.insert(pair<int, string>(1, "student_one"));
	mapStudent.insert(pair<int, string>(2, "student_two"));
	mapStudent.insert(pair<int, string>(3, "student_three"));
	map<int, string>::reverse_iterator  iter;
	for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)
	{
		cout<<iter->first<<"   "<<iter->second<<end;
	}
}

第三种：用数组方式，程序说明如下

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent.insert(pair<int, string>(1, "student_one"));
	mapStudent.insert(pair<int, string>(2, "student_two"));
	mapStudent.insert(pair<int, string>(3, "student_three"));
	int nSize = mapStudent.size()
	//此处有误，应该是 for(int nIndex = 1; nIndex <= nSize; nIndex++)
	//by rainfish
	for(int nIndex = 0; nIndex < nSize; nIndex++)
	{
		cout<<mapStudent[nIndex]<<end;
	}
}

数据的查找（包括判定这个关键字是否在map中出现）

在这里我们将体会，map在数据插入时保证有序的好处。

要判定一个数据（关键字）是否在map中出现的方法比较多，这里标题虽然是数据的查找，在这里将穿插着大量的map基本用法。

这里给出三种数据查找方法

第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了

第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器，程序说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent.insert(pair<int, string>(1, "student_one"));
	mapStudent.insert(pair<int, string>(2, "student_two"));
	mapStudent.insert(pair<int, string>(3, "student_three"));
	map<int, string>::iterator iter;
	iter = mapStudent.find(1);
	if(iter != mapStudent.end())
	{
		cout<<"Find, the value is "<<iter->second<<endl;
	}
	else
	{
		cout<<"Do not Find"<<endl;
	}
}

第三种：这个方法用来判定数据是否出现，是显得笨了点，但是，我打算在这里讲解

Lower_bound函数用法，这个函数用来返回要查找关键字的下界(是一个迭代器)

Upper_bound函数用法，这个函数用来返回要查找关键字的上界(是一个迭代器)

例如：map中已经插入了1，2，3，4的话，如果lower_bound(2)的话，返回的2，而upper-bound（2）的话，返回的就是3

Equal_range函数返回一个pair，pair里面第一个变量是Lower_bound返回的迭代器，pair里面第二个迭代器是Upper_bound返回的迭代器，如果这两个迭代器相等的话，则说明map中不出现这个关键字，程序说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent[1] =  "student_one";
	mapStudent[3] =  "student_three";
	mapStudent[5] =  "student_five";
	map<int, string>::iterator  iter;
	iter = mapStudent.lower_bound(2);
	{
		//返回的是下界3的迭代器
		cout<<iter->second<<endl;
	}
	iter = mapStudent.lower_bound(3);
	{
		//返回的是下界3的迭代器
		cout<<iter->second<<endl;
	}
	iter = mapStudent.upper_bound(2);
	{
		//返回的是上界3的迭代器
		cout<<iter->second<<endl;
	}
	iter = mapStudent.upper_bound(3);
	{
		//返回的是上界5的迭代器
		cout<<iter->second<<endl;
	}
	pair<map<int, string>::iterator, map<int, string>::iterator> mapPair;
	mapPair = mapStudent.equal_range(2);
	if(mapPair.first == mapPair.second)
	{
		cout<<"Do not Find"<<endl;
	}
	else
	{
		cout<<"Find"<<endl;
	}
	mapPair = mapStudent.equal_range(3);
	if(mapPair.first == mapPair.second)
	{
		cout<<"Do not Find"<<endl;
	}
	else
	{
		Cout<<"Find"<<endl;
	}
}

数据的清空与判空

清空map中的数据可以用clear()函数，判定map中是否有数据可以用empty()函数，它返回true则说明是空map

数据的删除

这里要用到erase函数，它有三个重载了的函数，下面在例子中详细说明它们的用法

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
	map<int, string> mapStudent;
	mapStudent.insert(pair<int, string>(1, "student_one"));
	mapStudent.insert(pair<int, string>(2, "student_two"));
	mapStudent.insert(pair<int, string>(3, "student_three"));
	//如果你要演示输出效果，请选择以下的一种，你看到的效果会比较好
	//如果要删除1,用迭代器删除
	map<int, string>::iterator iter;
	iter = mapStudent.find(1);
	mapStudent.erase(iter);
	//如果要删除1，用关键字删除
	int n = mapStudent.erase(1);//如果删除了会返回1，否则返回0
	//用迭代器，成片的删除
	//一下代码把整个map清空
	mapStudent.earse(mapStudent.begin(), mapStudent.end());
	//成片删除要注意的是，也是STL的特性，删除区间是一个前闭后开的集合
	//自个加上遍历代码，打印输出吧
}

其他一些函数用法

这里有swap,key_comp,value_comp,get_allocator等函数，感觉到这些函数在编程用的不是很多，略过不表，有兴趣的话可以自个研究

排序

这里要讲的是一点比较高深的用法了,排序问题，STL中默认是采用小于号来排序的，以上代码在排序上是不存在任何问题的，因为上面的关键字是int型，它本身支持小于号运算，在一些特殊情况，比如关键字是一个结构体，涉及到排序就会出现问题，因为它没有小于号操作，insert等函数在编译的时候过不去，下面给出两个方法解决这个问题

第一种：小于号重载，程序举例

#include <map>
#include <string>
using namespace std;
typedef struct tagStudentInfo
{
	int      nID;
	string   strName;
}StudentInfo, *PStudentInfo;  //学生信息
int main()
{
	int nSize;
	//用学生信息映射分数
	map<StudentInfo, int>mapStudent;
	map<StudentInfo, int>::iterator iter;
	StudentInfo studentInfo;
	studentInfo.nID = 1;
	studentInfo.strName = "student_one";
	mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
	studentInfo.nID = 2;
	studentInfo.strName = "student_two";
	mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
	for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)
	cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;
}

以上程序是无法编译通过的，只要重载小于号，就OK了，如下：

typedef struct tagStudentInfo
{
	int      nID;
	string   strName;
	bool operator < (tagStudentInfo const& _A) const
	{
		//这个函数指定排序策略，按nID排序，如果nID相等的话，按strName排序
		if(nID < _A.nID)  return true;
		if(nID == _A.nID) return strName.compare(_A.strName) < 0;
		return false;
	}
}StudentInfo, *PStudentInfo;  //学生信息

第二种：仿函数的应用，这个时候结构体中没有直接的小于号重载，程序说明

#include <map>
#include <string>
using namespace std;
typedef struct tagStudentInfo
{
	int      nID;
	string   strName;
}StudentInfo, *PStudentInfo;  //学生信息
classs sort
{
	public:
	bool operator() (StudentInfo const &_A, StudentInfo const &_B) const
	{
		If(_A.nID < _B.nID) return true;
		If(_A.nID == _B.nID) return _A.strName.compare(_B.strName) < 0;
		Return false;
	}
};
int main()
{
	//用学生信息映射分数
	map<StudentInfo, int, sort>mapStudent;
	StudentInfo studentInfo;
	studentInfo.nID = 1;
	studentInfo.strName = "student_one";
	mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));
	studentInfo.nID = 2;
	studentInfo.strName = "student_two";
	mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));
}

另外

由于STL是一个统一的整体，map的很多用法都和STL中其它的东西结合在一起，比如在排序上，这里默认用的是小于号，即less<>，如果要从大到小排序呢，这里涉及到的东西很多，在此无法一一加以说明。

还要说明的是，map中由于它内部有序，由红黑树保证，因此很多函数执行的时间复杂度都是log2N的，如果用map函数可以实现的功能，而STL Algorithm也可以完成该功能，建议用map自带函数，效率高一些。

下面说下，map在空间上的特性，否则，估计你用起来会有时候表现的比较郁闷，由于map的每个数据对应红黑树上的一个节点，这个节点在不保存你的数据时，是占用16个字节的，一个父节点指针，左右孩子指针，还有一个枚举值（标示红黑的，相当于平衡二叉树中的平衡因子），我想大家应该知道，这些地方很费内存了吧，不说了……

水草

mac osx 使用goagent，在chrome下访问google，不是私密连接的问题

解决办法

奇怪的梦-2

梦见洪水

博客主题做成了主题包，可以直接pull下来

lala~~~

test title

test title

灯泡广告…

FlashPlayer不弹出错误信息的问题

在Unity3D的网络游戏中实现资源动态加载

Liquid Extensions

3个服务端(游戏)

使用typeid和RTTI C++获取对象运行时类名称【转】

用GDB调试程序[转]

GDB调试精粹及使用实例

gdb 使用范例

咕噜咕噜

趣谈教主毁灭星际 GOMTV WCG直到今日FOX

水友制作——最终兵器Flash的Highlight

WeMadeFOX全队解散：星际被托管 魔兽成历史

inline函数链接报错：LNK2019

补间动画不播放的问题

星际经典回顾

人族皇帝SlayerS_BoxeR Highlight

英雄神族Reach Highlight

死神Anytime Highlight

野兽iloveoov Highlight

梦想家Nal_ra Highlight

完美人族Xellos Highlight

马本座Savior HIghlight

教主Flash

垃圾游戏特征及其诞生原因推测

神经病人思维广，弱智儿童欢乐多

宅若久时天然呆，呆到深处自然萌

ABC MART MSL4强 第二日

最近的星际

暗黑3全新符文之石系统及炫丽技能效果展示

信吗？笑吧《暗黑破坏神3》中国随全球同步发售

最近的一些事

[PSN]索尼平井一夫：PSN网络将在5月完全恢复

魂斗罗组曲by zeta

水树奈奈对 手冢治虫 的《仏陀》见解

仙剑5的场景设计

softstar，大宇

以下是来自迅游网的一些信息。

动视暴雪Q1财务表现强劲

搜寻地外文明

人工神经网络

消息

Concerto Gate (魔力2)人物加点计算器

思考的问题

拉登死亡

Flash 三神器

Public-key cryptography

东方动画《幻想万华镜》新动画+OP+ED

东方系列一直是我喜欢的游戏

The scripture of NineSuns

《暗黑破坏神3》即将出在PS3或XBOX

暴雪又要玩家用机了？

我就喜欢不着边际的事情

昨天看了一篇关于暴雪总部探访的报道

好吧，从新开始。

//(◕‿‿◕)要相信你的cpu

奇怪的梦-1

今天做了一个脱狱的梦，很刺激，像电影。记录下来

test

Title

内容

奇怪的梦-0

喵哈哈

RTTI、虚函数和虚基类的开销分析及使用指导

C/C++ 字符串处理函数

C++的营养RAII

Windows 平台上长路径名文件的解决方法

c++文件读写总结

C/C++ 文件读写操作总结

常量 值 说明

C中的Variable length arrays (变长数组)

WeMadeFOX全队解散：星际被托管魔兽成历史

ABC MART MSL4强第二日

水树奈奈对手冢治虫的《仏陀》见解

常量值说明