C++基础学习笔记----第十一课（类的静态成员、对象模型初步认识）
主要讲解了静态成员的本质以及静态成员和普通成员的差别，通过对象模型的基本知识体现了静态成员函数和普通函数的差别。
类的静态成员
普通成员变量
普通成员变量受到public和private两个关键字的限制，可以通过类的对象名访问具有public的普通成员变量，
普通的成员变量不能够在类的对象之间共享。
静态成员变量
1.在C++中可以定义静态成员变量和静态成员函数，
静态成员属于整个类所有，不需要任何依赖对象。
可以通过类名直接访问public静态成员，可以通过对象名访问public静态成员。
静态成员函数可以直接访问静态成员变量。
2.
普通成员变量依附于具体的对象存在，对象被销毁普通的成员变量就被销毁。在某一个对象诞生的时候静态成员变量不会被创建，同样某一个类被销毁静态成员变量也不会被销毁。它随着类的存在而存在，类是在程序开始运行的时候就存在，所以静态成员变量是随着程序的运行而存在的。
3.静态成员变量不依附于对象的存在而存在，所以
静态成员的空间分配需要在类的外部，也就是在
全局数据区对静态成员变量进行内存的分配。
如果静态成员变量没有被赋予初值，那么静态成员变量和普通的静态变量一样
默认的初始值为0。
4.
静态成员变量在类的内部进行声明，在类的外部进行定义并分配空间。
5.语法规则：在定义时直接通过static关键字进行修饰。语法规则：Type Class Name ::VarName，同时
在类外定义静态成员需要在类的初始化之后，否则编译器无法找到属于这个类的静态成员。
静态成员函数
1.
静态成员函数是属于类所有的，并不是依附于某一个对象而存在，调用静态成员函数直接通过类名调用即可。
2.
静态成员函数可以通过类的对象来进行调用。
基本例程如下所示：
#include <stdio.h>
//int A::ai; 类的静态变量定义在类的前面将会报错
class A
{
private:
static int ai;
public:
static int getai()
{
return ai;
}
static int setai(int i)
{
ai = i;
return 0;
}
void print()
{
printf("ai = %d\n", ai);
}
};
int A::ai = 0;
int main()
{
/*不需要建立类的对象就可以调用类的静态成员函数*/
A::setai(9);
printf("ai = %d\n",A::getai());
/*print函数是类的普通成员函数，需要建立类的对象来完成调用*/
A a;
a.print();
A a1;
/*可以通过类的对象来抵用类的静态成员函数*/
a1.setai(6);
printf("ai = %d\n",a1.getai());
//a1.ai = 8; 虽然可以通过类的对象来改变静态成员变量的值，但是这里的静态成员变量仍然受到public和private属性的限制。
return 0;
}
C++不同角度上的类的静态成员
命名空间的角度：
通过上面的例程，可发现在类的外部定义类的静态成员变量的代码：
int A::ai = 0;这里的A::ai类似于命名空间，这里的 静态成员变量，只是这个类的范围的命名空间的全局变量。同样，类的静态成员函数就是这个类的命名空间的全局函数。
不同的地方是，类可以对静态成员变量进行访问权限的限制（使用public和private关键字），而命名空间不可以。
面向对象的角度：
类的静态成员属于类的概念本身，类的所有对象共享相同的静态成员。
类的静态成员的应用
类的静态成员依赖于类而存在，所以可以通过静态成员变量来统计程序中正在运行的类。
#include <stdio.h>
class A
{
private:
static int ai;
public:
static int getai()
{
return ai;
}
A()
{
ai++;
}
~A()
{
ai--;
}
};
/*如果不给静态成员变量赋初值，那么ai的默认值为0*/
int A::ai;
void run()
{
A a[100];
/*
这里定义了一个100A类的数组，所以通过调用静态成员函数ai再次进行100次自加，打印102
*/
printf("%d\n",A::getai());
/*run()函数在调用结束后100个A类的数组自动被销毁，调用析构函数，ai自减100*/
}
int main()
{
A a1;
A a2;
/*定义两个A类的对象后，ai通过定义的默认构造函数自加两次，这里打印2*/
printf("%d\n",A::getai());
run();
/*run函数调用结束返回，这个时候静态成员变量的值是2*/
printf("%d\n",A::getai());
return 0;
}
C++对象模型初探
普通成员变量和struct变量的存储
1.C++中的成员变量和成员函数是分开存储的。成员变量分为普通成员变量和静态成员变量， 普通的成员变量存储在对象中， 与struct变量具有相同的内存布局和字节对齐方式。静态成员变量存储在程序的全局数据区。
2.
成员函数存储在代码段中，无论是静态成员函数还是普通的成员函数。
例程：
#include <stdio.h>
/*两种方式在C++定义类的差别在于：A默认的成员是private，B默认的成员是public*/
class A
{
int i;
int j;
short a;
char b;
};
struct B
{
int i;
int j;
short a;
char b;
};
class C
{
private:
int i;
int j;
short a;
char b;
/*静态成员变量占用的全局数据区的内存空间*/
static int h;
public:
/*成员函数占用的代码段的内存空间*/
C()
{
printf("abc\n");
}
int print()
{
i = 1;
return 0;
}
};
int C::h = 0;
int main()
{
/*根据C语言中的内存对齐，A和B结构体占用的内存空间都为12个字节*/
printf ("%d\n",sizeof(A));
printf ("%d\n",sizeof(B));
/*程序的打印结果和结构体A和B的打印结果相同*/
printf ("%d\n",sizeof(B));
return 0;
}
C++中的对象模型
面向对象理论到计算机程序的转化基本程序（这里只是一个简单的例子，具体的实现还是C++编译器内部的实现），如下图所示：
静态成员函数和普通成员函数的差别
1.
普通成员函数不包含指向具体对象的指针，普通成员函数包含一个指向具体对象的指针。
2.
C++中类的普通成员函数都隐式包含一个指向当前对象的this指针。
3.
静态成员函数没有this指针，普通成员函数有。普通成员函数通过C++默认的关键字this将当前成员函数的地址提供出来。
例程如下：
#include <stdio.h>
class A
{
private:
int a;
int b;
int c;
static int d;
public:
A(int a, int b, int c)
{
/*如果这里这样定义将会造成二义性，程序最后将无法确定怎么进行赋值,所以这里编译报错*/
/*this->a = a;
this->b = b;
this->c = c;*/
/*这里的this是C++中的关键字，这里的this指针指向当前的对象所以this->a是指向这个类的成员变量a*/
this->a = a;
this->b = b;
this->c = c;
}
void print()
{
/*打印各个变量的值和变量地址*/
printf("a = %d, &a = %p\n",a,&a);
printf("b = %d, &b = %p\n",b,&b);
printf("c = %d, &c = %p\n",c,&c);
/*通过地址打印可以看出d的地址和变量a,b,c的地址并不是连续的，可以进一步证明静态成员变量的内存分配来自全局数据区*/
printf ("d = %d, &c = %p\n",d,&d);
/*这里打印this指针的地址,也是具体的对象的地址，随着对象的创建而this指针式不同的*/
printf("%p\n",this);
}
};
int A::d = 0;
int main()
{
A g = A(2,3,4);
g.print();
printf ("&g = %p\n", &g);
A g2 = A(7,8,9);
g2.print();
printf ("&g = %p\n", &g2);
return 0;
}