程序博客网 > 淘宝买家好评率99%

C++对象的内存布局

来源：互联网 发布：淘宝买家好评率99% 编辑：程序博客网 时间：2024/06/04 19:28

07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非常简单的，主要是为了说明一些机理上的问题，也是为了图一些表达上方便和简单。不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些内容没有涉及：

1）有成员变量的情况。

2）有重复继承的情况。

3）有虚拟继承的情况。

4）有钻石型虚拟继承的情况。

 这些都是我本篇文章需要向大家说明的东西。所以，这篇文章将会是《C++虚函数表解析》的一个续篇，也是一篇高级进阶的文章。我希望大家在读这篇文章之前对C++有一定的基础和了解，并能先读我的上一篇文章。因为这篇文章的深度可能会比较深，而且会比较杂乱，我希望你在读本篇文章时不会有大脑思维紊乱导致大脑死机的情况。;-)

对象的影响因素

简而言之，我们一个类可能会有如下的影响因素：

1）成员变量

2）虚函数（产生虚函数表）

3）单一继承（只继承于一个类）

4）多重继承（继承多个类）

5）重复继承（继承的多个父类中其父类有相同的超类）

6）虚拟继承（使用virtual方式继承，为了保证继承后父类的内存布局只会存在一份）

上述的东西通常是C++这门语言在语义方面对对象内部的影响因素，当然，还会有编译器的影响（比如优化），还有字节对齐的影响。在这里我们都不讨论，我们只讨论C++语言上的影响。

本篇文章着重讨论下述几个情况下的C++对象的内存布局情况。

1）单一的一般继承（带成员变量、虚函数、虚函数覆盖）

2）单一的虚拟继承（带成员变量、虚函数、虚函数覆盖）

3）多重继承（带成员变量、虚函数、虚函数覆盖）

4）重复多重继承（带成员变量、虚函数、虚函数覆盖）

5）钻石型的虚拟多重继承（带成员变量、虚函数、虚函数覆盖）

我们的目标就是，让事情越来越复杂。

知识复习

我们简单地复习一下，我们可以通过对象的地址来取得虚函数表的地址，如：

1
2
3
4
5
6
7
8
9
10
11
12
typedefvoid(*Fun)(void);
 
Base b;
 
Fun pFun = NULL;
 
cout <<"虚函数表地址：" << (int*)(&b) << endl;
cout <<"虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;
 
// Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&b));
pFun();

我们同样可以用这种方式来取得整个对象实例的内存布局。因为这些东西在内存中都是连续分布的，我们只需要使用适当的地址偏移量，我们就可以获得整个内存对象的布局。

本篇文章中的例程或内存布局主要使用如下编译器和系统：

1）Windows XP 和 VC++ 2003
2）Cygwin 和 G++ 3.4.4

单一的一般继承

下面，我们假设有如下所示的一个继承关系：

01

请注意，在这个继承关系中，父类，子类，孙子类都有自己的一个成员变量。而了类覆盖了父类的f()方法，孙子类覆盖了子类的g_child()及其超类的f()。

我们的源程序如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
classParent {
public:
    intiparent;
    Parent ():iparent (10) {}
    virtualvoid f() { cout << " Parent::f()" << endl; }
    virtualvoid g() { cout << " Parent::g()" << endl; }
    virtualvoid h() { cout << " Parent::h()" << endl; }
 
};
 
classChild : publicParent {
public:
    intichild;
    Child():ichild(100) {}
    virtualvoid f() { cout << "Child::f()" << endl; }
    virtualvoid g_child() { cout << "Child::g_child()"<< endl; }
    virtualvoid h_child() { cout << "Child::h_child()"<< endl; }
};
 
classGrandChild : publicChild{
public:
    intigrandchild;
    GrandChild():igrandchild(1000) {}
    virtualvoid f() { cout << "GrandChild::f()" << endl; }
    virtualvoid g_child() { cout << "GrandChild::g_child()"<< endl; }
    virtualvoid h_grandchild() { cout << "GrandChild::h_grandchild()"<< endl; }
};

