安科网

一文详解C++类的内存布局和虚函数底层实现机制

tangjikede

tangjikede

2020-04-30

关注 关注
目录

VS2015 查看内存布局

1 打开VS，创建一个项目， 项目 --> 属性--> C/C++ --> 命令行
2 添加可选项 /d1reportSingleClassLayout
3 运行程序
4 调出输出窗口：Alt+12，下拉输出来源，选择生成顺序。
一文详解C++类的内存布局和虚函数底层实现机制

1 空类

class C
{
public:
	C() { cout << " C()" << endl; };
	~C() { cout << " ~C()" << endl; };
};

内存布局：占据1个字节。

1>  class C	size(1):
1>  	+---
1>  	+---
1>

为什么空类大小为1字节：因为c++有规定，任何不同的对象都应该有不同的地址。空类虽然没有内容，但是仍旧需要分配地址，表明有这个对象的存在，另外所占字节大小与编译器有关。 另外说明添加了构造和析构函数，说明类的非虚函数不占用类对象的内存（函数编译后形成二进制文件放在内存中的代码段区）

2 普通类

class A
{
public:
	int a;
	char b;
	void func() { cout << "A func()" << endl; }
};

内存布局：占据8个字节，（四字节对齐，所以需要八个字节），如下所示：

1>  class A	size(8):
1>  	+---
1>   0	| a
1>   4	| b
1>    	| <alignment member> (size=3)
1>  	+---

3 虚函数的类

class A
{
public:
	int a;
	char b;
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
	virtual void Afunc2() { cout << "virtual A func2()" << endl; }
};

内存布局：占据12个字节，多了一个虚函数指针，如下所示： 虚函数指针指向一张虚表，虚表里面存储了虚函数Afunc1()，Afunc2()的入口地址。

1>  class A	size(12):
1>  	+---
1>   0	| {vfptr}
1>   4	| a
1>   8	| b
1>    	| <alignment member> (size=3)
1>  	+---

虚表

1>  A:::
1>  	| &A_meta
1>  	|  0
1>   0	| &A::Afunc1
1>   1	| &A::Afunc2

4 不含虚函数的普通继承

4.1 单继承的类

B->A

class A
{
public:
	int a;
	char b;
};

class B:public A
{
public:
	int _c;
};

子类B的内存布局，先是继承基类A的属性，然后再自己的属性。

1>  class A	size(8):
1>  	+---
1>   0	| a
1>   4	| b
1>    	| <alignment member> (size=3)
1>  	+---
1>
1>  class B	size(12):
1>  	+---
1>   0	| +--- (base class A)
1>   0	| | a
1>   4	| | b
1>    	| | <alignment member> (size=3)
1>  	| +---
1>   8	| _c
1>  	+---
1>

4.2 两个继承类

C->A,B->A

C 同上B

1>  class C	size(12):
1>  	+---
1>   0	| +--- (base class A)
1>   0	| | a
1>   4	| | b
1>    	| | <alignment member> (size=3)
1>  	| +---
1>   8	| _c
1>    	| <alignment member> (size=3)
1>  	+---

4.3 菱形继承类

D->C,D->B, C->A,B->A

ABC同上，我们看到D类的内存大小不是简单的a,b,_b,_c,d所占的20个字节，而是28字节，爷爷类的ab，保存了两份，因此访问ab时会存在二义性，因此有两个解决方案：1 指定所属作用域，说明是B类的还是C类的。2采用虚继承。另外内存布局遵循前面的规则：继承的属性放在最前面，自己多的属性放在最后面。

1>  class D	size(28):
1>  	+---
1>   0	| +--- (base class B)
1>   0	| | +--- (base class A)
1>   0	| | | a
1>   4	| | | b
1>    	| | | <alignment member> (size=3)
1>  	| | +---
1>   8	| | _b
1>  	| +---
1>  12	| +--- (base class C)
1>  12	| | +--- (base class A)
1>  12	| | | a
1>  16	| | | b
1>    	| | | <alignment member> (size=3)
1>  	| | +---
1>  20	| | _c
1>    	| | <alignment member> (size=3)
1>  	| +---
1>  24	| d
1>  	+---

