(一)常规类大小计算

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

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

一、完全空类

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. };
  5. class B : public A{
  6. };
  7. class C : public B{
  8. };
  9. int main() {
  10. A a;
  11. B b;
  12. C c;
  13. cout<<"size of a:"<<sizeof(a)<<endl;
  14. cout<<"size of b:"<<sizeof(b)<<endl;
  15. cout<<"size of c:"<<sizeof(c)<<endl;
  16. return 0;
  17. }

VS类布局图:

运行结果为:

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

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

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. void printA() {
  9. cout<<"Hello A";
  10. }
  11. };
  12. class B :public A{
  13. public:
  14. B(int x=0) {
  15. cout<<"B"<<x<<endl;
  16. }
  17. void printB() {
  18. cout<<"Hello B";
  19. }
  20. };
  21. class C : public B{
  22. public:
  23. C() {
  24. cout<<"C"<<endl;
  25. }
  26. void printC() {
  27. cout<<"Hello C";
  28. }
  29. };
  30. int main() {
  31. A a;
  32. B b;
  33. C c;
  34. cout<<"size of a:"<<sizeof(a)<<endl;
  35. cout<<"size of b:"<<sizeof(b)<<endl;
  36. cout<<"size of c:"<<sizeof(c)<<endl;
  37. return 0;
  38. }

VS类布局图:

运行结果为:

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

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

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

VS类结构体为:

运行结果为:

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

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

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

VS类结构图:

运行结果为:

四、含有静态成员变量

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

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. void printA() {
  9. cout<<"Hello A";
  10. }
  11. private:
  12. char Data1[3];
  13. int Data2;
  14. static int Data3;
  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. static int Data3;
  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. static int Data3;
  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. }

运行结果为:

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

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

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

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

五、包含虚函数的类

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

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

如下面的例子:

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. void printA() {
  9. cout<<"Hello A";
  10. }
  11. };
  12. class B :public A{
  13. public:
  14. B(int x=0) {
  15. cout<<"B"<<x<<endl;
  16. }
  17. virtual void printB() {
  18. cout<<"Hello B";
  19. }
  20. };
  21. class C : public B{
  22. public:
  23. C() {
  24. cout<<"C"<<endl;
  25. }
  26. virtual void printC() {
  27. cout<<"Hello C";
  28. }
  29. };
  30. int main() {
  31. A a;
  32. B b;
  33. C c;
  34. cout<<"size of a:"<<sizeof(a)<<endl;
  35. cout<<"size of b:"<<sizeof(b)<<endl;
  36. cout<<"size of c:"<<sizeof(c)<<endl;
  37. return 0;
  38. }

VS类结构图:

运行结果为:

        类A没有虚函数,因此大小仍然是1。类B因为有虚函数,其对象当中包含了一个vPtr指针,指针指向类B的虚函数表(假设为vTB),该表中存储了printB的入口地址,因此大小为4。类C因为继承了类B,也就复制了vTB(设为vTC),其对象中也就包含了指向vTC的虚表指针,该虚表中除了有printB的入口地址外,还包含了printC的入口地址,因此,类C对象大小为4。
 
        考虑另一种情况,类C同时继承了类A、B,类A、B当中都有虚函数。如下面的例子:
  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. virtual void printA() {
  9. cout<<"Hello A";
  10. }
  11. };
  12. class B {
  13. public:
  14. B(int x=0) {
  15. cout<<"B"<<x<<endl;
  16. }
  17. virtual void printB() {
  18. cout<<"Hello B";
  19. }
  20. };
  21. class C : public B, public A{
  22. public:
  23. C() {
  24. cout<<"C"<<endl;
  25. }
  26. void printC() {
  27. cout<<"Hello C";
  28. }
  29. };
  30. int main() {
  31. A a;
  32. B b;
  33. C c;
  34. cout<<"size of a:"<<sizeof(a)<<endl;
  35. cout<<"size of b:"<<sizeof(b)<<endl;
  36. cout<<"size of c:"<<sizeof(c)<<endl;
  37. return 0;
  38. }
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,各类中均不包含虚函数

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. };
  9. class B : virtual public A {
  10. public:
  11. B(int x=0) {
  12. cout<<"B"<<x<<endl;
  13. }
  14. };
  15. class C : virtual public A {
  16. public:
  17. C() {
  18. cout<<"C"<<endl;
  19. }
  20. };
  21. class D : public B, public C {
  22. public:
  23. D() {
  24. cout<<"D"<<endl;
  25. }
  26. };
  27. int main() {
  28. A a;
  29. B b;
  30. C c;
  31. D d;
  32. cout<<"size of a:"<<sizeof(a)<<endl;
  33. cout<<"size of b:"<<sizeof(b)<<endl;
  34. cout<<"size of c:"<<sizeof(c)<<endl;
  35. cout<<"size of d:"<<sizeof(d)<<endl;
  36. return 0;
  37. }