我们使用以下程序作为测试程序：（下面程序中，我使用了一个int** pVtab 来作为遍历对象内存布局的指针，这样，我就可以方便地像使用数组一样来遍历所有的成员包括其虚函数表了，在后面的程序中，我也是用这样的方法的，请不必感到奇怪，）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedefvoid(*Fun)(void);
 
GrandChild gc;
 
int** pVtab = (int**)&gc;
 
cout <<"[0] GrandChild::_vptr->" << endl;
for(inti=0; (Fun)pVtab[0][i]!=NULL; i++){
    pFun = (Fun)pVtab[0][i];
    cout <<"    ["<<i<<"] ";
    pFun();
}
cout <<"[1] Parent.iparent = " << (int)pVtab[1] << endl;
cout <<"[2] Child.ichild = " << (int)pVtab[2] << endl;
cout <<"[3] GrandChild.igrandchild = " << (int)pVtab[3] << endl;

其运行结果如下所示：（在VC++ 2003和G++ 3.4.4下）

1
2
3
4
5
6
7
8
9
10
[0] GrandChild::_vptr->
<pre>    [0] GrandChild::f()
    [1] Parent::g()
    [2] Parent::h()
    [3] GrandChild::g_child()
    [4] Child::h1()
    [5] GrandChild::h_grandchild()
[1] Parent.iparent = 10
[2] Child.ichild = 100
[3] GrandChild.igrandchild = 1000

使用图片表示如下：

02

可见以下几个方面：

1）虚函数表在最前面的位置。

2）成员变量根据其继承和声明顺序依次放在后面。

3）在单一的继承中，被overwrite的虚函数在虚函数表中得到了更新。

多重继承

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类只overwrite了父类的f()函数，而还有一个是自己的函数（我们这样做的目的是为了用g1()作为一个标记来标明子类的虚函数表）。而且每个类中都有一个自己的成员变量：

03

我们的类继承的源代码如下所示：父类的成员初始为10，20，30，子类的为100

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
classBase1 {
public:
    intibase1;
    Base1():ibase1(10) {}
    virtualvoid f() { cout << "Base1::f()" << endl; }
    virtualvoid g() { cout << "Base1::g()" << endl; }
    virtualvoid h() { cout << "Base1::h()" << endl; }
 
};
 
classBase2 {
public:
    intibase2;
    Base2():ibase2(20) {}
    virtualvoid f() { cout << "Base2::f()" << endl; }
    virtualvoid g() { cout << "Base2::g()" << endl; }
    virtualvoid h() { cout << "Base2::h()" << endl; }
};
 
classBase3 {
public:
    intibase3;
    Base3():ibase3(30) {}
    virtualvoid f() { cout << "Base3::f()" << endl; }
    virtualvoid g() { cout << "Base3::g()" << endl; }
    virtualvoid h() { cout << "Base3::h()" << endl; }
};
 
classDerive : publicBase1, publicBase2, publicBase3 {
public:
    intiderive;
    Derive():iderive(100) {}
    virtualvoid f() { cout << "Derive::f()" << endl; }
    virtualvoid g1() { cout << "Derive::g1()" << endl; }
};

我们通过下面的程序来查看子类实例的内存布局：下面程序中，注意我使用了一个s变量，其中用到了sizof(Base)来找下一个类的偏移量。（因为我声明的是int成员，所以是4个字节，所以没有对齐问题。关于内存的对齐问题，大家可以自行试验，我在这里就不多说了）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
typedefvoid(*Fun)(void);
 
Derive d;
 
int** pVtab = (int**)&d;
 
cout <<"[0] Base1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout <<"     [0] ";
pFun();
 
pFun = (Fun)pVtab[0][1];
cout <<"     [1] ";pFun();
 
pFun = (Fun)pVtab[0][2];
cout <<"     [2] ";pFun();
 
pFun = (Fun)pVtab[0][3];
cout <<"     [3] "; pFun();
 
pFun = (Fun)pVtab[0][4];
cout <<"     [4] "; cout<<pFun<<endl;
 