5 含虚函数的普通继承

5.1.1 单继承，子类不含虚函数

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
};

1
class B:public A
{
public:
	int _b;
	virtual void Afunc1() { cout << "virtual B func1()" << endl; }
};
1>  class A	size(12):
1>  	+---
1>   0	| {vfptr}
1>   4	| a
1>   8	| b
1>    	| <alignment member> (size=3)
1>  	+---

//A类的虚表：存的A的虚函数地址
1>  A:::
1>  	| &A_meta
1>  	|  0
1>   0	| &A::Afunc1
1>
1>  A::Afunc1 this adjustor: 0
1>
1>  class std::is_error_code_enum<char const *>	size(1):
1>  	+---
1>   0	| +--- (base class std::integral_constant<bool,0>)
1>  	| +---
1>  	+---
1>
1>  class B	size(16):
1>  	+---
1>   0	| +--- (base class A)
1>   0	| | {vfptr}
1>   4	| | a
1>   8	| | b
1>    	| | <alignment member> (size=3)
1>  	| +---
1>  12	| _b
1>  	+---

//B类的虚表：存的是B类的虚函数地址，因此同一个函数Afunc1，由于虚表的因故，地址不同，实现了多态性。
1>  B:::
1>  	| &B_meta
1>  	|  0
1>   0	| &B::Afunc1

到此我们可以发现，虚函数指针的位置总是放在最前面的，设想如果B也有自己的虚函数，内存布局又是怎么样的呢？

5.1.2 单继承，子类含虚函数

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
};

1
class B:public A
{
public:
	int _b;
	virtual void Afunc1() { cout << "virtual B func1()" << endl; }
	virtual void Bfunc() { cout << "virtual B func()" << endl; }
};

A类的内存布局同上，但是B类的内存布局改变了，看一下和你想象的一样吗？ 仅在虚函数表里面也增加了Bfunc()这个虚函数的入口地址。

1>  class B	size(16):
1>  	+---
1>   0	| +--- (base class A)
1>   0	| | {vfptr}
1>   4	| | a
1>   8	| | b
1>    	| | <alignment member> (size=3)
1>  	| +---
1>  12	| _b
1>  	+---

//B类的虚表
1>  B:::
1>  	| &B_meta
1>  	|  0
1>   0	| &B::Afunc1
1>   1	| &B::Bfunc

5.2 多个继承

C->A,B->A

C的内存布局类似B；

5.3 菱形继承

D->C,D->B, C->A,B->A

ABC的内存布局同上，但是D的内存布局又是怎么样的呢？先想象一下。

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
};

class B:public A
{
public:
	int _b;
	virtual void Afunc1() { cout << "virtual B func1()" << endl; }
	virtual void Bfunc() { cout << "virtual B func()" << endl; }
};


class C:public A
{
public:
	char _c;
	virtual void Afunc1() { cout << "virtual C func1()" << endl; }
	virtual void Cfunc() { cout << "virtual C func()" << endl; }
};


class D : public B, public C
{
public:
	int d;
	virtual void Dfunc1() { cout << "virtual C func1()" << endl; }
	virtual void Dfunc() { cout << "virtual C func()" << endl; }
};

内存布局：相比没有虚函数的内存布局，仅仅多了两个虚函数指针。

1>  class D	size(36):
1>  	+---
1>   0	| +--- (base class B)
1>   0	| | +--- (base class A)
1>   0	| | | {vfptr}
1>   4	| | | a
1>   8	| | | b
1>    	| | | <alignment member> (size=3)
1>  	| | +---
1>  12	| | _b
1>  	| +---
1>  16	| +--- (base class C)
1>  16	| | +--- (base class A)
1>  16	| | | {vfptr}
1>  20	| | | a
1>  24	| | | b
1>    	| | | <alignment member> (size=3)
1>  	| | +---
1>  28	| | _c
1>    	| | <alignment member> (size=3)
1>  	| +---
1>  32	| d
1>  	+---

虚函数表有两张，而且根据继承的顺序，表的虚函数地址也不一样，请仔细品。

