..::一步一个坚定的脚印::..

发布新日志

  • 一些SDK和C++程序设计的网址

    2008-05-26 21:17:56

    查看(24) 评论(0) 收藏 分享 管理

  • 覆盖和重载的区别

    2008-05-25 18:48:52

    重载是让同名的方法根据不同的数据类型可以处理和返回不同类型的数据。而覆盖则与作用域有关了，在子类中与父类同名的方法，在子类中父类的方法就不能被调用，可以说被屏蔽了。
    重载是让同一方法名的方法可以处理和返回不同类型的数据,而覆盖是在子类中改写父类的方法
    重载与覆盖的区别
    1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
    2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
    3、覆盖要求参数列表相同；重载要求参数列表不同。
    4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。
    相同点:被覆盖(重载)的函数的函数名必须是一样的;
    不同点:覆盖的函数的函数参数表必须和被覆盖的函数的参数表一样,重载的函数的函数参数表必须和被重载的函数的参数表不一样.
        要值得提到的是,C和C++对函数的解析,C一般都把函数名解析成类似__FUNCTION__,而C++却是要加一个参数表的,类似于:__FUNCTION_VAR__,这就是C++实现多态的机制.
        extern "C" 的作用就是把C语言的函数名解析成C++的函数名,否则C++编译器是识别不了这些符号的.
    以上几条都是从百度知道搜索得到。
    重载与覆盖的区别
    经常看到C++的一些初学者对于重载、覆盖、多态与函数隐藏的模糊理解。在这里写一点自己的见解，希望能够C++初学者解惑。
     
    要弄清楚重载、覆盖、多态与函数隐藏之间的复杂且微妙关系之前，我们首先要来回顾一下重载覆盖等基本概念。
     
    ⑴首先，我们来看一个非常简单的例子，理解一下什么叫函数隐藏hide。
    #include <iostream>
    using namespace std;
     
    class Base
    {
    public:
        void fun() { cout << "Base::fun()" << endl; }
    };
     
    class Derive : public Base
    {
    public:
        void fun(int i) { cout << "Derive::fun()" << endl; }
    };
     
    int main()
    {
        Derive d;
           //下面一句错误，故屏蔽掉
        //d.fun();error C2660: ''''fun'''' : function does not take 0 parameters
        d.fun(1);
     
           Derive *pd =new Derive();
           //下面一句错误，故屏蔽掉
           //pd->fun();error C2660: ''''fun'''' : function does not take 0 parameters
           pd->fun(1);
           delete pd;
     
        return 0;
    }
    /*在不同的非命名空间作用域里的函数不构成重载,子类和父类是不同的两个作用域。
    在本例中,两个函数在不同作用域中,故不够成重载,除非这个作用域是命名空间作用域。*/
     
    在这个例子中，函数不是重载overload，也不是覆盖override，而是隐藏hide。
     
    接下来的5个例子具体说明一下什么叫隐藏
    例1
    #include <iostream>
    using namespace std;
     
    class Basic
    {
    public:
           void fun(){cout << "Base::fun()" << endl;}//overload
           void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
    };
     
    class Derive :public Basic
    {
    public:
           void fun2(){cout << "Derive::fun2()" << endl;}
    };
     
    int main()
    {
           Derive d;
           d.fun();//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。
           d.fun(1);//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。
           return 0;
    }
     
    例2
    #include <iostream>
    using namespace std;
     
    class Basic{
    public:
           void fun(){cout << "Base::fun()" << endl;}//overload
           void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
    };
     
    class Derive :public Basic{
    public:
           //新的函数版本,基类所有的重载版本都被屏蔽,在这里,我们称之为函数隐藏hide
        //派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。
           void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}
           void fun2(){cout << "Derive::fun2()" << endl;}
    };
     
    int main()
    {
           Derive d;
           d.fun(1,2);
           //下面一句错误，故屏蔽掉
           //d.fun();error C2660: ''''fun'''' : function does not take 0 parameters
           return 0;
    }
    例3
    #include <iostream>
    using namespace std;
     
    class Basic{
    public:
           void fun(){cout << "Base::fun()" << endl;}//overload
           void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
    };
     
    class Derive :public Basic{
    public:
           //覆盖override基类的其中一个函数版本,同样基类所有的重载版本都被隐藏hide
        //派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。
           void fun(){cout << "Derive::fun()" << endl;}
           void fun2(){cout << "Derive::fun2()" << endl;}
    };
     
    int main()
    {
           Derive d;
           d.fun();
           //下面一句错误，故屏蔽掉
           //d.fun(1);error C2660: ''''fun'''' : function does not take 1 parameters
           return 0;
    }
    例4
    #include <iostream>
    using namespace std;
     
    class Basic{
    public:
           void fun(){cout << "Base::fun()" << endl;}//overload
           void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
    };
     
    class Derive :public Basic{
    public:
           using Basic::fun;
           void fun(){cout << "Derive::fun()" << endl;}
           void fun2(){cout << "Derive::fun2()" << endl;}
    };
     
    int main()
    {
           Derive d;
           d.fun();//正确
           d.fun(1);//正确
           return 0;
    }
    /*
    输出结果
     
    Derive::fun()
    Base::fun(int i)
    Press any key to continue
    */
    例5
    #include <iostream>
    using namespace std;
     
    class Basic{
    public:
           void fun(){cout << "Base::fun()" << endl;}//overload
           void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
    };
    class Derive :public Basic{
    public:
           using Basic::fun;
           void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}
           void fun2(){cout << "Derive::fun2()" << endl;}
    };
    int main()
    {
           Derive d;
           d.fun();//正确
           d.fun(1);//正确
           d.fun(1,2);//正确
           return 0;
    }
    /*
    输出结果
    Base::fun()
    Base::fun(int i)
    Derive::fun(int i,int j)
    Press any key to continue
    如果基类有某个函数的多个重载(overload)版本，而你在派生类中重写(override)了基类中的一个或多个函数版本，或是在派生类中重新添加了新的函数版本(函数名相同，参数不同)，则所有基类的重载版本都被屏蔽，在这里我们称之为隐藏hide。所以，在一般情况下，你想在派生类中使用新的函数版本又想使用基类的函数版本时，你应该在派生类中重写基类中的所有重载版本。你若是不想重写基类的重载的函数版本，则你应该使用例4或例5方式，显式声明基类名字空间作用域。
     
    事实上，C++编译器认为，相同函数名不同参数的函数之间根本没有什么关系，它们根本就是两个毫不相关的函数。只是C++语言为了模拟现实世界，为了让程序员更直观的思维处理现实世界中的问题，才引入了重载和覆盖的概念。重载是在相同名字空间作用域下，而覆盖则是在不同的名字空间作用域下，比如基类和派生类即为两个不同的名字空间作用域。在继承过程中，若发生派生类与基类函数同名问题时，便会发生基类函数的隐藏。当然，这里讨论的情况是基类函数前面没有virtual 关键字。在有virtual 关键字关键字时的情形我们另做讨论。
     
    继承类重写了基类的某一函数版本，以产生自己功能的接口。此时C++编绎器认为，你现在既然要使用派生类的自己重新改写的接口，那我基类的接口就不提供给你了(当然你可以用显式声明名字空间作用域的方法，见[C++基础]重载、覆盖、多态与函数隐藏(1))。而不会理会你基类的接口是有重载特性的。若是你要在派生类里继续保持重载的特性，那你就自己再给出接口重载的特性吧。所以在派生类里，只要函数名一样，基类的函数版本就会被无情地屏蔽。在编绎器中，屏蔽是通过名字空间作用域实现的。
     
    所以，在派生类中要保持基类的函数重载版本，就应该重写所有基类的重载版本。重载只在当前类中有效，继承会失去函数重载的特性。也就是说，要把基类的重载函数放在继承的派生类里，就必须重写。
     
    这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，具体规则我们也来做一小结：
    ①       如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类无virtual关键字，基类的函数将被隐藏。(注意别与重载混淆，虽然函数名相同参数不同应称之为重载，但这里不能理解为重载，因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏)
    ②  如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类有virtual关键字，基类的函数将被隐式继承到派生类的vtable中。此时派生类vtable中的函数指向基类版本的函数地址。同时这个新的函数版本添加到派生类中，作为派生类的重载版本。但在基类指针实现多态调用函数方法时，这个新的派生类函数版本将会被隐藏。
    ③          如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。(注意别与覆盖混淆，这里理解为隐藏)。
    ④          如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数有virtual关键字。此时，基类的函数不会被“隐藏”。(在这里，你要理解为覆盖哦^_^)。
     
    插曲：基类函数前没有virtual关键字时，我们要重写更为顺口些，在有virtual关键字时，我们叫覆盖更为合理些，戒此，我也希望大家能够更好的理解C++中一些微妙的东西。费话少说，我们举例说明吧。
     
    例6
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
           virtual void fun() { cout << "Base::fun()" << endl; }//overload
        virtual void fun(int i) { cout << "Base::fun(int i)" << endl; }//overload
    };
     
    class Derive : public Base{
    public:
           void fun() { cout << "Derive::fun()" << endl; }//override
        void fun(int i) { cout << "Derive::fun(int i)" << endl; }//override
           void fun(int i,int j){ cout<< "Derive::fun(int i,int j)" <<endl;}//overload
    };
     
    int main()
    {
     Base *pb = new Derive();
     pb->fun();
     pb->fun(1);
     //下面一句错误，故屏蔽掉
     //pb->fun(1,2);virtual函数不能进行overload,error C2661: 'fun' : no overloaded function takes 2 parameters
     
     cout << endl;
     Derive *pd = new Derive();
     pd->fun();
     pd->fun(1);
     pd->fun(1,2);//overload
     
     delete pb;
     delete pd;
     return 0;
    }
    /*
    输出结果
     
    Derive::fun()
    Derive::fun(int i)
     
    Derive::fun()
    Derive::fun(int i)
    Derive::fun(int i,int j)
    Press any key to continue
    */
     
    例7-1
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
           virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
    };
     
    class Derive : public Base
    {
    };
     
    int main()
    {
           Base *pb = new Derive();
           pb->fun(1);//Base::fun(int i)
           delete pb;
           return 0;
    }
    例7-2
     
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
             virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
    };
     
    class Derive : public Base{
    public:
        void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }
    };
     
    int main()
    {
             Base *pb = new Derive();
             pb->fun(1);//Base::fun(int i)
                  pb->fun((double)0.01);//Base::fun(int i)
             delete pb;
             return 0;
    }
    例8-1
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
           virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
    };
     
    class Derive : public Base{
    public:
           void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }
    };
     
    int main()
    {
           Base *pb = new Derive();
           pb->fun(1);//Derive::fun(int i)
           delete pb;
           return 0;
    }
    例8-2
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
             virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
    };
     
    class Derive : public Base{
    public:
           void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }
             void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }       
    };
     
    int main()
    {
             Base *pb = new Derive();
             pb->fun(1);//Derive::fun(int i)
                  pb->fun((double)0.01);//Derive::fun(int i)
             delete pb;
             return 0;
    }
     
    例9
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
             virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
     
    };
    class Derive : public Base{
    public:
            void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }
                  void fun(char c){ cout <<"Derive::fun(char c)"<< endl; } 
                  void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }  
    };
    int main()
    {
             Base *pb = new Derive();
             pb->fun(1);//Derive::fun(int i)
                  pb->fun('a');//Derive::fun(int i)
                  pb->fun((double)0.01);//Derive::fun(int i)
     
                  Derive *pd =new Derive();
             pd->fun(1);//Derive::fun(int i)
             //overload
                  pd->fun('a');//Derive::fun(char c)        
             //overload
                  pd->fun(0.01);//Derive::fun(double d)        
     
             delete pb;
                  delete pd;
             return 0;
    }
    例7-1和例8-1很好理解，我把这两个例子放在这里，是让大家作一个比较摆了，也是为了帮助大家更好的理解：
            例7-1中，派生类没有覆盖基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是基类的虚函数地址。
            例8-1中，派生类覆盖了基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是派生类自己的重写的虚函数地址。
    在例7-2和8-2看起来有点怪怪，其实，你按照上面的原则对比一下，答案也是明朗的：
            例7-2中，我们为派生类重载了一个函数版本：void fun(double d) 其实，这只是一个障眼法。我们具体来分析一下，基类共有几个函数，派生类共有几个函数：
    类型
    基类
    派生类
    Vtable部分
    void fun(int i)
    指向基类版的虚函数void fun(int i)
    静态部分
     
    void fun(double d)
     
    我们再来分析一下以下三句代码
    Base *pb = new Derive();
    pb->fun(1);//Base::fun(int i)
    pb->fun((double)0.01);//Base::fun(int i)
     
    这第一句是关键，基类指针指向派生类的对象，我们知道这是多态调用；接下来第二句，运行时基类指针根据运行时对象的类型，发现是派生类对象，所以首先到派生类的vtable中去查找派生类的虚函数版本，发现派生类没有覆盖基类的虚函数，派生类的vtable只是作了一个指向基类虚函数地址的一个指向，所以理所当然地去调用基类版本的虚函数。最后一句，程序运行仍然埋头去找派生类的vtable，发现根本没有这个版本的虚函数，只好回头调用自己的仅有一个虚函数。
     
    这里还值得一提的是：如果此时基类有多个虚函数，此时程序编绎时会提示”调用不明确”。示例如下
    #include <iostream>
    using namespace std;
     
    class Base{
    public:
             virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
                   virtual void fun(char c){ cout <<"Base::fun(char c)"<< endl; }
    };
     
    class Derive : public Base{
    public:
        void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } 
    };
     
    int main()
    {
             Base *pb = new Derive();
                   pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function
             delete pb;
             return 0;
    }
    好了，我们再来分析一下例8-2。
    n          例8-2中，我们也为派生类重载了一个函数版本：void fun(double d) ，同时覆盖了基类的虚函数，我们再来具体来分析一下，基类共有几个函数，派生类共有几个函数：
    类型
    基类
    派生类
    Vtable部分
    void fun(int i)
    void fun(int i)
    静态部分
     
    void fun(double d)
     
    从表中我们可以看到，派生类的vtable中函数指针指向的是自己的重写的虚函数地址。
     
    我们再来分析一下以下三句代码
     
    Base *pb = new Derive();
    pb->fun(1);//Derive::fun(int i)
    pb->fun((double)0.01);//Derive::fun(int i)
     
    第一句不必多说了，第二句，理所当然调用派生类的虚函数版本，第三句，嘿，感觉又怪怪的，其实呀，C++程序很笨的了，在运行时，埋头闯进派生类的vtable表中（虚函数表virtual function table），只眼一看，靠，竞然没有想要的版本，真是想不通，基类指针为什么不四处转转再找找呢?呵呵，原来是眼力有限，基类年纪这么老了，想必肯定是老花了，它那双眼睛看得到的仅是自己的非Vtable部分(即静态部分)和自己要管理的Vtable部分，派生类的void fun(double d)那么远，看不到呀!再说了，派生类什么都要管，难道派生类没有自己的一点权力吗?哎，不吵了，各自管自己的吧^_^
     
    唉!你是不是要叹气了，基类指针能进行多态调用，但是始终不能进行派生类的重载调用啊(参考例6)~~~
    再来看看例9，本例的效果同例6，异曲同工
    小结：
     
            重载overload是根据函数的参数列表来选择要调用的函数版本，而覆盖是根据运行时对象的实际类型来选择要调用的虚virtual函数版本，覆盖的实现是通过派生类对基类的虚virtual函数进行覆盖override来实现的，若派生类没有对基类的虚virtual函数进行覆盖override的话，则派生类会自动继承基类的虚virtual函数版本，此时无论基类指针指向的对象是基类型还是派生类型，都会调用基类版本的虚virtual函数；如果派生类对基类的虚virtual函数进行覆盖override的话，则会在运行时根据对象的实际类型来选择要调用的虚virtual函数版本，例如基类指针指向的对象类型为派生类型，则会调用派生类的虚virtual函数版本，从而实现多态。
     
            使用多态的本意是要我们在基类中声明函数为virtual，并且是要在派生类中覆盖override基类的虚virtual函 数版本，注意，此时的函数原型与基类保持一致，即同名同参数类型；如果你在派生类中新添加函数版本，你不能通过基类指针动态调用派生类的新的函数版本，这 个新的函数版本只作为派生类的一个重载版本。还是同一句话，重载只有在当前类中有效，不管你是在基类重载的，还是在派生类中重载的，两者互不牵连。如果明 白这一点的话，在例6、例9中，我们也会对其的输出结果顺利地理解。
     
            重载是静态联编的，覆盖是动态联编的。进一步解释，重载与指针实际指向的对象类型无关，覆盖与指针实际指向的对象类型相关。若基类的指针调用派生类的重载版本，C++编绎认为是非法的，C++编绎器只认为基类指针只能调用基类的重载版本，重载只在当前类的名字空间作用域内有效，继承会失去重载的特性，当然，若此时的基类指针调用的是一个虚virtual函数，那么它还会进行动态选择基类的虚virtual函数版本还是派生类的虚virtual函数版本来进行具体的操作，这是通过基类指针实际指向的对象类型来做决定的，所以说重载与指针实际指向的对象类型无关，多态与指针实际指向的对象类型相关。 
     
        最后阐明一点，虚virtual函数同样可以进行重载，但是重载只能是在当前自己名字空间作用域内有效(请再次参考例6)。
     
    重载overload的特征：
    ①相同的范围(在同一个类中，名字空间作用域)；
    ②函数名相同参数不同；
    ③virtual 关键字可有可无
    ④根据函数的参数列表来选择要调用的函数版本
    ⑤静态联编
     
    覆盖override是指派生类函数覆盖基类函数，覆盖的特征是：
    ①不同的范围(分别位于派生类与基类)；
    ②函数名和参数都相同；
    ③基类函数必须有virtual 关键字。(若没有virtual 关键字则称之为隐藏hide)
    ④覆盖是根据运行时对象的实际类型来选择要调用的虚virtual函数版本
    ⑤动态联编
    override可 以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是 对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意 以下的几点：
       1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
       2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
       3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
       4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
        overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
       1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int)）；
       2、不能通过访问权限、返回类型、抛出的异常进行重载；
       3、方法的异常类型和数目不会对重载造成影响；
     注:
    虚函数表:编译器处理虚函数的方法是:给每个对象添加一个隐藏成员.隐藏成员中保存了一个指向函数地址数组的指针.这组数组称为Vtbl
    来自：http://blog.csdn.net/christinavivi/archive/2008/02/29/2134782.aspx
    博主也是转的，却没表明出处，很想拜读该文作者的其它文章。

    查看(38) 评论(0) 收藏 分享 管理

  • 匈牙利命名法

    2008-05-25 14:44:28

    匈牙利命名规范

        几年以前,Charles Simonyi(他后来成为微软的著名程序员)设计了一种以前缀为基础的命名方法,这种方法后来称为"匈牙利表示法"以记念他.他的思想是根据每个标识符所代表的含义给它一个前缀.微软后来采用了这个思想,给每个标识符一个前缀以说明它的数据类型.因此,整型变量的前缀是n,长整型变量是nl,字符型数组变量是ca,以及字符串(以空类型结尾的字符数组)以sz为前缀.这些名字可能会非常古怪.比如说:lpszFoo表示"Foo"是一个指向以空字符为结尾的字符串的长整型指针.

        这种方法的优点是使人能够通过变量的名字来辨别变量的类型,而不比去查找它的定义.遗憾的是,这种方法不仅使变量名字非常绕口,而且使改变变量类型的工作变得十分艰巨.在Windows3.1中,整型变量为16为宽.如果我们在开始时采用了一个整型变量,但是在通过30---40个函数的计算之后,发现采用整型变量宽度不够,这时我们不仅要改变这个变量的类型,而且要改变这个变量在这30--40个函数中的名字.
               匈牙利命名法是微软推广的一种关于变量、函数、对象、前缀、宏定义等各种类型的符号的命名规范。匈牙利命名法的主要思想是：在变量和函数名中加入前缀以增进人们对程序的理解。它是由微软内部的一个匈牙利人发起使用的，结果它在微软内部逐渐流行起来，并且推广给了全世界的Windows开发人员。下面将介绍匈牙利命名法，后面的例子里也会尽量遵守它和上面的代码风格。还是那句话，并不是要求所有的读者都要去遵守，但是希望读者作为一个现代的软件开发人员都去遵守它。

      a       Array                                 数组

      b       BOOL (int)                            布尔(整数)

      by      Unsigned Char (Byte)                  无符号字符(字节)

      c       Char                                  字符(字节)

      cb      Count of bytes                        字节数

      cr      Color reference value                 颜色(参考)值

      cx      Count of x (Short)                    x的集合(短整数)

      dw      DWORD   (unsigned long)                 双字(无符号长整数)

      f       Flags   (usually multiple bit values)   标志(一般是有多位的数值)

      fn      Function                              函数

      g_      global                                全局的

      h       Handle                                句柄

      i       Integer                               整数

      l       Long                                  长整数

      lp      Long pointer                          长指针

      m_      Data member of a class                一个类的数据成员

      n       Short int                             短整数

      p       Pointer                               指针

      s       String                                字符串

      sz      Zero terminated String                以0结尾的字符串

      tm      Text metric                           文本规则

      u       Unsigned int                          无符号整数

      ul      Unsigned long (ULONG)                 无符号长整数

      w       WORD (unsigned short)                 无符号短整数

      x,y     x, y coordinates (short)              坐标值/短整数

      v       void                                  空

    有关项目的全局变量用g_开始，类成员变量用m_，局部变量若函数较大则可考虑用l_用以显示说明其是局部变量。

     前缀       类型                 例子

    g_      全局变量           g_Servers

    C       类或者结构体       CDocument，CPrintInfo

    m_      成员变量           m_pDoc，m_nCustomers


    VC常用前缀列表：

    前缀类型描述例子
    chchar8位字符chGrade
    chTCHAR16位Unicode集字符chName
    bBOOL布尔变量bEnable
    nint整型nLength
    nUINT无符整型nLength
    wWORD16位无符号整型wPos
    lLong32位有符号整型lOffset
    dwDWORD32位无符号整型dwRange
    p*指针变量，内存模块指针（Ambient memory model point)pDoc
    lpFar*长指针lpDoc
    lpszLPSTR32位字符串指针lpszName
    lpszLPCSTR32位常量字符串指针lpszName
    lpszLPCTSTR32位Unicode集常量指针lpszName
    hhandleWindows对象句柄hWnd
    lpfn(*fn)()   回调函数指针 Callback Far pointer to CALLBACK function lpfnAbort

    MFC、句柄、控件及结构的命名规范
    Windows类型样本变量MFC类样本变量
    HWNDhWnd；CWnd*pWnd；
    HDLGhDlg；CDialog*pDlg；
    HDChDC；CDC*pDC；
    HGDIOBJhGdiObj；CGdiObject*pGdiObj；
    HPENhPen；CPen*pPen；
    HBRUSHhBrush；CBrush*pBrush；
    HFONT hFont； CFont*pFont；
    HBITMAP hBitmap；CBitmap*pBitmap；
    HPALETTE hPaltte；CPalette*pPalette；
    HRGN hRgn；CRgn*pRgn；
    HMENU hMenu；CMenu*pMenu；
    HWND hCtl；CState* pState；
    HWND hCtl；CButton*pButton；
    HWND hCtl；CEdit*pEdit；
    HWND hCtl；CListBox*pListBox；
    HWND hCtl；CComboBox*pComboBox；
    HWND hCtl；CScrollBar*pScrollBar；
    HSZ hszStr；CString pStr；
    POINT pt；CPoint pt；
    SIZE size；CSize size；
    RECT rect；CRect rect；

    一般前缀命名规范
    前缀类型实例
    C类或结构CDocument，CPrintInfo
    m_成员变量m_pDoc，m_nCustomers
    变量命名规范
    前缀类型描述实例
    chchar8位字符chGrade
    ch TCHAR如果_UNICODE定义，则为16位字符chName
    bBOOL布尔值bEnable
    n int整型（其大小依赖于操作系统）nLength
    n UINT 无符号值（其大小依赖于操作系统）nHeight
    w WORD 16位无符号值wPos
    l LONG 32位有符号整型lOffset
    dw DWORD 32位无符号整型 dwRange
    p * 指针pDoc
    lp FAR* 远指针 lpszName
    lpsz LPSTR 32位字符串指针lpszName
    lpsz LPCSTR 32位常量字符串指针lpszName
    lpsz LPCTSTR 如果_UNICODE定义，则为32位常量字符串指针lpszName
    h handle Windows对象句柄hWnd
    lpfn callback指向CALLBACK函数的远指针
    前缀符号类型实例范围
    IDR_ 不同类型的多个资源共享标识IDR_MAIINFRAME1～0x6FFF
    IDD_对话框资源IDD_SPELL_CHECK 1～0x6FFF
    HIDD_对话框资源的Help上下文HIDD_SPELL_CHECK 0x20001～0x26FF
    IDB_ 位图资源IDB_COMPANY_LOGO 1～0x6FFF
    IDC_光标资源IDC_PENCIL 1～0x6FFF
    IDI_图标资源IDI_NOTEPAD 1～0x6FFF
    ID_来自菜单项或工具栏的命令ID_TOOLS_SPELLING 0x8000～0xDFFF
    HID_命令Help上下文HID_TOOLS_SPELLING 0x18000～0x1DFFF
    IDP_消息框提示IDP_INVALID_PARTNO 8～0xDEEF
    HIDP_消息框Help上下文HIDP_INVALID_PARTNO 0x30008～0x3DEFF
    IDS_串资源IDS_COPYRIGHT 1～0x7EEF
    IDC_对话框内的控件IDC_RECALC 8～0xDEEF

    应用程序符号命名规范

    Microsoft MFC宏命名规范

    名称类型
    _AFXDLL唯一的动态连接库（Dynamic Link Library，DLL）版本
    _ALPHA仅编译DEC Alpha处理器
    _DEBUG包括诊断的调试版本
    _MBCS编译多字节字符集
    _UNICODE在一个应用程序中打开Unicode
    AFXAPI MFC提供的函数
    CALLBACK通过指针回调的函数

    库标识符命名法

    标识符值和含义
    u ANSI（N）或Unicode（U）
    d 调试或发行：D = 调试；忽略标识符为发行。

    静态库版本命名规范

    库描述
    NAFXCWD.LIB调试版本：MFC静态连接库
    NAFXCW.LIB发行版本：MFC静态连接库
    UAFXCWD.LIB调试版本：具有Unicode支持的MFC静态连接库
    UAFXCW.LIB发行版本：具有Unicode支持的MFC静态连接库

    动态连接库命名规范

    名称类型
    _AFXDLL唯一的动态连接库（DLL）版本
    WINAPI Windows所提供的函数

    Windows.h中新的命名规范
    类型定义描述
    WINAPI使用在API声明中的FAR PASCAL位置，如果正在编写一个具有导出API人口点的DLL，则可以在自己的API中使用该类型
    CALLBACK使用在应用程序回叫例程，如窗口和对话框过程中的FAR PASCAL的位置
    LPCSTR与LPSTR相同，只是LPCSTR用于只读串指针，其定义类似（const char FAR*）
    UINT可移植的无符号整型类型，其大小由主机环境决定（对于Windows NT和Windows 9x为32位）；它是unsigned int的同义词
    LRESULT窗口程序返回值的类型
    LPARAM声明lParam所使用的类型，lParam是窗口程序的第四个参数
    WPARAM声明wParam所使用的类型，wParam是窗口程序的第三个参数
    LPVOID一般指针类型，与（void *）相同，可以用来代替LPSTR
    摘自http://qhmoon.blogdriver.com/qhmoon/1181508.html

    查看(139) 评论(98) 收藏 分享 管理

  • windows api中定义的基本数据类型简介(转)

    2008-05-16 13:14:06

    windows api中定义的基本数据类型简介

    ATOM                   原子（原子表中的一个字符串的参考）
    BOOL                   布尔变量
    BOOLEAN                布尔变量
    BYTE                   字节（8位）
    CCHAR                  Windows字符
    CHAR                   Windows字符
    COLORREF               红、绿、蓝(RGB)彩色值(32位)
    Const                  变量，该变量的值在执行期间保持为常量
    CRITICAL_SECTION       临界段对象
    CTRYID                 国名标识符
    DLGPROC                指向一个对话框过程的指针
    DWORD                  双字(32位)
    ENHMFENUMPROC          指向一个应用程序定义的回调函数的指针，该回调函数枚举增强的元文件记录
    ENUMRESLANGPROC        指向一个应用程序定义的回调函数的指针，该回调函数枚举资源语言。
    ENUMRESNAMEPROC        指向一个应用程序定义的回调函数的指针，该回调函数枚举资源名称。
    ENUMRESTYPEPROC        指向一个应用程序定义的回调函数的指针，该回调函数枚举资源类型。
    FARPROC                指向一个回调函数的指针
    FLOAT                  浮点变量
    FMORDER                32位字体映射值的数组
    FONTENUMPROC           指向一个应用程序定义的回调函数的指针，该回调函数枚举字体
    GOBJENUMPROC           指向一个应用程序定义的回调函数的指针，该回调函数枚举图形设备接口(GDI)对象
    HACCEL                 加速键表句柄
    HANDLE                 对象的句柄
    HBITMAP                位图句柄
    HBRUSH                 画刷句柄
    HCONV                  动态数据交换(DDE)会话句柄
    HCONVLIST              DDE会话句柄
    HCURSOR                光标句柄
    HDC                    设备描述表(DC)句柄
    HDDEDATA               DDE数据句柄
    HDLG                   对话框句柄
    HDWP                   延期窗口位置结构句柄
    HENHMETAFILE           增强原文件句柄
    HFILE                  文件句柄
    HFONT                  字体句柄
    HGDIOBJ                GDI对象句柄
    HGLOBAL                全局内存块句柄
    HHOOK                  钩子句柄
    HICON                  图标句柄
    HINSTANCE              实例句柄
    HKEY                   登记关键字句柄
    HLOCAL                 局部内存块句柄
    HMEMU                  菜单句柄
    HMETAFILE              元文件句柄
    HMIDIIN                乐器的数字化接口(MIDI)输入文件句柄
    HMIDIOUT               MIDI输出文件句柄
    HMMIO                  文件句柄
    HOOKPROC               指向一个应用程序定义的钩子函数的指针
    HPALETTE               调色板句柄
    HPEN                   画笔句柄
    HRGN                   域句柄
    HRSRC                  资源句柄
    HSZ                    DDE字符串句柄
    HWAVEIN                波形输入文件句柄
    HWAVEOUT               波形输出文件句柄
    HWINSTA                工作站句柄
    HWND                   窗口句柄
    INT                    符号整数
    LANGID                 语言标识符
    LCID                   所在国(Locale)标识符
    LCTYPE                 所在国类型
    LINEDDAPROC            指向一个回调函数的指针，该回调函数处理行坐标
    LONG                   32位符号整数
    LP                     指向一个以"NULL"结束的Unicode(TM)字符串的指针
    LPARAM                 32位消息参数
    LPBOOL                 指向一个布尔变量的指针
    LPBYTE                 指向一个字节的指针
    LPCCH                  指向一个Windows字符常量的指针
    LPCCHOOKPROC           指向一个应用程序定义的钩子函数的指针
    LPCFHOOLPROC           指向一个应用程序定义的钩子函数的指针
    LPCH                   指向一个Windows字符的指针
    LPCOLORREF             指向一个COLORREF值的指针
    LPCRITICAL_SECTION     指向一个临界段对象的指针
    LPCSTR                 指向一个以"NULL"结束的WINDOWS字符串常量的指针
    LPCTSTR                指向一个以"NULL"结束的Unicode或Windows字符串常量的指针      
    LPCWCH                 指向一个以"NULL"指向一个以"NULL"结束的Unicode字符常量的指针 
    LPCWSTR&nbs