cout <<"[1] Base1.ibase1 = " << (int)pVtab[1] << endl;
 
ints = sizeof(Base1)/4;
 
cout <<"[" << s << "] Base2::_vptr->"<<endl;
pFun = (Fun)pVtab[s][0];
cout <<"     [0] "; pFun();
 
Fun = (Fun)pVtab[s][1];
cout <<"     [1] "; pFun();
 
pFun = (Fun)pVtab[s][2];
cout <<"     [2] "; pFun();
 
pFun = (Fun)pVtab[s][3];
out <<"     [3] ";
cout<<pFun<<endl;
 
cout <<"["<< s+1 <<"] Base2.ibase2 = "<< (int)pVtab[s+1] << endl;
 
s = s +sizeof(Base2)/4;
 
cout <<"[" << s << "] Base3::_vptr->"<<endl;
pFun = (Fun)pVtab[s][0];
cout <<"     [0] "; pFun();
 
pFun = (Fun)pVtab[s][1];
cout <<"     [1] "; pFun();
 
pFun = (Fun)pVtab[s][2];
cout <<"     [2] "; pFun();
 
pFun = (Fun)pVtab[s][3];
cout <<"     [3] ";
cout<<pFun<<endl;
 
s++;
cout <<"["<< s <<"] Base3.ibase3 = "<< (int)pVtab[s] << endl;
s++;
cout <<"["<< s <<"] Derive.iderive = "<< (int)pVtab[s] << endl;

其运行结果如下所示：（在VC++ 2003和G++ 3.4.4下）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
[0] Base1::_vptr->
     [0] Derive::f()
     [1] Base1::g()
     [2] Base1::h()
     [3] Driver::g1()
     [4] 00000000      <== 注意：在GCC下，这里是1
[1] Base1.ibase1 = 10
[2] Base2::_vptr->
     [0] Derive::f()
     [1] Base2::g()
     [2] Base2::h()
     [3] 00000000      <== 注意：在GCC下，这里是1
[3] Base2.ibase2 = 20
[4] Base3::_vptr->
     [0] Derive::f()
     [1] Base3::g()
     [2] Base3::h()
     [3] 00000000
[5] Base3.ibase3 = 30
[6] Derive.iderive = 100

使用图片表示是下面这个样子：

04

我们可以看到：

1）  每个父类都有自己的虚表。

2）  子类的成员函数被放到了第一个父类的表中。

3）  内存布局中，其父类布局依次按声明顺序排列。

4）  每个父类的虚表中的f()函数都被overwrite成了子类的f()。这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

重复继承

下面我们再来看看，发生重复继承的情况。所谓重复继承，也就是某个基类被间接地重复继承了多次。

下图是一个继承图，我们重载了父类的f()函数。

05

其类继承的源代码如下所示。其中，每个类都有两个变量，一个是整形（4字节），一个是字符（1字节），而且还有自己的虚函数，自己overwrite父类的虚函数。如子类D中，f()覆盖了超类的函数， f1() 和f2() 覆盖了其父类的虚函数，Df()为自己的虚函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
classB
{
    public:
        intib;
        charcb;
    public:
        B():ib(0),cb('B') {}
 
        virtualvoid f() { cout << "B::f()" << endl;}
        virtualvoid Bf() { cout << "B::Bf()" << endl;}
};
classB1 :  publicB
{
    public:
        intib1;
        charcb1;
    public:
        B1():ib1(11),cb1('1') {}
 
        virtualvoid f() { cout << "B1::f()" << endl;}
        virtualvoid f1() { cout << "B1::f1()" << endl;}
        virtualvoid Bf1() { cout << "B1::Bf1()" << endl;}
 
};
classB2:  publicB
{
    public:
        intib2;
        charcb2;
    public:
        B2():ib2(12),cb2('2') {}
 
        virtualvoid f() { cout << "B2::f()" << endl;}
        virtualvoid f2() { cout << "B2::f2()" << endl;}
        virtualvoid Bf2() { cout << "B2::Bf2()" << endl;}
 
};
 