1>  D::@:
1>  	| &D_meta
1>  	|  0
1>   0	| &D::Afunc1
1>   1	| &B::Bfunc
1>   2	| &D::Dfunc
1>
1>  D::@:
1>  	| -16
1>   0	| &thunk: this-=16; goto D::Afunc1
1>   1	| &C::Cfunc

从上面的菱形继承，我们发现，菱形继承存在二义性，而且内存布局有重复，空间消耗大，因此需要虚继承。

6 虚继承

6.1.1 基类不含虚函数，子类也不含虚函数的单虚继承

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
};

class B:virtual public A
{
public:
	int _b;
};

B的内存布局：1 多了一个虚基指针，放在了最前面，而且B的成员也放在了最前面，基类被放到了最后面，和非虚继承的内存布局形式完全相反。

1>  class B	size(16):
1>  	+---
1>   0	| {vbptr}
1>   4	| _b
1>  	+---
1>  	+--- (virtual base A)
1>   8	| a
1>  12	| b
1>    	| <alignment member> (size=3)
1>  	+---
1>

虚基表：虚基表里面存放了虚基类的入口地址： 从B类地址开始偏移8个字节就是虚基类的地址，结合内存布局看，容易理解。

1>  B:::
1>   0	| 0
1>   1	| 8 (Bd(B+0)A)

6.1.2 基类含有虚函数，子类不含虚函数的单虚继承

可以先想象一下，含有虚函数之后，内存布局会是怎样？根据虚函数的特性，会有一个虚函数指针和虚函数表，那虚函数指针又是放在内存的哪个地方呢？

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
};

class B:virtual public A
{
public:
	int _b;
	virtual void Afunc1() { cout << "virtual B func1()" << endl; }
};

没什么变化，仅仅是基类增加了一个虚函数指针，而继承类没有虚函数指针。

1>  class B	size(20):
1>  	+---
1>   0	| {vbptr}//虚基指针
1>   4	| _b
1>  	+---
1>  	+--- (virtual base A)
1>   8	| {vfptr}//虚函数指针
1>  12	| a
1>  16	| b
1>    	| <alignment member> (size=3)
1>  	+---

//虚基表
1>  B:::
1>   0	| 0
1>   1	| 8 (Bd(B+0)A)

//虚函数表
1>  B:::
1>  	| -8
1>   0	| &B::Afunc1
1>

6.1.3 基类含有虚函数，子类也含有虚函数的单虚继承

再子类也含有虚函数之后，内存布局又会是怎样？会像非虚继承那样，直接将自己的虚函数放入继承自基类的虚函数指针指向的虚函数表吗？

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
	//virtual void Afunc2() { cout << "virtual A func2()" << endl; }
};

class B:virtual public A
{
public:
	int _b;
	virtual void Afunc1() { cout << "virtual B func1()" << endl; }
	virtual void Bfunc() { cout << "virtual B func()" << endl; }
};

恐怕就不是了。

内存布局，此时子类拥有了自己独立的虚函数指针，并且放在了起始地址，有用两张虚表。

1>  class B	size(24):
1>  	+---
1>   0	| {vfptr}
1>   4	| {vbptr}
1>   8	| _b
1>  	+---
1>  	+--- (virtual base A)
1>  12	| {vfptr}
1>  16	| a
1>  20	| b
1>    	| <alignment member> (size=3)
1>  	+---

//存放B类独立的虚函数的虚函数表1
1>  B::@:
1>  	| &B_meta
1>  	|  0
1>   0	| &B::Bfunc
//虚基表
1>  B:::
1>   0	| -4
1>   1	| 8 (Bd(B+4)A)

//存放B类继承父类虚函数的虚函数表2
1>  B::@:
1>  	| -12
1>   0	| &B::Afunc1
1>

6.2.多继承

C->A,B->A

C的内存布局同单继承的B

6.3.1 不含虚函数的菱形继承

从上面虚继承内存布局形式来看，子类的属性会放在最前面，然后是继承类的属性，那么三层的菱形继承，内存布局会是先D,再B,C,最后A吗？

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
};

class B:virtual public A
{
public:
	int _b;
};

#if 1
class C:virtual public A
{
public:
	char _c;
};


