静态成员变量初始化

       静态成员变量可以初始化，但只能在类体外进行初始化。如：

long long student::number = 13926572996;    //在类体外对静态成员变量赋值

其一般形式为：

数据类型 类名：：静态成员变量名 = 初值；

不必在初始化赋值语句中加 static。

       注意：不可以在构造函数的参数初始化表中对静态成员变量初始化，例如：

    student(char* pn, char* pa, int n):number(n)

    {

        strcpy(name, pn);

        strcpy(addr, pa);

    }

       在构造函数中，对static类型的number成员进行初始化，是错误的操作。

如果未对静态成员变量赋值，则编译系统会自动赋初值为0。

如果一个成员变量定义为const类型，同时，也是static类型，那么，应该怎么样初始化？有如下的分析：

(1) static类型的成员变量，需要在类外进行初始化；

(2) const类型的成员变量，需要在构造函数的初始化列表进行初始化；

       那么，const类型的static成员变量，不可以在构造函数的初始化列表中进行初始化，例如：

       程序编译错误，如下：

       提示 student::number成员变量是static类型，仅仅在定义的时候可以初始化。所以，不可以在构造函数列表中初始化。所以，在类外对static类型的成员变量进行初始化，程序测试代码如下：

       程序运行结果如下：

       所以，可以在类外对const类型的静态成员变量进行初始化。

       注意：对于const 类型的static成员变量，可以在定义它的时候进行初始化，如下：

       在student类内对number成员进行初始化。这是合法的语句。

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

我们都知道类的静态成员变量必须在类外初始化，不仅如此，类的静态成员变量最好在源文件中初始化，而不能在头文件初始化，否则，编译的时候就会报错"symbol multiply defined".
举例：

/*--testA.h--*/
class A
{
public:
    void testB();
private:
    struct B
    {
        int getStatic();
        void addStatic();
        static int seq; //static member variable
        int num;
    };
    //int A::B::seq = 0; //error, must be defined in cpp file
};
//int A::B::seq = 0; //error, must be defined in cpp file

#include "test30-static-member.h"

void A::testB() {
        B b[2];
        b[0].addStatic();
        std::cout << b[0].getStatic() << std::endl;
        b[1].addStatic();
        std::cout << b[1].getStatic() << std::endl;
    }
int A::B::seq = 0; //right

/*--main.cpp--*/
#include "testA.h"
//int A::B::seq = 0;  //also work
int main()
{
    A a;
    a.testB();
    return 0;
}

输出：
1
2

C++中有声明（declare)和定义（define）的概念，int A::B::seq = 0;与其叫做初始化，叫做定义更准确， 而结构体中的这句话实际为声明。
C++中的所有变量、函数、类等都只能定义一次，可以声明多次。 如果把int A::B::seq = 0;放到头文件中，头文件被多次include， 则可能会导致变量被多次声明， 因此不可行。

？？
declare： 编译期告诉编译器变量的名字和类型
define: 链接的时候告诉变量存放位置，函数实体等。
？？

根据评论提醒，static const的成员变量可以在类内初始化， 但仅限于整型和enum型。

总结：

In C++11, non-static data members, static constexpr data members, and static const data members of integral or enumeration type may be initialized in the class declaration.

struct X {
    int i=5; // ok
    const float f=3.12f; // ok
    static const int j=42; // ok
    static constexpr float g=9.5f; //ok
    static const double d = 1.23; // error
    static const char* cstr = "FOO"; // error
    struct FooT { int i; };
    static const FooT foo; // ok
};

https://stackoverflow.com/questions/9141950/initializing-const-member-within-class-declaration-in-c
https://stackoverflow.com/questions/19575258/why-must-non-integral-static-data-members-initialized-in-the-class-be-constexpr

One of the reasons why this was the case prior to C++11’s addition of constexpr was the standard did not specify how floating points were to be implemented (it is left to the processor/architecture - for example, when you say float x = 1.6f, it is actually 1.6000000000024 on most systems).

1.背景

有这样一套会话机制，CSession为会话对象，CSessionManager为会话管理类，在CSession会话需要销毁时，CSession主动发送消息给CSessionManager销毁session。同时CSession是一个基类，子类通过继承CSession实现不同的session处理。

实现主要考虑三个方面（创建、处理、销毁）：

1. 通过不同的server创建不同的session会话；
2. 子类通过CSession提供的虚函数接口实现多态；
3. 通过消息对象指针发送消息给CSessionManager销毁session；