classD : publicB1, publicB2
{
    public:
        intid;
        charcd;
    public:
        D():id(100),cd('D') {}
 
        virtualvoid f() { cout << "D::f()" << endl;}
        virtualvoid f1() { cout << "D::f1()" << endl;}
        virtualvoid f2() { cout << "D::f2()" << endl;}
        virtualvoid Df() { cout << "D::Df()" << endl;}
 
};

我们用来存取子类内存布局的代码如下所示：（在VC++ 2003和G++ 3.4.4下）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
typedefvoid(*Fun)(void);
int** pVtab = NULL;
Fun pFun = NULL;
 
D d;
pVtab = (int**)&d;
cout <<"[0] D::B1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout <<"     [0] ";    pFun();
pFun = (Fun)pVtab[0][1];
cout <<"     [1] ";    pFun();
pFun = (Fun)pVtab[0][2];
cout <<"     [2] ";    pFun();
pFun = (Fun)pVtab[0][3];
cout <<"     [3] ";    pFun();
pFun = (Fun)pVtab[0][4];
cout <<"     [4] ";    pFun();
pFun = (Fun)pVtab[0][5];
cout <<"     [5] 0x" << pFun << endl;
 
cout <<"[1] B::ib = " << (int)pVtab[1] << endl;
cout <<"[2] B::cb = " << (char)pVtab[2] << endl;
cout <<"[3] B1::ib1 = " << (int)pVtab[3] << endl;
cout <<"[4] B1::cb1 = " << (char)pVtab[4] << endl;
 
cout <<"[5] D::B2::_vptr->" << endl;
pFun = (Fun)pVtab[5][0];
cout <<"     [0] ";    pFun();
pFun = (Fun)pVtab[5][1];
cout <<"     [1] ";    pFun();
pFun = (Fun)pVtab[5][2];
cout <<"     [2] ";    pFun();
pFun = (Fun)pVtab[5][3];
cout <<"     [3] ";    pFun();
pFun = (Fun)pVtab[5][4];
cout <<"     [4] 0x" << pFun << endl;
 
cout <<"[6] B::ib = " << (int)pVtab[6] << endl;
cout <<"[7] B::cb = " << (char)pVtab[7] << endl;
cout <<"[8] B2::ib2 = " << (int)pVtab[8] << endl;
cout <<"[9] B2::cb2 = " << (char)pVtab[9] << endl;
 
cout <<"[10] D::id = " << (int)pVtab[10] << endl;
cout <<"[11] D::cd = " << (char)pVtab[11] << endl;

程序运行结果如下：

06

下面是对于子类实例中的虚函数表的图：

06

我们可以看见，最顶端的父类B其成员变量存在于B1和B2中，并被D给继承下去了。而在D中，其有B1和B2的实例，于是B的成员在D的实例中存在两份，一份是B1继承而来的，另一份是B2继承而来的。所以，如果我们使用以下语句，则会产生二义性编译错误：

D d;
d.ib = 0; //二义性错误
d.B1::ib = 1; //正确
d.B2::ib = 2; //正确

注意，上面例程中的最后两条语句存取的是两个变量。虽然我们消除了二义性的编译错误，但B类在D中还是有两个实例，这种继承造成了数据的重复，我们叫这种继承为重复继承。重复的基类数据成员可能并不是我们想要的。所以，C++引入了虚基类的概念。

钻石型多重虚拟继承

虚拟继承的出现就是为了解决重复继承中多个间接父类的问题的。钻石型的结构是其最经典的结构。也是我们在这里要讨论的结构：

07

上述的“重复继承”只需要把B1和B2继承B的语法中加上virtual 关键，就成了虚拟继承，其继承图如下所示：

上图和前面的“重复继承”中的类的内部数据和接口都是完全一样的，只是我们采用了虚拟继承：其省略后的源码如下所示：

1
2
3
4
classB {……};
classB1 : virtualpublic B{……};
classB2: virtualpublic B{……};
classD : publicB1, publicB2{ …… };