class D : virtual public B, virtual public C
{
public:
	int d;
};
#endif

D的内存布局：em和想象的有一点相反，A类的属性被放在了BC之前。但是只保留了一份，不再是无虚继承时的两份，节约了空间，而且访问a,b不再二义性了， 而且存在三个虚基指针，显然也指向了三张虚基表

1>  class D	size(32):
1>  	+---
1>   0	| {vbptr}
1>   4	| d
1>  	+---
1>  	+--- (virtual base A)
1>   8	| a
1>  12	| b
1>    	| <alignment member> (size=3)
1>  	+---
1>  	+--- (virtual base B)
1>  16	| {vbptr}
1>  20	| _b
1>  	+---
1>  	+--- (virtual base C)
1>  24	| {vbptr}
1>  28	| _c
1>    	| <alignment member> (size=3)
1>  	+--

虚基表，基类内存布局更容易懂哦

//D的虚基指针
1>  D::@:
1>   0	| 0
1>   1	| 8 (Dd(D+0)A) //基类A的起始地址是D类起始偏移为8的地址
1>   2	| 16 (Dd(D+0)B)//基类B的起始地址是D类起始偏移为16的地址
1>   3	| 24 (Dd(D+0)C)//基类C的起始地址是D类起始偏移为24的地址

//B的虚基指针
1>  D::@:
1>   0	| 0
1>   1	| -8 (Dd(B+0)A)//基类A的起始地址是B的起始偏移为-8的地址，16-8=8

//C的虚基指针
1>  D::@:
1>   0	| 
1>   1	| -16 (Dd(C+0)A)//基类A的起始地址是C的起始偏移为-16的地址，24-16=8

6.3.1 基类含虚函数，中间类不含单独的虚函数的菱形继承

我们又可以合理推断了，根据6.1.2，如果自己没有单独的虚函数，自己是不存在单独虚函数指针的，直接继承了父类的虚函数指针，重写了所指向的虚函数表。因此内存布局中仍然只有一个虚函数指针，存放于基类A的地方。

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
};

class B:virtual public A
{
public:
	int _b;
};

#if 1
class C:virtual public A
{
public:
	char _c;
};


class D : virtual public B, virtual public C
{
public:
	int d;
};
#endif

内存布局

1>  class D	size(36):
1>  	+---
1>   0	| {vbptr}
1>   4	| d
1>  	+---
1>  	+--- (virtual base A)
1>   8	| {vfptr}
1>  12	| a
1>  16	| b
1>    	| <alignment member> (size=3)
1>  	+---
1>  	+--- (virtual base B)
1>  20	| {vbptr}
1>  24	| _b
1>  	+---
1>  	+--- (virtual base C)
1>  28	| {vbptr}
1>  32	| _c
1>    	| <alignment member> (size=3)
1>  	+---

虚基表和虚函数表

1>  D::@:
1>   0	| 0
1>   1	| 8 (Dd(D+0)A)
1>   2	| 20 (Dd(D+0)B)
1>   3	| 28 (Dd(D+0)C)
1>
1>  D:::
1>  	| -8
1>   0	| &D::Afunc1
1>
1>  D::@:
1>   0	| 0
1>   1	| -12 (Dd(B+0)A)
1>
1>  D::@:
1>   0	| 0
1>   1	| -20 (Dd(C+0)A)

6.3.1 基类含虚函数，中间类含单独虚函数，但自己不含虚函数的菱形继承

相信到这里，就很容易想到，D类的内存布局只会增加B,C类的虚函数指针，增加8个字节。

class A
{
public:
	int a;
	char b;
	void func(){ cout << "A func()" << endl; }
	virtual void Afunc1() { cout << "virtual A func1()" << endl; }
	//virtual void Afunc2() { cout << "virtual A func2()" << endl; }
};

class B:virtual public A
{
public:
	int _b;
	virtual void Afunc1() { cout << "virtual B func1()" << endl; }
	virtual void Bfunc() { cout << "virtual B func()" << endl; }
};

#if 1
class C:virtual public A
{
public:
	char _c;
	virtual void Afunc1() { cout << "virtual C func1()" << endl; }
	virtual void Cfunc() { cout << "virtual C func()" << endl; }
};


