C++ 类的static 成员变量的初始化和销毁的问题

1.如果在header file中申明了一个static成员变量，想初始化他（有很多初始化代码），一般怎么做的？
我是这样做： 定义一个static方法或全局方法，然后返回值赋给给这个static变量.不知这样做好不好。
2.如何销毁这个static变量的，是程序退出后自动销毁吗？
但若这个static变量是指针类型的，以前他是通过new赋值的，需不需要在退出程序的时候手动delete掉?

8 个解决方案

#1

在cpp中
class test{};
static test x=test();
2在main结束后会销毁的
如果是指针类型,就得手动delete掉

#2

1：如果是public的，就可以在类外直接进行初始化，否则可以用static的函数进行初始化
2：如果是new出来的，肯定是需要用delete进行销毁的。

#3

比如一个Class中有一个static vector<string> strs;
我想给他初始化，填充一些数据进去，以后就不改了。我应该在什么地方初始化他？
在构造函数中肯定不行吧。

#4

反正不改了，那么在构造函数中赋值也没关系，只不过每次构造对象时重新又赋值一遍。
或者在类中再定义一个 static bool bIsInit, 初始化为false, 然后在构造函数中这么赋值：
if (!bIsInit)
{
  // 对strs赋值
  bIsInit = true;
}

#5

在类中写个静态的初始化函数和静态的释放函数。
当然在初始化之前你还需要在cpp中写个静态成员的空定义。

#6

enum，或者const int类型的静态变量类里面可以直接初始化的：
static const int  test=4;
static enum {ONE, TWO};
一般的成员变量：类里面申明，
外面初始化；

#7

class A
{
	int m_i;
public:
	static void* operator new(size_t n)
	{
		void* p=malloc(n);
		cout<<"在 "<<p<<" 处成功分配了 "<<n<<" 个字节的内存。\n";
		return p;
	}
	static void operator delete(void* p)
	{
		void* tmp=p;
		free(p);
		cout<<"在 "<<tmp<<" 处成功回收了内存。\n";
	}
	explicit A(int i=0):m_i(i){}
	int get()const{return m_i;}
	void set(int i){m_i=i;}
};
class B
{
public:
	static A* m_a;
};
A* B::m_a=new A(88);
int main()
{
	cout<<B::m_a->get()<<'\n';
	B::m_a->set(2008);
	cout<<B::m_a->get()<<'\n';
//////////////////////////////////////
	return 0;
}

换成：

template<typename T>
class HasPtrr
{
	T* ptr;
	HasPtrr(const HasPtrr& og);//
	HasPtrr& operator=(const HasPtrr&);//
public:
	explicit HasPtrr(T* p=0):ptr(p){}
	~HasPtrr(){delete ptr;ptr=0;}
	T* get_ptr()const{return ptr;}
	T get_ptr_val()const{return *ptr;}
	void set_ptr_val(const T& i){*ptr=i;}
};
class A
{
	int m_i;
public:
	static void * operator new(size_t n)
	{
		void* p=malloc(n);
		cout<<"在 "<<p<<" 处成功分配了 "<<n<<" 个字节的内存。\n";
		return p;
	}
	static void operator delete(void* p)
	{
		void* tmp=p;
		free(p);
		cout<<"在 "<<tmp<<" 处成功回收了内存。\n";
	}
	explicit A(int i=0):m_i(i){}
	int get()const{return m_i;}
	void set(int i){m_i=i;}
};
class B
{
public:
	static HasPtrr<A> m_a;//代替裸指针：A* m_a
};
HasPtrr<A> B::m_a(new A(88));
int main()
{
	cout<<B::m_a.get_ptr_val().get()<<'\n';
/////////////////////////////////////
	return 0;
}

如果不是VS2008，可那看不到内存回收语句，这可以换成如下形式：

#include<fstream>
using std::ofstream;
template<typename T>
class HasPtrr
{
	T* ptr;
	HasPtrr(const HasPtrr& og);//
	HasPtrr& operator=(const HasPtrr&);//
public:
	explicit HasPtrr(T* p=0):ptr(p){}
	~HasPtrr(){delete ptr;ptr=0;}
	T* get_ptr()const{return ptr;}
	T get_ptr_val()const{return *ptr;}
	void set_ptr_val(const T& i){*ptr=i;}
};
class A
{
	int m_i;
	static ofstream m_os;
public:
	static void * operator new(size_t n)
	{
		void* p=malloc(n);
		m_os<<"在 "<<p<<" 处成功分配了 "<<n<<" 个字节的内存。\n";
		return p;
	}
	static void operator delete(void* p)
	{
		void* tmp=p;
		free(p);
		m_os<<"在 "<<tmp<<" 处成功回收了内存。\n";
	}
	explicit A(int i=0):m_i(i){}
	int get()const{return m_i;}
	void set(int i){m_i=i;}
};
ofstream A::m_os("E:\\ptr.txt",std::ios::app);
class B
{
public:
	static HasPtrr<A> m_a;//代替裸指针：A* m_a
};
HasPtrr<A> B::m_a(new A(88));
int main()
{
	cout<<B::m_a.get_ptr_val().get()<<'\n';
//////////////////////////////////////
	return 0;
}

#8

#include <iostream>
using namespace std;

int main()
{  return 0;
}

//尝试格式