在查看D之前，我们先看一看单一虚拟继承的情况。下面是一段在VC++2003下的测试程序：（因为VC++和GCC的内存而局上有一些细节上的不同，所以这里只给出VC++的程序，GCC下的程序大家可以根据我给出的程序自己仿照着写一个去试一试）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
int** pVtab = NULL;
Fun pFun = NULL;
 
B1 bb1;
 
pVtab = (int**)&bb1;
cout <<"[0] B1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout <<"     [0] ";
pFun();//B1::f1();
cout <<"     [1] ";
pFun = (Fun)pVtab[0][1];
pFun();//B1::bf1();
cout <<"     [2] ";
cout << pVtab[0][2] << endl;
 
cout <<"[1] = 0x";
cout << (int*)*((int*)(&bb1)+1) <<endl; //B1::ib1
cout <<"[2] B1::ib1 = ";
cout << (int)*((int*)(&bb1)+2) <<endl; //B1::ib1
cout <<"[3] B1::cb1 = ";
cout << (char)*((int*)(&bb1)+3) << endl; //B1::cb1
 
cout <<"[4] = 0x";
cout << (int*)*((int*)(&bb1)+4) << endl; //NULL
 
cout <<"[5] B::_vptr->" << endl;
pFun = (Fun)pVtab[5][0];
cout <<"     [0] ";
pFun();//B1::f();
pFun = (Fun)pVtab[5][1];
cout <<"     [1] ";
pFun();//B::Bf();
cout <<"     [2] ";
cout <<"0x" << (Fun)pVtab[5][2] << endl;
 
cout <<"[6] B::ib = ";
cout << (int)*((int*)(&bb1)+6) <<endl; //B::ib
cout <<"[7] B::cb = ";

其运行结果如下（我结出了GCC的和VC++2003的对比）：

070

这里，大家可以自己对比一下。关于细节上，我会在后面一并再说。

下面的测试程序是看子类D的内存布局，同样是VC++ 2003的（因为VC++和GCC的内存布局上有一些细节上的不同，而VC++的相对要清楚很多，所以这里只给出VC++的程序，GCC下的程序大家可以根据我给出的程序自己仿照着写一个去试一试）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
D d;
 
pVtab = (int**)&d;
cout <<"[0] D::B1::_vptr->" << endl;
pFun = (Fun)pVtab[0][0];
cout <<"     [0] ";    pFun();//D::f1();
pFun = (Fun)pVtab[0][1];
cout <<"     [1] ";    pFun();//B1::Bf1();
pFun = (Fun)pVtab[0][2];
cout <<"     [2] ";    pFun();//D::Df();
pFun = (Fun)pVtab[0][3];
cout <<"     [3] ";
cout << pFun << endl;
 
//cout << pVtab[4][2] << endl;
cout <<"[1] = 0x";
cout <<  (int*)((&dd)+1) <<endl;//????
 
cout <<"[2] B1::ib1 = ";
cout << *((int*)(&dd)+2) <<endl;//B1::ib1
cout <<"[3] B1::cb1 = ";
cout << (char)*((int*)(&dd)+3) << endl; //B1::cb1
 
//---------------------
cout <<"[4] D::B2::_vptr->" << endl;
pFun = (Fun)pVtab[4][0];
cout <<"     [0] ";    pFun();//D::f2();
pFun = (Fun)pVtab[4][1];
cout <<"     [1] ";    pFun();//B2::Bf2();
pFun = (Fun)pVtab[4][2];
cout <<"     [2] ";
cout << pFun << endl;
 
cout <<"[5] = 0x";
cout << *((int*)(&dd)+5) << endl;// ???
 
cout <<"[6] B2::ib2 = ";
cout << (int)*((int*)(&dd)+6) <<endl; //B2::ib2
cout <<"[7] B2::cb2 = ";
cout << (char)*((int*)(&dd)+7) << endl; //B2::cb2
 
cout <<"[8] D::id = ";
cout << *((int*)(&dd)+8) << endl;//D::id
cout <<"[9] D::cd = ";
cout << (char)*((int*)(&dd)+9) << endl;//D::cd
 