问题卡在session的销毁：

CSessionManager通过消息队列模板类创建消息对象，保存消息对象指针信息，并且有一个线程专门接收该对象发送的消息。那么CSession会话类也需要知道和保存消息对象指针。

先前有类似情况，消息对象指针是通过构造传参保存下来的。但现在CSession作为一个基类（要被继承），显然通过构造传参是非常不合理的，并且我希望CSession只保存一份消息对象指针（static成员变量），提供唯一 一个发送消息的接口给子类。

大致代码如下：

typedef struct
{
	int connfd;
	int keepfd;		/*是否保留fd:1-是，其他-否*/
}SocketSessionExp;

//session会话基类(HttpSession、RtspSession继承该类)
class CSession
{
	friend class CSessionManager;
	public:
		CSession();
		virtual ~CSession();
	protected:
		static void sendMessage(SocketSessionExp &expMessage);//希望CSession对象和子类能通过这个唯一接口发送消息给CSessionManager销毁该CSession会话
	private:
		static TMessageQue<SocketSessionExp> *m_exception_msq;//TMessageQue为消息队列模板类
}

//会话管理类
class CSessionManager
{
public:
	static CSessionManager* instance();		//单健类
private:
	CSessionManager();
	{
		m_exception_msq = new TMessageQue<SocketSessionExp>();
		CSession::m_exception_msq=m_exception_msq;
	}
	~CSessionManager();//不是重点未给出
private:
	static TMessageQue<SocketSessionExp> *m_exception_msq;//在构造函数中new一个类对象
	std::map<int,CSession*>			m_sessionMap;
}

该模块编译时没报错，链接时报错提示：

undefined reference to `Network::CSession::m_exception_msq'

2.试错

CSessionManager是CSession的友元类，可直接访问CSession的私有成员和保护成员。也尝试通过函数、局部CSession等方式来完成m_exception_msq的赋值，均报错。

3.分析与百度

class CSession
{
	friend class CSessionManager;
	public:
		CSession();
		virtual ~CSession();
	private:
		static TMessageQue<SocketSessionExp> *m_exception_msq;//TMessageQue为消息队列模板类
}

分析-有用信息：

1. 在如上代码中，m_exception_msq只是声明，并没有定义和初始化。
2. “undefined reference to”是未定义……；
3. 项目中有地方使用静态变量的地方都在.cpp文件上方进行了初始化（实际是定义–>初始化）。

分析推测：应该是m_exception_msq未定义。

在.cpp文件中添加如下代码：

//xxx.cpp
TMessageQue<SocketSessionExp>* CSession::m_exception_msq=NULL;

编译成功、链接成功、通过打印信息也看到CSession::m_exception_msq在CSessionManager构造中完成了赋值，问题解决了。

这里一方面是对static成员变量的理解不到位，另一方面是分析的时候没有抓住有效信息浪费了不少时间。（“undefined reference to”）

4.C++静态成员变量

C++的变量的类型大致有普通成员变量、静态成员变量、成员常量这三种，还有一种组合的静态成员常量。

这里说一下C++静态成员变量，在C++中，静态成员是属于整个类的而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则，保证了安全性还可以节省内存。

static成员的所有者是类本身和对象，但是多个对象拥有一样的静态成员。从而在定义对象时不能通过构造函数对其进行初始化; 静态成员不能在类定义里边初始化，只能在class body外初始化; 静态变量依旧符合public、private、protect特性; 静态成员函数没有this指针，它不能返回非静态成员，因为除了对象会调用它外，类本身也可以调用 。

C++静态成员变量：

1. 必须在外部定义和赋值；
   • 不能在 main() 函数中定义
   • 不能在类的构造函数中定义
2. 必须要定义静态变量，否则该变量没有内存空间（类中只是申明） ；
3. 类本身可以直接调用静态变量
4. 静态变量依旧符合public、private、protect特性

C++成员变量声明、初始化、赋值说明列表：

5.C++静态成员方法

1、静态方法可以被类直接调用，但是同静态变量一样符合public、private、protect特性

2、静态成员函数不可以调用类的非静态成员。因为静态成员函数不含this指针。

3、静态成员函数不可以同时声明为 virtual或后缀const 函数。因为virtual就是用来区分是哪个对象调用了他，与静态方法矛盾。而后缀const是用来修饰this指针的，静态变量中不包含this指针。

参考资料：
https://blog.csdn.net/nwd0729/article/details/47067549
https://blog.csdn.net/buknow/article/details/80275191