VS类结构图:

运行结果为:

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

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

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. virtual void printA() {
  9. cout<<"Hello A"<<endl;
  10. }
  11. };
  12. class B :virtual  public A {
  13. public:
  14. B(int x=0) {
  15. cout<<"B"<<x<<endl;
  16. }
  17. virtual void printA() {
  18. cout<<"Hello A"<<endl;
  19. }
  20. };
  21. class C : public A {
  22. public:
  23. C() {
  24. cout<<"C"<<endl;
  25. }
  26. virtual void printA() {
  27. cout<<"Hello A"<<endl;
  28. }
  29. };
  30. int main() {
  31. A a;
  32. B b;
  33. C c;
  34. cout<<"size of a:"<<sizeof(a)<<endl;
  35. cout<<"size of b:"<<sizeof(b)<<endl;
  36. cout<<"size of c:"<<sizeof(c)<<endl;
  37. return 0;
  38. }

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,所有类均没有虚函数

  1. #include <iostream>
  2. using namespace std;
  3. class A {
  4. public:
  5. A(int x=0) {
  6. cout<<"A"<<x<<endl;
  7. }
  8. };
  9. class B :virtual  public A {
  10. public:
  11. B(int x=0) {
  12. cout<<"B"<<x<<endl;
  13. }
  14. };
  15. class C :virtual public A {
  16. public:
  17. C() {
  18. cout<<"C"<<endl;
  19. }
  20. };
  21. class D : public C,  public B {
  22. public:
  23. D() {
  24. cout<<"D"<<endl;
  25. }
  26. };
  27. class E :virtual public C,  public B {
  28. public:
  29. E() {
  30. cout<<"E"<<endl;
  31. }
  32. };
  33. class F :virtual public C, virtual public B {
  34. public:
  35. F() {
  36. cout<<"F"<<endl;
  37. }
  38. };
  39. int main() {
  40. A a;
  41. B b;
  42. C c;
  43. D d;
  44. E e;
  45. F f;
  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. cout<<"size of d:"<<sizeof(d)<<endl;
  50. cout<<"size of e:"<<sizeof(e)<<endl;
  51. cout<<"size of f:"<<sizeof(f)<<endl;
  52. return 0;
  53. }

VS类结构图:

运行结果为:

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

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

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

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++是一门很复杂的语言,其中的规则很多,细节也很多。这三篇博客中写的内容定有不妥之处,欢迎各位指正。

