zoukankan      html  css  js  c++  java

  • C++类对象大小的计算

    (一)常规类大小计算

    C++类对象计算需要考虑很多东西，如成员变量大小，内存对齐，是否有虚函数，是否有虚继承等。接下来，我将对此举例说明。

    以下内存测试环境为Win7+VS2012，操作系统为32位

    一、完全空类

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5.   
    6. };  
    7. class B : public A{  
    8.   
    9. };  
    10. class C : public B{  
    11.   
    12. };  
    13.   
    14. int main() {  
    15.     A a;  
    16.     B b;  
    17.     C c;  
    18.     cout<<"size of a:"<<sizeof(a)<<endl;  
    19.     cout<<"size of b:"<<sizeof(b)<<endl;  
    20.     cout<<"size of c:"<<sizeof(c)<<endl;  
    21.     return 0;  
    22. }  

    VS类布局图：

    运行结果为：

            不含任何成员变量，且在一般继承(不含虚继承)情况下，无论是基类还是派生类，所有的类大小均为1。这1个字节的空间是系统为该类的对象创建的一个占位符，表示该对象仅仅是存在而已，而没有实际内容。

    二、仅有常规函数，无成员变量类

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     void printA() {  
    10.         cout<<"Hello A";  
    11.     }  
    12. };  
    13. class B :public A{  
    14. public:  
    15.     B(int x=0) {  
    16.         cout<<"B"<<x<<endl;  
    17.     }  
    18.     void printB() {  
    19.         cout<<"Hello B";  
    20.     }  
    21. };  
    22.   
    23. class C : public B{  
    24. public:  
    25.     C() {  
    26.         cout<<"C"<<endl;  
    27.     }  
    28.     void printC() {  
    29.         cout<<"Hello C";  
    30.     }  
    31. };  
    32.   
    33. int main() {  
    34.     A a;  
    35.     B b;  
    36.     C c;  
    37.     cout<<"size of a:"<<sizeof(a)<<endl;  
    38.     cout<<"size of b:"<<sizeof(b)<<endl;  
    39.     cout<<"size of c:"<<sizeof(c)<<endl;  
    40.     return 0;  
    41. }  

    VS类布局图：

    运行结果为：

            仅包含一般成员函数(即没有虚函数)，不含成员变量时，运行结果和(一)是一样的，系统也只是为对象创建了1个字节的占位符。因此，我们可以得出结论是，一般成员函数不会对类的大小造成影响。

    三、含有一般成员变量的类

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     void printA() {  
    10.         cout<<"Hello A";  
    11.     }  
    12. private:  
    13.     char Data1[3];  
    14.     int Data2;  
    15. };  
    16. class B :public A{  
    17. public:  
    18.     B(int x=0) {  
    19.         cout<<"B"<<x<<endl;  
    20.     }  
    21.     void printB() {  
    22.         cout<<"Hello B";  
    23.     }  
    24. private:  
    25.     char Data1[3];  
    26.     int Data2;  
    27. };  
    28.   
    29. class C : public B{  
    30. public:  
    31.     C(int x=0) {  
    32.         cout<<"C"<<x<<endl;  
    33.     }  
    34.     void printC() {  
    35.         cout<<"Hello C";  
    36.     }  
    37. private:  
    38.     char Data1[3];  
    39.     int Data2;  
    40. };  
    41.   
    42. int main() {  
    43.     A a;  
    44.     B b;  
    45.     C c;  
    46.     cout<<"size of a:"<<sizeof(a)<<endl;  
    47.     cout<<"size of b:"<<sizeof(b)<<endl;  
    48.     cout<<"size of c:"<<sizeof(c)<<endl;  
    49.     return 0;  
    50. }  

    VS类结构体为：

    运行结果为：

            依次继承的三个类中含有相同数量，相同类型的一般成员变量(不含静态成员变量)。此种情况下，类对象大小=基类对象大小+自身成员大小。A当中三个字符变量3个字节，一个整形变量4个字节，考虑内存对齐因素(默认为4)，A类对象大小为8。B类对象大小为A类对象大小基础上再加8，C类对象大小在B类对象大小基础上再加8。

           若继承情况为：A、B都是基类，C类同时继承了A、B，结果同样符合上述的累加原则：类C对象的大小=类A对象的大小+类B对象的大小+自身成员大小。如：

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     void printA() {  
    10.         cout<<"Hello A";  
    11.     }  
    12. private:  
    13.     char Data1[3];  
    14.     int Data2;  
    15. };  
    16. class B{  
    17. public:  
    18.     B(int x=0) {  
    19.         cout<<"B"<<x<<endl;  
    20.     }  
    21.     void printB() {  
    22.         cout<<"Hello B";  
    23.     }  
    24. private:  
    25.     char Data1[3];  
    26.     int Data2;  
    27. };  
    28.   
    29. class C : public A, public B{  
    30. public:  
    31.     C(int x=0) {  
    32.         cout<<"C"<<x<<endl;  
    33.     }  
    34.     void printC() {  
    35.         cout<<"Hello C";  
    36.     }  
    37. private:  
    38.     char Data1[3];  
    39.     int Data2;  
    40. };  
    41.   
    42. int main() {  
    43.     A a;  
    44.     B b;  
    45.     C c;  
    46.     cout<<"size of a:"<<sizeof(a)<<endl;  
    47.     cout<<"size of b:"<<sizeof(b)<<endl;  
    48.     cout<<"size of c:"<<sizeof(c)<<endl;  
    49.     return 0;  
    50. }  

    VS类结构图：

    运行结果为：

    四、含有静态成员变量

            在上面例子的基础上，每个类都增加一个静态成员变量：

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     void printA() {  
    10.         cout<<"Hello A";  
    11.     }  
    12. private:  
    13.     char Data1[3];  
    14.     int Data2;  
    15.     static int Data3;  
    16. };  
    17. class B: public A {  
    18. public:  
    19.     B(int x=0) {  
    20.         cout<<"B"<<x<<endl;  
    21.     }  
    22.     void printB() {  
    23.         cout<<"Hello B";  
    24.     }  
    25. private:  
    26.     char Data1[3];  
    27.     int Data2;  
    28.     static int Data3;  
    29. };  
    30.   
    31. class C : public B{  
    32. public:  
    33.     C(int x=0) {  
    34.         cout<<"C"<<x<<endl;  
    35.     }  
    36.     void printC() {  
    37.         cout<<"Hello C";  
    38.     }  
    39. private:  
    40.     char Data1[3];  
    41.     int Data2;  
    42.     static int Data3;  
    43. };  
    44.   
    45. int main() {  
    46.     A a;  
    47.     B b;  
    48.     C c;  
    49.     cout<<"size of a:"<<sizeof(a)<<endl;  
    50.     cout<<"size of b:"<<sizeof(b)<<endl;  
    51.     cout<<"size of c:"<<sizeof(c)<<endl;  
    52.     return 0;  
    53. }  

    运行结果为：

            可以看到，类对象大小没有因为增加了静态成员而变化。因为静态成员是属于类成员共有的，不单独属于任何一个对象，对静态成员的存储不会选择在某个对象空间，而是存在于堆当中，因此不会对对象的大小造成影响。

            以上情况仅仅只是考虑常规函数，没有虚函数，没有虚继承情况下类对象。之后的文章《C++类对象大小的计算(二)含有虚函数类大小计算》会讨论含有虚函数时的情况。

    (二)含有虚函数类大小计算

    以下内存测试环境为Win7+VS2012，操作系统为32位

    五、包含虚函数的类

            包含虚函数的类，对象生成时，会在类对象当中插入一个指针，这个指针称做虚函数表指针，简称虚表指针(vPtr)。该指针指向一个虚函数表(简称虚表)，虚函数表中存储了虚函数的入口地址。基类当中有虚函数时，会产生该虚函数表；创建基类对象，对象中的vPtr会指向该表；调用虚函数时，是通过vPtr在此表当中寻找函数入口地址的。

            当派生类继承含有虚函数的子类时，会复制一份虚函数表，派生类如果有与基类中虚函数同名的虚函数，会在虚函数表中覆盖原来基类的虚函数；如果虚函数不重名，只会在虚函数表中增加一个函数入口。这种机制实现了类的多态。

    如下面的例子：

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     void printA() {  
    10.         cout<<"Hello A";  
    11.     }  
    12. };  
    13. class B :public A{  
    14. public:  
    15.     B(int x=0) {  
    16.         cout<<"B"<<x<<endl;  
    17.     }  
    18.     virtual void printB() {  
    19.         cout<<"Hello B";  
    20.     }  
    21. };  
    22.   
    23. class C : public B{  
    24. public:  
    25.     C() {  
    26.         cout<<"C"<<endl;  
    27.     }  
    28.     virtual void printC() {  
    29.         cout<<"Hello C";  
    30.     }  
    31. };  
    32.   
    33. int main() {  
    34.     A a;  
    35.     B b;  
    36.     C c;  
    37.     cout<<"size of a:"<<sizeof(a)<<endl;  
    38.     cout<<"size of b:"<<sizeof(b)<<endl;  
    39.     cout<<"size of c:"<<sizeof(c)<<endl;  
    40.     return 0;  
    41. }  

    VS类结构图：

    运行结果为：

            类A没有虚函数，因此大小仍然是1。类B因为有虚函数，其对象当中包含了一个vPtr指针，指针指向类B的虚函数表(假设为vTB)，该表中存储了printB的入口地址，因此大小为4。类C因为继承了类B，也就复制了vTB(设为vTC)，其对象中也就包含了指向vTC的虚表指针，该虚表中除了有printB的入口地址外，还包含了printC的入口地址，因此，类C对象大小为4。
     
            考虑另一种情况，类C同时继承了类A、B，类A、B当中都有虚函数。如下面的例子：
    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     virtual void printA() {  
    10.         cout<<"Hello A";  
    11.     }  
    12. };  
    13. class B {  
    14. public:  
    15.     B(int x=0) {  
    16.         cout<<"B"<<x<<endl;  
    17.     }  
    18.     virtual void printB() {  
    19.         cout<<"Hello B";  
    20.     }  
    21. };  
    22.   
    23. class C : public B, public A{  
    24. public:  
    25.     C() {  
    26.         cout<<"C"<<endl;  
    27.     }  
    28.     void printC() {  
    29.         cout<<"Hello C";  
    30.     }  
    31. };  
    32.   
    33. int main() {  
    34.     A a;  
    35.     B b;  
    36.     C c;  
    37.     cout<<"size of a:"<<sizeof(a)<<endl;  
    38.     cout<<"size of b:"<<sizeof(b)<<endl;  
    39.     cout<<"size of c:"<<sizeof(c)<<endl;  
    40.     return 0;  
    41. }  
    VS类结构图：
    运行结果为：
    类A、B对象的大小按照上面所说的内存很好理解。类C因为同时继承了类A、B，因此就复制了两个虚函数表，也就有了两个vPtr，所以大小为8。如果类C有虚函数，也会放在其中一张虚函数表当中，不会再增加对象大小。
            含有成员变量时，按照《C++类对象大小的计算(一)常规类大小计算》所讲内容加上相应的大小即可。
     
            下面的文章《C++类对象大小的计算(三)含有虚函数、虚继承类大小计算》会讨论增加虚继承时，类对象的大小。
     
     (三)含有虚函数、虚继承类大小计算

    以下内存测试环境为Win7+VS2012，操作系统为32位

    六、当类中含有虚继承情况时

        1. 派生类对象中会添加一个指针，该指针指向虚继承的基类，称为虚类指针(cPtr)。每一个指针只指向其中一个虚继承的类，也就是说，虚继承了几个类，就会有几个cPtr。

        2. 父类当中的成员变量、虚函数指针(vPtr)、虚类指针(cPtr)仍然会被复制到派生类当中。但在不同继承模式下，vPtr和cPtr的效果是不同的。

            vPtr：普通继承时，子类当中如果有虚函数，会直接在父类的虚函数表中添加或者替换相应的选项；虚继承时，vPtr指向的基类虚表不可以再增加了；如果在派生类添加虚函数，分为三种情况：

              情况一：虚函数名称与父类当中的某个虚函数名相同，且派生类含有构造函数，会在结构体中产生一个和虚基类有关的vtordisp指针，该指针作用暂未知。

              情况二：虚函数名称与父类当中的某个虚函数名相同，且派生类不含构造函数，会直接修改基类虚函数表，类大小不变。

              情况三：虚函数名称与父类当中的任何一个虚函数都不同，需要重新添加一个vPtr，重新产生一个虚函数表，大小就会增加。

            cPtr：假设子类D同时继承了父类B和父类C，两个父类都虚继承了类A（A是无任何虚继承的类），根据子类D对B、C继承方式的不同，其cPtr的个数也是不同的

              (1). 父类B、C都是普通继承。这种情况下有两个cPtr，分别是从父类B和父类C中继承过来的，且指向虚继承的A。

              (2). 父类C是虚继承，B是普通继承时(或相反情况)。普通继承父类B时已经继承过A(有了一个cPtr)，因此在虚继承父类C时，父类C虚继承的类A就不会再次继承，因此不会有第二个cPtr指向A。虚继承父类C也会产生一个cPtr。因此，此种情况下有两个cPtr。

              (3). 父类B、C都是虚继承。此时指向类A的cPtr仍然只有一个，另外有两个cPtr指向父类B、C，所以一共有三个cPtr。

            下面以几个例子来理解一下上面所说内容：

             情况一：类B虚继承类A，类C虚继承类A，类D普通继承类B、C，各类中均不包含虚函数

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9. };  
    10. class B : virtual public A {  
    11. public:  
    12.     B(int x=0) {  
    13.         cout<<"B"<<x<<endl;  
    14.     }  
    15. };  
    16.   
    17. class C : virtual public A {  
    18. public:  
    19.     C() {  
    20.         cout<<"C"<<endl;  
    21.     }  
    22.   
    23. };  
    24. class D : public B, public C {  
    25. public:  
    26.     D() {  
    27.         cout<<"D"<<endl;  
    28.     }  
    29.   
    30. };  
    31. int main() {  
    32.     A a;  
    33.     B b;  
    34.     C c;  
    35.     D d;  
    36.     cout<<"size of a:"<<sizeof(a)<<endl;  
    37.     cout<<"size of b:"<<sizeof(b)<<endl;  
    38.     cout<<"size of c:"<<sizeof(c)<<endl;  
    39.     cout<<"size of d:"<<sizeof(d)<<endl;  
    40.     return 0;  
    41. }  

    VS类结构图：

    运行结果为：

    类B、C虚继承了类A，因此都拥有一个cPtr(类图中用vbptr表示)，因此大小为4。类D普通继承了B、C，因此复制了两者的cPtr(都指向类A)，大小为8。

             情况二：类B虚继承类A，类C普通继承类A，类A、B、C中都包含有虚函数

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     virtual void printA() {  
    10.         cout<<"Hello A"<<endl;  
    11.     }  
    12. };  
    13. class B :virtual  public A {  
    14. public:  
    15.     B(int x=0) {  
    16.         cout<<"B"<<x<<endl;  
    17.     }  
    18.     virtual void printA() {  
    19.         cout<<"Hello A"<<endl;  
    20.     }  
    21. };  
    22.   
    23. class C : public A {  
    24. public:  
    25.     C() {  
    26.         cout<<"C"<<endl;  
    27.     }  
    28.     virtual void printA() {  
    29.         cout<<"Hello A"<<endl;  
    30.     }  
    31. };  
    32.   
    33. int main() {  
    34.     A a;  
    35.     B b;  
    36.     C c;  
    37.     cout<<"size of a:"<<sizeof(a)<<endl;  
    38.     cout<<"size of b:"<<sizeof(b)<<endl;  
    39.     cout<<"size of c:"<<sizeof(c)<<endl;  
    40.     return 0;  
    41. }  

    VS类结构图：

    运行结果为：

    类A当中因为有虚函数，存在一个vPtr，因此结果为4。类B复制了类A的vPtr和虚函数表，产生了指向类A的cPtr；因为是类B是虚继承了类A，且类B当中又有与类A中同名的虚函数，因此根据vPtr情况一所示，也就有了一个新的vtordisp指针；共三个指针，因此大小为12。类C是普通继承类A，复制了类A的虚函数表和vPtr，它的虚函数也就添加在了这个虚函数表中，因此也只有一个指针，大小为4。

            情况三：类A为空类；类B、C都虚继承了类A；类D普通继承了类B、C；类E普通继承了类B，虚继承了类C；类F虚继承了类B、C，所有类均没有虚函数

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9. };  
    10. class B :virtual  public A {  
    11. public:  
    12.     B(int x=0) {  
    13.         cout<<"B"<<x<<endl;  
    14.     }  
    15. };  
    16.   
    17. class C :virtual public A {  
    18. public:  
    19.     C() {  
    20.         cout<<"C"<<endl;  
    21.     }  
    22. };  
    23.   
    24. class D : public C,  public B {  
    25. public:  
    26.     D() {  
    27.         cout<<"D"<<endl;  
    28.     }  
    29.   
    30. };  
    31. class E :virtual public C,  public B {  
    32. public:  
    33.     E() {  
    34.         cout<<"E"<<endl;  
    35.     }  
    36. };  
    37. class F :virtual public C, virtual public B {  
    38. public:  
    39.     F() {  
    40.         cout<<"F"<<endl;  
    41.     }  
    42. };  
    43. int main() {  
    44.     A a;  
    45.     B b;  
    46.     C c;  
    47.     D d;  
    48.     E e;  
    49.     F f;  
    50.     cout<<"size of a:"<<sizeof(a)<<endl;  
    51.     cout<<"size of b:"<<sizeof(b)<<endl;  
    52.     cout<<"size of c:"<<sizeof(c)<<endl;  
    53.     cout<<"size of d:"<<sizeof(d)<<endl;  
    54.     cout<<"size of e:"<<sizeof(e)<<endl;  
    55.     cout<<"size of f:"<<sizeof(f)<<endl;  
    56.     return 0;  
    57. }  

    VS类结构图：

    运行结果为：

    类A、B、C的大小不做过多讨论；类D直接复制了类B和C当中指向类A的cPtr，因此是两个指针，大小为8；类E中复制了类B当中指向类A的cPtr，继承类C时因为虚继承关系不会再一次继承类A，只会产生一个指向类C的cPtr，因此只有两个指针， 大小为8；类F除了类E中的两个指针外，又产生了指向类B的cPtr，一共三个指针，大小为12。

            情况四：情况三包含虚函数时

    [cpp] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class A {  
    5. public:  
    6.     A(int x=0) {  
    7.         cout<<"A"<<x<<endl;  
    8.     }  
    9.     virtual void printA() {  
    10.         cout<<"Hello A"<<endl;  
    11.     }  
    12. };  
    13. class B :virtual  public A {  
    14. public:  
    15.     B(int x=0) {  
    16.         cout<<"B"<<x<<endl;  
    17.     }  
    18.     virtual void printB() {  
    19.         cout<<"Hello B"<<endl;  
    20.     }  
    21. };  
    22.   
    23. class C :virtual public A {  
    24. public:  
    25.     C() {  
    26.         cout<<"C"<<endl;  
    27.     }  
    28.     virtual void printC() {  
    29.         cout<<"Hello C"<<endl;  
    30.     }  
    31. };  
    32.   
    33. class D : public C,  public B {  
    34. public:  
    35.     D() {  
    36.         cout<<"D"<<endl;  
    37.     }  
    38.     virtual void printD() {  
    39.         cout<<"Hello D"<<endl;  
    40.     }  
    41. };  
    42.   
    43. class E :virtual public C,  public B {  
    44. public:  
    45.     E() {  
    46.         cout<<"E"<<endl;  
    47.     }  
    48.     virtual void printE() {  
    49.         cout<<"Hello E"<<endl;  
    50.     }  
    51. };  
    52. class F :virtual public C, virtual public B {  
    53. public:  
    54.     F() {  
    55.         cout<<"F"<<endl;  
    56.     }  
    57.     virtual void printF() {  
    58.         cout<<"Hello F"<<endl;  
    59.     }  
    60. };  
    61. int main() {  
    62.     A a;  
    63.     B b;  
    64.     C c;  
    65.     D d;  
    66.     E e;  
    67.     F f;  
    68.     cout<<"size of a:"<<sizeof(a)<<endl;  
    69.     cout<<"size of b:"<<sizeof(b)<<endl;  
    70.     cout<<"size of c:"<<sizeof(c)<<endl;  
    71.     cout<<"size of d:"<<sizeof(d)<<endl;  
    72.     cout<<"size of e:"<<sizeof(e)<<endl;  
    73.     cout<<"size of f:"<<sizeof(f)<<endl;  
    74.     return 0;  
    75. }  

    VS类结构图：

    运行结果为：

    类B、C都复制了类A的vPtr，但由于都是虚继承类A且他们当中的虚函数与类A中虚函数不同名，因此需要重新产生新的vPtr和虚函数表，加上各自的cPtr，都有三个指针，大小为12。类D和类E当中都有普通继承，因此不需要产生新的vPtr。按照前面分析，类D中包含两个指向类A的cPtr，三个vPtr(分别指向类A、类B、类C的，类D虚函数放在了类B或类C的vPtr指向的虚函数表中)；类E中包含cPtr，分别指向类A、类C，三个vPtr(分别为类A、类B、类C的，类E的虚函数放在了类B的vPtr指向的虚函数表中)；类F中包括三个cPtr(分别指向类A，类B，类C)，四个vPtr(分别为类A，类B，类C，还有因为类F中虚函数而新创建的)，共七个指针，大小为28。
     
     
    至此，所有关于windows下C++类大小的分析已经全部写完，需要特别注意的是，以上所有结果都是在用微软的C++编译器得到的，经实际测试，相同代码在Linux系统下用g++编译过后会得到完全不同的结果。因此，微软C++编译器对类的处理并不是完全按照C++标准来的。
    由于C++是一门很复杂的语言，其中的规则很多，细节也很多。这三篇博客中写的内容定有不妥之处，欢迎各位指正。
  • 相关阅读:
    Windows Phone开发（21）：做一个简单的绘图板 转：http://blog.csdn.net/tcjiaan/article/details/7392179
    Windows Phone开发（18）：变形金刚第九季——变换 转：http://blog.csdn.net/tcjiaan/article/details/7385056
    Windows Phone开发（24）：启动器与选择器之发送短信 转：http://blog.csdn.net/tcjiaan/article/details/7404643
    Windows Phone开发（16）：样式和控件模板 转：http://blog.csdn.net/tcjiaan/article/details/7367260
    POJ 2484 A Funny Game
    CodeForces 835E The penguin's game
    【SDOI 2015】序列统计
    Cutting Game
    HDU 1525 Euclid's Game
    Fibonacci Nim 斐波那契博弈
  • 原文地址：https://www.cnblogs.com/alexhg/p/6552645.html
Copyright © 2011-2022 走看看