cout <<"[10]  = 0x";
cout << (int*)*((int*)(&dd)+10) << endl;
//---------------------
cout <<"[11] D::B::_vptr->" << endl;
pFun = (Fun)pVtab[11][0];
cout <<"     [0] ";    pFun();//D::f();
pFun = (Fun)pVtab[11][1];
cout <<"     [1] ";    pFun();//B::Bf();
pFun = (Fun)pVtab[11][2];
cout <<"     [2] ";
cout << pFun << endl;
 
cout <<"[12] B::ib = ";
cout << *((int*)(&dd)+12) << endl;//B::ib
cout <<"[13] B::cb = ";
cout << (char)*((int*)(&dd)+13) <<endl;//B::cb

下面给出运行后的结果（分VC++和GCC两部份）

07

关于虚拟继承的运行结果我就不画图了（前面的作图已经让我产生了很严重的厌倦感，所以就偷个懒了，大家见谅了）

在上面的输出结果中，我用不同的颜色做了一些标明。我们可以看到如下的几点：

1）无论是GCC还是VC++，除了一些细节上的不同，其大体上的对象布局是一样的。也就是说，先是B1（黄色），然后是B2（绿色），接着是D（灰色），而B这个超类（青蓝色）的实例都放在最后的位置。

2）关于虚函数表，尤其是第一个虚表，GCC和VC++有很重大的不一样。但仔细看下来，还是VC++的虚表比较清晰和有逻辑性。

3）VC++和GCC都把B这个超类放到了最后，而VC++有一个NULL分隔符把B和B1和B2的布局分开。GCC则没有。

4）VC++中的内存布局有两个地址我有些不是很明白，在其中我用红色标出了。取其内容是-4。接道理来说，这个指针应该是指向B类实例的内存地址（这个做法就是为了保证重复的父类只有一个实例的技术）。但取值后却不是。这点我目前还并不太清楚，还向大家请教。

5）GCC的内存布局中在B1和B2中则没有指向B的指针。这点可以理解，编译器可以通过计算B1和B2的size而得出B的偏移量。

结束语

C++这门语言是一门比较复杂的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要我们去了解他后面的内存对象。这样我们才能真正的了解C++，从而能够更好的使用C++这门最难的编程语言。

（全文完）

（转载本站文章请注明作者和出处 酷 壳 – CoolShell.cn ，请勿用于任何商业用途）

0 0
淘宝买家好评率99% 淘宝买家好评率99%
原创粉丝点击
热门IT博客
网络直播的法律问题网络直播的法律问题
mac查看路径命令mac查看路径命令
单片机最小系统pcb
java异步发送http请求
招聘数据公式
优化发展环境建议
淘宝商品素材
dnf登陆网络连接中断
淘宝怎么看上次登录
达人如何挂淘宝
特效摄影软件下载
松下触摸屏软件
明星真人更好看 知乎
mac 10.12 刷新dns
mac apache安装目录
长筒运动袜 知乎
linux 安装anaconda2
凯云软件
unity3d 自带寻路算法
匿名发短信软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 iphone4s铃声制作 iphone5s怎么换铃声 电信手机铃声下载 iphone默认铃声 iphone怎么删除铃声 你那么爱他 铃声 itunes设置铃声 手机铃声在线下载 手机铃声设置下载 说爱我铃声 手机铃声下载套马杆 吹石玲奈 玲奈 能年玲奈 葵玲奈 松井玲奈 南条玲奈 高山玲奈 坂口玲奈 中山玲奈 绪方绘玲奈 相泽玲奈 佐木玲奈 佐佐木玲奈 久保田玲奈 三杉玲奈 光咲玲奈 吹石玲奈在线 吹石玲奈在线播放 吹石玲奈中文字幕 女囚07号玲奈 玲木uy125 菱木汽车 suzuki suzukl 凌木 suzuk 鈴木 铃木汽车怎么样 铃木轿车 铃木超级维特拉

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里