C++类对象大小的计算的更多相关文章

  1. C++类对象大小问题(一)

    先看如下代码: #include<iostream> using namespace std; class Base1 { public: }; class Base2 { public: ...

  2. 对C++对象内存模型造成的影响(类/对象的大小)

    首先重新回顾一下关于类/对象大小的计算原则: 类大小计算遵循结构体对齐原则 第一个数据成员放在offset为0的位置 其它成员对齐至min(sizeof(member),#pragma pack(n) ...

  3. static 成员变量、static 成员函数、类/对象的大小

    一.static 成员变量 对于特定类型的全体对象而言,有时候可能需要访问一个全局的变量.比如说统计某种类型对象已创建的数量. 如果我们用全局变量会破坏数据的封装,一般的用户代码都可以修改这个全局变量 ...

  4. c++类对象的内存分布

    要想知道c++类对象的内存布局, 可以有多种方式,比如: 1)输出成员变量的偏移, 通过offsetof宏来得到 2)通过调试器查看, 比如常用的VS 1.没有数据成员的对象 class A{ }; ...

  5. C++一个类对象的大小计算

    计算一个类对象的大小时的规律: 1.空类.单一继承的空类.多重继承的空类所占空间大小为:1(字节,下同): 2.一个类中,虚函数本身.成员函数(包括静态与非静态)和静态数据成员都是不占用类对象的存储空 ...

  6. Java对象大小计算

    这篇说说如何计算Java对象大小的方法.之前在聊聊高并发(四)Java对象的表示模型和运行时内存表示 这篇中已经说了Java对象的内存表示模型是Oop-Klass模型. 普通对象的结构如下,按64位机 ...

  7. C++类的大小计算汇总

    C++中类涉及到虚函数成员.静态成员.虚继承.多继承.空类等. 类,作为一种类型定义,是没有大小可言的. 类的大小,指的是类的对象所占的大小.因此,用sizeof对一个类型名操作,得到的是具有该类型实 ...

  8. 两种计算Java对象大小的方法

    之前想研究一下unsafe类,碰巧在网上看到了这篇文章,觉得写得很好,就转载过来.原文出处是: http://blog.csdn.net/iter_zc/article/details/4182271 ...

  9. C++类大小的计算

    这里记录一下怎么计算类对象的大小. 大概总结下,类的大小需要考虑以下内容: 非静态成员变量大小 数据对齐到多少位 有无虚函数(即需不需要指向虚函数表的指针,如果考虑继承的情况,则还需要看继承了多少个指 ...

随机推荐

  1. 20个常用的Java程序块

    1.字符串有整型的相互转换 String a = String.valueOf(2);//integer to numeric string Int i = Integer.parseInt(a);/ ...

  2. MyBatis:学习笔记(3)——关联查询

    MyBatis:学习笔记(3)--关联查询 关联查询 理解联结 SQL最强大的功能之一在于我们可以在数据查询的执行中可以使用联结,来将多个表中的数据作为整体进行筛选. 模拟一个简单的在线商品购物系统, ...

  3. linux的Make使用的重定向

    Linux中,脚本语言环境中,即你用make xxx即其他一些普通linux命令,比如ls,find等,不同的数字,代表不同的含义:  数字 含义  标准叫法   0  标准输入   stdin = ...

  4. W3Cschool学习笔记——CSS教程

    CSS 概述 CSS 指层叠样式表 (Cascading Style Sheets) 样式定义如何显示 HTML 元素 样式通常存储在样式表中 把样式添加到 HTML 4.0 中,是为了解决内容与表现 ...

  5. SysLog简介和java操作实例

    什么是SysLog syslog协议属于一种主从式协议:syslog发送端会传送出一个小的文字讯息(小于1024字节)到syslog接收端.接收端通常名为“syslogd”.“syslog daemo ...

  6. Spring实战——Profile

    看到Profile这个关键字,或许你从来没有正眼瞧过他,又或者脑海中有些模糊的印象,比如除了这里Springmvc中的Profile,maven中也有Profile的标签. 从字面意思来看,Profi ...

  7. self、 superclass 、 super的区别

    self. superclass . super self : 当前方法的调用者 class:获取方法调用者的类对象 superclass:获取方法调用者的父类对象 super:不是一个指针,编译指示 ...

  8. IIS7.0发布后关于"不能在此路径中使用此配置节”的解决办法

    在系统为window sever2008,iis7.0上安装后发布出现 IIS Web Core 通知 BeginRequest 处理程序 尚未确定 错误代码 0x80070021 配置错误 不能在此 ...

  9. (4)activiti之uel表达式

    有了前面几章,我们肯定有一定的困惑,activiti如何与实际业务整合,比如一条采购单,如何跟一个流程实例互相关联起来? 这里就需要使用到activiti启动流程实例时设置一个流程实例的busines ...

  10. SharePoint 2016 文档库的新功能简介

    今天,重装了一下SharePoint 2016,想多了解了解,看到一些自己平时没注意的功能,或者新的功能,分享一下给大家. 1.界面上操作的变换,多了一排按钮,更像SharePoint Online了 ...