class D : virtual public B, virtual public C
{
public:
	int d;
	virtual void Afunc1() { cout << "virtual C func1()" << endl; }
	virtual void Bfunc() { cout << "virtual D func()" << endl; }
	virtual void Cfunc() { cout << "virtual D func()" << endl; }
};
#endif

内存布局

1>  class D	size(44):
1>  	+---
1>   0	| {vbptr}
1>   4	| d
1>  	+---
1>  	+--- (virtual base A)
1>   8	| {vfptr}
1>  12	| a
1>  16	| b
1>    	| <alignment member> (size=3)
1>  	+---
1>  	+--- (virtual base B)
1>  20	| {vfptr}
1>  24	| {vbptr}
1>  28	| _b
1>  	+---
1>  	+--- (virtual base C)
1>  32	| {vfptr}
1>  36	| {vbptr}
1>  40	| _c
1>    	| <alignment member> (size=3)
1>  	+---

虚基表和虚函数表

1>  D::@:
1>   0	| 0             //说明此虚基指针距离D的起始地址 的距离，为0，说明D类不含自己的虚函数
1>   1	| 8 (Dd(D+0)A)  //说明此虚基指针距离A的起始地址 的距离，为8
1>   2	| 20 (Dd(D+0)B)
1>   3	| 32 (Dd(D+0)C)
1>
1>  D::@:
1>  	| -8            //说明来自A的虚函数距离D的起始地址 的距离，为-8
1>   0	| &D::Afunc1    //说明此虚基指针指向的函数入口地址是D类重写的Afunc1
1>
1>  D::@:
1>  	| -20
1>   0	| &D::Bfunc
1>
1>  D::@:
1>   0	| -4            //说明B类的虚基指针距离B的起始地址 的距离，为-4，说明有虚函数指针。
1>   1	| -16 (Dd(B+4)A)//说明B类的虚基指针距离继承的A的起始地址 的距离，为-16
1>
1>  D::@:
1>  	| -32
1>   0	| &D::Cfunc
1>
1>  D::@:
1>   0	| -4
1>   1	| -28 (Dd(C+4)A)

6.3.2 基类含虚函数，中间类含单独虚函数，但自己含虚函数的菱形继承

这就不用多说了把，又会增加一个虚函数指针，增加4字节。

内存布局

1>  class D	size(48):
1>  	+---
1>   0	| {vfptr}
1>   4	| {vbptr}
1>   8	| d
1>  	+---
1>  	+--- (virtual base A)
1>  12	| {vfptr}
1>  16	| a
1>  20	| b
1>    	| <alignment member> (size=3)
1>  	+---
1>  	+--- (virtual base B)
1>  24	| {vfptr}
1>  28	| {vbptr}
1>  32	| _b
1>  	+---
1>  	+--- (virtual base C)
1>  36	| {vfptr}
1>  40	| {vbptr}
1>  44	| _c
1>    	| <alignment member> (size=3)
1>  	+---

虚函数表和虚基表

1>  D:::
1>  	| &D_meta
1>  	|  0
1>   0	| &D::Dfunc
1>
1>  D::@:
1>   0	| -4
1>   1	| 8 (Dd(D+4)A)
1>   2	| 20 (Dd(D+4)B)
1>   3	| 32 (Dd(D+4)C)
1>
1>  D::@:
1>  	| -12
1>   0	| &D::Afunc1
1>
1>  D::@:
1>  	| -24
1>   0	| &D::Bfunc
1>
1>  D::@:
1>   0	| -4
1>   1	| -16 (Dd(B+4)A)
1>
1>  D::@:
1>  	| -36
1>   0	| &D::Cfunc
1>
1>  D::@:
1>   0	| -4
1>   1	| -28 (Dd(C+4)A)

总结

虚基表

采用虚继承，继承类就会多一个虚基指针，指向虚基表，虚基表里面存放了基类的入口地址

虚基指针所指向的虚基表的内容：

  1. 虚基指针的第一条内容表示的是该虚基指针距离所在的子对象的首地址的偏移
  2. 虚基指针的第二条内容表示的是该虚基指针距离虚基类子对象的首地址的偏移

