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

此时你的test函数只能去访问m_staticA成员，而不能去访问m_a。同学可能会问，这算什么问题？问题都是在应用场景中才能体现的，我一开始也是不以为意，直到我遇到了回调函数这个烦人的问题我才真正静下心来去考虑这个知识点。

先简单说下回调，在座的应该都知道回调的含义，在C中回调主要体现就是回调函数，当然C++中也有仿函数等其他用法，抛开这些，单纯在回调函数这个点上我们进行如下讨论。

由于C++类的成员函数都隐含了this指针，如果我直接注册，比如：

typedef void (A::*FunPtr)();
FunPtr p = A::hello;
p();

此时程序会报错，提示信息是你缺少一个this指针，意味着你要真的想使用p，你必须有一个分配好空间的实例才能来调用

typedef void (A::*FunPtr)();
FunPtr p = A::hello;

A a;
A *pA = new A();

(a.*p)();
(pA->*p)();

当然，如果仅仅是对C++的类静态函数进行回调函数注册，你是不需要考虑this指针的

typedef void (A::*FunPtr)();
FunPtr p = A::test;
p();

但问题就是，你此时的静态函数是不能拥有你的成员变量的，看到了吧，问题来了。面对这种需求，我们就真正应该静下心来好好想想，究竟如何才能让静态函数去访问非静态成员变量这个问题了。

有如下四种方法：

• ① 在静态函数的形参表里加上实例的地址；
• ② 在静态函数中使用全局变量；
• ③ 静态成员函数可以访问静态成员，在类是单例类的情况下，可以在创建的时候把this指针赋值给那个静态成员，然后在静态成员函数内部访问this指向的静态成员；
• ④ 在静态函数的形参比加上一个void *的内存首地址，然后在内部做转换；

具体示例如下：

方法一：

有一个很取巧的办法，就是在静态函数的形参表里加上实例的地址，也就是：

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指针赋值给那个静态成员，然后在静态成员函数内部访问this指向的静态成员：

class A {
public:
    A() {
        m_gA = this;
    }
    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 = static_cast<A*>(pData);
        a->m_a += 1;
    }
    void hello() {
    }
private:
    static int m_staticA;
    int m_a
};

A a;
test(&a);

如上，我整理了4种方法，当然方法还有很多，其实绕了这么大远路，我们的希望就是不破坏回调函数整洁的函数接口（即不在回调函数形参列表中加上自己的实例指针）而做的妥协，如果你更喜欢通过改变接口或者通过用Java类似的interface方式来实现，那也没有问题，这里主要就是提供给大家一个思路，C++确实很灵活，我们要用好这把双刃剑 ： ）

转载自：C++静态成员函数访问非静态成员的几种方法

1静态成员

       如果定义了一个student类，定义 3 个student类的对象，如下：

student stud1, stud2, stud3;

那么，每一个student类对象都分别有自己的成员变量，而不同对象的成员变量各自有值，互不相干。但是，有时人们希望有一个或几个成员变量为所有对象所共有。这样，可以实现数据共享。

       学习C语言时已经了解了全局对象，它能够实现数据共享。如果在一个程序文件中有多个函数，在每一个函数中都可以改变全局变量的值。全局变量的值为各个函数共享，但是，用全局变量时安全性得不到保证，由于在各处都可以自由地修改全局变量的值，很有可能偶到失误，全局变量的值就被修改，导致程序错误。因此，在实际工作中很少使用全局变量。

       如果想在同类的多个对象之间实现数据共享，也不要用全局对象，可以用静态的成员变量。使用静态成员变量，实现数据共享。

2静态成员变量

2.1 静态成员变量的定义

       静态成员变量是一种特殊的成员变量。它以关键字static开头，用static关键字来修饰的一种成员变量，例如：

class student

{

public:

    char name[32]; //姓名

    char addr[32]; //家庭地址

    static long long number; //电话号码

public: //以下部分是公有部分

    student(char* pn, char* pa)

    {

        strcpy(name, pn);

        strcpy(addr, pa);

    }

    void print() const

    {

        cout << "name = " << name << endl;

        cout << "addr = " << addr << endl;

        cout << "number = " << number << endl;

    }

};

       此时，在student类中定义的number成员变量，就是“静态成员变量”。每个student类对象中的number的值都是一样的，把它定义为静态成员变量，这样它就为各对象所共有，而不只属于某个对象的成员，所有对象都可以引用它。

静态的成员变量在内存中只占一份空间（而不是每个对象都分别为它保留一份空间）。每个对象都可以引用这个静态成员变量。所有同类对象的静态成员变量的值都是一样的。如果改变它的值，那么，在各个对象中这个成员变量的值都同时改变了。这样，可以节省空间，提高效率。

静态成员变量是属于类，而不是属于某个独立对象。N个独立的对象，共享一个静态成员变量。

       如下是一个测试例子：

       程序运行结果如下：

       可以看到，student类定义number成员是static类型。在类外给number成员初始化。然后，在stud对象中修改number成员的值。

       然后，输出stud1对象的信息，得到的stud1. number成员变量是stud.number设置的值。所以，stud, stud1对象是共享static类型的number成员变量。

韦凯峰 Linux C/C++ 程序设计教程，Linux 系统编程，Openwrt 系统开发，微信:13926572996,QQ:1523520001,博客:www.mylinux.vip

普通静态变量的初始化

#include<iostream>
using namespace std;
int main()
{
	static int sa;//普通静态变量
	//普通静态变量定义时分配内存，系统自动初始化为0
	cout << sa << endl;
	return 0;
}

静态成员变量的初始化

参考以下文章
c++静态成员变量的初始化

#include<iostream>
using namespace std;
class A
{
public:
	static int cnt;
};
int main()
{
	A a;
	static int sa;//普通静态变量
	cout << sa << endl;//0
	cout << A::cnt << endl;
	cout << sizeof(A) << endl;//1
	return 0;
}
/*
上述代码会报错，错误	2	error LNK2001: 
无法解析的外部符号 "public: static int A::cnt" 
原因是static int cnt只是类内的声明，在类外没有定义，
即没有分配内存，所以会报错
*/

在类外加上静态数据成员的定义int A::cnt后，程序会通过编译。

#include<iostream>
using namespace std;
class A
{
public:
	static int cnt;
};
int A::cnt;//静态数据成员的定义，分配内存，自动初始化为0
int main()
{
	A a;
	static int sa;//普通静态变量
	cout << sa << endl;//自动初始化为0
	cout << A::cnt << endl;//自动初始化为0
	cout << sizeof(A) << endl;
	return 0;
}

总结：

这里普通静态变量与类的静态成员变量的初始化不同，原因是类的静态数据成员变量只是在类内进行声明，并没有为其分配内存空间，所以在类外必须定义，从而分配空间并初始化。而普通静态变量声明与定义是同时的，不用再另行定义。