静态成员函数：

静态成员函数由于属于整个类，所以它不能访问某个对象的成员变量，因为它没有指向该对象的this指针，但是它可以访问该类的静态成员变量。
	
要尽量类成员名限定来访问静态成员函数，尽量不要使用对象来访问。
	
静态成员函数可以被继承，基类和派生类都可以共享该静态成员函数。
	
类中的任何成员函数都可以访问静态成员函数。
	
静态成员函数不能是虚函数。
 

静态成员函数的定义是在一般函数定义前加上static关键字
调用静态成员函数的格式如下：
        类名：：静态成员函数名（参数表）
#include<iostream>
using namespace std;

int s=0;

class MyClass
{
private:
	static int n; //声明数据成员
public:
	MyClass(int a){n=a;}
	static void add() {s+=n;}
};

int MyClass::n=0; //静态数据成员初始化

int main()
{
	MyClass a(2);
	MyClass::add();
	cout<<"s= "<<s<<endl;
	MyClass b(5);
	MyClass::add();
	cout<<"s= "<<s<<endl;
	return 0;
}

C++静态成员函数访问非静态成员的几种方法
文章目录
C++静态成员函数访问非静态成员的几种方法
方法一：
方法二：
方法三：
方法四：

方法一：
有一个很取巧的办法，就是在静态函数的形参表里加上实例的地址，也就是
class A
{
public:
    static void test(A *a)
    {
        a->m_a += 1;
    }
    void hello()
    {
    }
private:
    static int m_staticA;
    int m_a
};

这样在你回调函数的时候，你可以通过这个来让本身不能访问成员非静态变量的静态函数来访问非静态成员变量。
方法二：
其实这个方法在GLIB中用的很多，就是放上全局变量地址即
A g_a;

class A
{
public:
    static void test()
    {
        g_a.m_a += 1;
    }
    void hello()
    {
    }
private:
    static int m_staticA;
    int m_a
};

这种方法我们了解就好，全局变量我们并不推荐。
方法三：
大家都知道静态成员函数不能访问非静态成员，但别忘了，他们可以访问静态成员，也就是说，如果我们的这个类是个单例，我们完全可以在创建的时候把this指针赋值给那个静态成员，然后在静态成员函数内部就可以放心大胆的使用了。
class A
{
public:
    A()
    {
        m_gA = this;
        m_a = 999;
    }
    static void test()
    {
        m_gA->m_a += 1;
    }
    void hello()
    {
    }
private:
    static int m_staticA;
    static A *m_gA;
    int m_a;
};

方法四：
和方法一比较像，但他的方向思想更多的是针对内存块这个概念，意思就是在静态函数的形参比加上一个void *的内存首地址，然后在内部做转换
class A
{
public:
    static void test(void *pData)
    {
        A *a = (A *)pData;
        a->m_a += 1;
    }
    void hello()
    {
    }
private:
    static int m_staticA;
    int m_a
};

A a;
test(&a);

数据成员：

静态数据成员是类的一部分，为类的所有实例共享(静态区)；非静态数据成员，类的每个实例都有一份拷贝(动态区)。

静态数据成员的访问：

静态数据成员是类的一部分，在产生任何实例之前已经存在。

函数成员(都在代码区)：

静态函数成员与非静态函数成员都为类所有，对象中并不存在函数的拷贝（每个对象所占用的存储空间只是该对象的数据成员所占用的存储空间，但是在逻辑上函数和数据是一起被封装进对象的）。静态成员函数和非静态成员函数的根本区别在于有无this指针。非静态函数由对象名.或者对象指针->调用，调用时编译器会向函数传递this指针；静态成员函数则有类名::或者对象名.调用，没有this指针，不识别对象个体，经常用来操作类的静态数据成员。访问类的非静态成员要通过对象来实现。

内存角度分析：

类的静态成员(数据成员和函数成员)为类本身所有，在类加载的时候就会分配内存，可以通过类名直接访问；非静态成员(数据成员和函数成员)属于类的实例所有，所以只有在创建类的实例的时候才会分配内存，并通过实例去访问。

 

注意：类的静态数据成员是静态存储，它是静态生存周期，必须进行初始化。

注意：静态数据成员的初始化在类体外进行，前面不加static以免与一般静态变量或者对象混淆。

静态成员函数访问非静态成员报错：

类的静态成员在类加载的时候就已经分配内存，而此时类的非静态成员尚未分配内存，访问内存中不存在的东西自然会出错。

 

#include<iostream>

using namespace std;

class StaticTest
{
public:
	StaticTest(int a){A=a;B++;}  // B实际为类实例化的对象的个数
	static void printTest(StaticTest t);
private:
	int A;
	static int B;
};
void StaticTest::printTest(StaticTest t)
{
	cout<<"t.A: "<<t.A<<endl;
	cout<<"StaticTest::B: "<<StaticTest::B<<endl;
	cout<<"t.B: "<<t.B<<endl;
}
int StaticTest::B=0;
int main()
{
	StaticTest a1(66);
	StaticTest::printTest(a1);
	StaticTest a2(88);
	StaticTest::printTest(a2);
	return 0;
}