虚函数表

采用虚函数，继承类就会多一个虚函数指针，指向虚函数表，虚函数表里面存放了基类的入口地址
１.　每个基类都有自己的虚函数表
２.　派生类如果有自己的虚函数，会被加入到第一个虚函数表之中
３. 内存布局中，其基类的布局按照基类被声明时的顺序进行排列
４.　派生类会覆盖基类的虚函数，只有第一个虚函数表中存放的是真实的被覆盖的函数的地址；其它的虚函数表中存放的并不是真实的对应的虚函数的地址，而只是一条跳转指令

ul 虚函数 c++

tangjikede

tangjikede

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

编程语言TOP10！该如何选择适合自己的？

编程领域大约有700种代码语言。理解编程语言的重要性以及其如何影响需要执行的具体任务至关重要。一篇文章穷尽700 种语言不现实，也没有意义。因此，笔者挑选出了时下最热门的原因，在本文中一一分析其特征、优缺点和发展方向，并确定其是否有学习价值。根据设计，C

chensen 2020-11-14

选择困难终结者：不同问题之下的机器学习算法

刚开始学习数据科学时，笔者经常面临这样一个问题：遇到具体问题，选择何种算法才合适。也许你也和我一样，搜了很多有关机器学习算法的文章，会看到许多详细的描述，却并没有减少让抉择的难度。问题陈述2：深挖客户统计数据用以识别模式。问题陈述12：根据车辆特性预估车辆

lwnylslwnyls 2020-11-06

Dubbo中的时间轮(Time Wheel)算法应用

Netty、Quartz、Kafka 以及 Linux 都有定时任务功能。在任务量大、性能要求高的场景，为了将任务存取及取消操作时间复杂度降为 O，会采用时间轮算法。指针周期性跳动，跳动到一个槽位，就执行该槽位的定时任务。需要高效的定时器算法以减少总体中断

ATenhong 2020-10-15

前端一面基础知识 ⑥——性能优化、Web安全、Linux常用命令

④用户输入结束或暂停时，才会触发change事件，类似搜索框中输入信息停下来1秒后才会出现可能要搜索的内容。控制事件发生的频率，如控制为1秒发生一次，甚至1分钟发生一次。与服务端及网关控制的限流类似。防抖是触发间隔大于time触发，所以每次在小于间隔tim

yanzhelee 2020-10-13

Java程序员怎样打造高效率的开发环境

作为一名程序员，好的开发环境可以提升你的工作效率，事半功倍。那么一名Java程序员应该拥有什么样的开发工具呢。java程序员都知道，第一节课就会教你安装jdk。jdk是java开发工具包，包含了jvm虚拟机，你写的java代码就是通过jdk编译运行的。ja

佛系程序员J 2020-10-10

AI创业哪家强？6大选择给你方向

人工智能被认为是当代“最热门”的工作。根据《财富》杂志统计，雇佣AI专家的人数在过去4年里增长了74%，社会对人工智能专家的需求正以前所未有的速度增长。人工智能的子领域，如机器学习、深度学习、计算机视觉、统计学和自然语言处理，对这些领域专家的需求和空缺职位

guojin0 2020-10-08

如何使Java程序员拥有高效率的开发环境

作为一名程序员，好的开发环境可以提升你的工作效率，事半功倍。那么一名Java程序员应该拥有什么样的开发工具呢。java程序员都知道，第一节课就会教你安装jdk。jdk是java开发工具包，包含了jvm虚拟机，你写的java代码就是通过jdk编译运行的。ja

佛系程序员J 2020-10-08

《Machine Learning Yearning》总结

在训练数据不足的情况下，你可以尝试引入额外的训练数据，只要它们能提供对训练有价值的信息。如果模型在引入额外数据的训练数据集和引入额外数据的测试数据集中都表现的很好，但在不引入额外数据的测试数据集中表现糟糕，那么这种情况称为：数据不匹配。此时可以考虑在目标函

bluewelkin 2020-09-16

移动APP开发有哪些框架？

现在比较流行的移动APP开发框架有以下六种：网页、混合、不仅、原生、桥接、自绘。前三种体验与Web的体验相似，后三种与原生APP的体验相似。这六种框架形式，都有自己适用的范围。无所谓好坏，适用就是好。自绘应用适用于游戏和有特殊效果的应用，最大的好处是没有平

wwzaqw 2020-09-04

那些与健康运营密切相关的衡量标准

下面，我们将和您在健康运营的过程中，企业所面临的各项挑战、痛点、以及需要衡量的各项关键指标。在此基础上，我们会进一步给出一个标准成熟度模型，以及对应的实践案例。同时，由于不同团队各司其职、各自为政，因此数据孤岛的现象在企业中屡见不鲜。对应的KPI包括：了解

zhongdaowendao 2020-09-02

mysql分库分表篇

当表的数量达到几百上千张表时， 众多的业务模块都访问这个数据库， 压力会非常的大， 考虑对其进行分库。支持MySQL、Oracle、DB2、SQL Server、PostgreSQL等DB的常见SQL语法。基于心跳的自动故障切换，支持读写分离，支持MySQ

favouriter 2020-08-18

怎么才能隐藏的IP？打造超强IP池项目，让你自己都忘记原本的IP

随着大型网站反扒机制的增强，更改IP登陆已经成为一种最高效的方式，为此打造一款超强IP池项目，采用最新最快的Python技术——异步。编写了一个免费的异步爬虫代理池，以 Python asyncio 为基础，充分利用 Python 的异步性能，异步处理比同

奎因amp华洛 2020-08-15

移动端跨平台技术之下的变与不变

跨 Native 与 Web：商品详情页等要求有一套功能差不多的 Web 页能够在端外访问，需要跨 Native App 与 Web. 容器化 Native 跨端：将 Native App 改造成标准化的容器，进而允许一套代码跨多端标准容器运行，如 Rea

一青年 2020-08-13

数据科学家的工具列表：提高生产效率的工具包

本文转载自公众号“读芯术”。新的东西令人激动，新的框架、新的仪器、新的工具，都会让生活变得更轻松。保持更新很难，我们需要花更多的时间在其上。当然，我们并不是要一直更新到最新的发现，它可能是某个特定库的新的小版本，也可能是处于兴趣或是工作需要而寻找。应用tf

千锋 2020-08-10

JVM

新生代，老年代，永久代/元空间。晋升机制根据对象存活时间。jmap -dump:file=[文件名] pid：将进程运行的状况dump到文件中,文件通过fastThread线上工具分析。

nangongyanya 2020-08-09

MyBatis接口代理方式实现Dao层

Mybatis中namespace用于绑定dao接口，dao接口的方法对应mapper中的sql语名。--默认名为类名首字母小写-->. --environment配置数据库环境 id 属性唯一标识 -->. --dataSource数据源信息

dongxurr 2020-08-08

Python名称空间与作用域

在python解释器开始执行, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来,当遇到函数定义的时候, 解释器只是把函数名读入内存, 并检查语法是否正确，表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关

明天你好 2020-08-03

python List 和Numpy array 区别

一个numpy array 是内存中一个连续块，并且array里的元素都是同一类。　　 list完全不同，它的每个元素其实是一个地址的引用，这个地址又指向了另一个元素，这些元素的在内存里不一定是连续的。所以list其实是只 能塞进地址的“数组”

kyelu 2020-08-03

Redis 内存压缩原理

Redis 无疑是一个大量消耗内存的数据库，因此 Redis 引入了一些设计巧妙的数据结构进行内存压缩来减轻负担。ziplist、quicklist 以及 intset 是其中最常用最重要的压缩存储结构。Redis对外提供了 string, list, h

Ashes 2020-08-03

数据准备基本流程 数据规范化的几种方法 利用SciKit库进行数据变换

就是将多个数据源合并存放在一个数据仓库中。与主流的ETL的区别是：在抽取后首先将结果写入目的地，然后通过数据库的聚合分析能力或外部计算框架来完成转换。通过以下方法针对算法对数据进行变换。数据平滑---去除数据中的噪声，将连续数据离散化。

wndong 2020-08-01
tangjikede

tangjikede

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号