以下转自http://blog.csdn.net/morewindows/article/details/6721430
在C++中，静态成员是属于整个类的而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则，保证了安全性还可以节省内存。
静态成员的定义或声明要加个关键static。静态成员可以通过双冒号来使用即<类名>::<静态成员名>。
在C++中类的静态成员变量和静态成员函数是个容易出错的地方，本文先通过几个例子来总结静态成员变量和成员函数使用规则，再给出一个实例来加深印象。希望阅读本文可以使读者对类的静态成员变量和成员函数有更为深刻的认识。
第一个例子，通过类名调用静态成员函数和非静态成员函数
- class Point
- {
- public:
- void init()
- {
- }
- static void output()
- {
- }
- };
- void main()
- {
- Point::init();
- Point::output();
- }
class Point
{
public:
void init()
{
}
static void output()
{
}
};
void main()
{
Point::init();
Point::output();
}编译出错：error C2352: 'Point::init' : illegal call of non-static member function
结论1：不能通过类名来调用类的非静态成员函数。
第二个例子，通过类的对象调用静态成员函数和非静态成员函数
将上例的main()改为：
- void main()
- {
- Point pt;
- pt.init();
- pt.output();
- }
void main()
{
Point pt;
pt.init();
pt.output();
}编译通过。
结论2：类的对象可以使用静态成员函数和非静态成员函数。
第三个例子，在类的静态成员函数中使用类的非静态成员
- #include <stdio.h>
- class Point
- {
- public:
- void init()
- {
- }
- static void output()
- {
- printf("%d\n", m_x);
- }
- private:
- int m_x;
- };
- void main()
- {
- Point pt;
- pt.output();
- }
#include <stdio.h>
class Point
{
public:
void init()
{
}
static void output()
{
printf("%d\n", m_x);
}
private:
int m_x;
};
void main()
{
Point pt;
pt.output();
}编译出错：error C2597: illegal reference to data member 'Point::m_x' in a static member function
因为静态成员函数属于整个类，在类实例化对象之前就已经分配空间了，而类的非静态成员必须在类实例化对象后才有内存空间，所以这个调用就出错了，就好比没有声明一个变量却提前使用它一样。
结论3：静态成员函数中不能引用非静态成员。
第四个例子，在类的非静态成员函数中使用类的静态成员
- class Point
- {
- public:
- void init()
- {
- output();
- }
- static void output()
- {
- }
- };
- void main()
- {
- Point pt;
- pt.output();
- }
class Point
{
public:
void init()
{
output();
}
static void output()
{
}
};
void main()
{
Point pt;
pt.output();
}编译通过。
结论4：类的非静态成员函数可以调用用静态成员函数，但反之不能。
第五个例子，使用类的静态成员变量
- #include <stdio.h>
- class Point
- {
- public:
- Point()
- {
- m_nPointCount++;
- }
- ~Point()
- {
- m_nPointCount--;
- }
- static void output()
- {
- printf("%d\n", m_nPointCount);
- }
- private:
- static int m_nPointCount;
- };
- void main()
- {
- Point pt;
- pt.output();
- }
#include <stdio.h>
class Point
{
public:
Point()
{
m_nPointCount++;
}
~Point()
{
m_nPointCount--;
}
static void output()
{
printf("%d\n", m_nPointCount);
}
private:
static int m_nPointCount;
};
void main()
{
Point pt;
pt.output();
}按Ctrl+F7编译无错误，按F7生成EXE程序时报链接错误
error LNK2001: unresolved external symbol "private: static int Point::m_nPointCount" (?m_nPointCount@Point@@0HA)
这是因为类的静态成员变量在使用前必须先初始化。
在main()函数前加上int Point::m_nPointCount = 0;
再编译链接无错误，运行程序将输出1。
结论5：类的静态成员变量必须先初始化再使用。
结合上面的五个例子，对类的静态成员变量和成员函数作个总结：
一。静态成员函数中不能调用非静态成员。
二。非静态成员函数中可以调用静态成员。因为静态成员属于类本身，在类的对象产生之前就已经存在了，所以在非静态成员函数中是可以调用静态成员的。
三。静态成员变量使用前必须先初始化(如int MyClass::m_nNumber = 0;)，否则会在linker时出错。
再给一个利用类的静态成员变量和函数的例子以加深理解，这个例子建立一个学生类，每个学生类的对象将组成一个双向链表，用一个静态成员变量记录这个双向链表的表头，一个静态成员函数输出这个双向链表。
- #include <stdio.h>
- #include <string.h>
- const int MAX_NAME_SIZE = 30;
- class Student
- {
- public:
- Student(char *pszName);
- ~Student();
- public:
- static void PrintfAllStudents();
- private:
- char m_name[MAX_NAME_SIZE];
- Student *next;
- Student *prev;
- static Student *m_head;
- };
- Student::Student(char *pszName)
- {
- strcpy(this->m_name, pszName);
- //建立双向链表，新数据从链表头部插入。
- this->next = m_head;
- this->prev = NULL;
- if (m_head != NULL)
- m_head->prev = this;
- m_head = this;
- }
- Student::~Student ()//析构过程就是节点的脱离过程
- {
- if (this == m_head) //该节点就是头节点。
- {
- m_head = this->next;
- }
- else
- {
- this->prev->next = this->next;
- this->next->prev = this->prev;
- }
- }
- void Student::PrintfAllStudents()
- {
- for (Student *p = m_head; p != NULL; p = p->next)
- printf("%s\n", p->m_name);
- }
- Student* Student::m_head = NULL;
- void main()
- {
- Student studentA("AAA");
- Student studentB("BBB");
- Student studentC("CCC");
- Student studentD("DDD");
- Student student("MoreWindows");
- Student::PrintfAllStudents();
- }
#include <stdio.h>
#include <string.h>
const int MAX_NAME_SIZE = 30;
class Student
{
public:
Student(char *pszName);
~Student();
public:
static void PrintfAllStudents();
private:
char m_name[MAX_NAME_SIZE];
Student *next;
Student *prev;
static Student *m_head;
};
Student::Student(char *pszName)
{
strcpy(this->m_name, pszName);
//建立双向链表，新数据从链表头部插入。
this->next = m_head;
this->prev = NULL;
if (m_head != NULL)
m_head->prev = this;
m_head = this;
}
Student::~Student ()//析构过程就是节点的脱离过程
{
if (this == m_head) //该节点就是头节点。
{
m_head = this->next;
}
else
{
this->prev->next = this->next;
this->next->prev = this->prev;
}
}
void Student::PrintfAllStudents()
{
for (Student *p = m_head; p != NULL; p = p->next)
printf("%s\n", p->m_name);
}
Student* Student::m_head = NULL;
void main()
{
Student studentA("AAA");
Student studentB("BBB");
Student studentC("CCC");
Student studentD("DDD");
Student student("MoreWindows");
Student::PrintfAllStudents();
}程序将输出：
当然在本例还可以增加个静态成员变量来表示链表中学生个数，如果读者有兴趣，就将这个作为小练习吧。
--------------------------------------------------------------------------------------------------------------------------------------------
以下转自http://blog.csdn.net/candyliuxj/article/details/4520971
静态成员的特性：
不管这个类创建了多少个对象，而其静态成员只有一个拷贝（副本），这个拷贝被所有属于这个类的对象共享。
一、静态数据成员
定义格式：
static 数据类型 静态数据成员名；
初始化格式：
数据类型 类名：：静态数据成员名 = 初始化值；
公有静态数据成员的访问格式：
1. 类名：：静态数据成员名
2. 对象.静态数据成员名
3. 对象指针->静态数据成员名
说明：
1. 静态数据成员属于类，普通数据成员属于某一对象；
2. 在类中不给静态数据成员分配内存空间；
3. 静态数据成员与静态变量一样，是在编译时创建并初始化，它在该类的任何对象被建立之前就存在；
4. 静态数据成员不能在类中进行初始化，必须在类外的其他地方为它提供定义；一般在main()开始之前、类的声明之后的特殊地
带为它提供定义和初始化；
5. 私有静态数据成员不能被类外部函数访问，也不能用对象进行访问。
例子：
- #include <iostream>
- using namespace std;
- class KMyClass
- {
- private:
- static int i; //声明i为私有静态数据成员
- public:
- static int j; //声明j为公有静态数据成员
- int Geti()
- {
- return i;
- }
- int Getj()
- {
- return j;
- }
- };
- int KMyClass::i = 0; //静态数据成员初始化
- int KMyClass::j = 0;
- int main()
- {
- KMyClass::j = 200; //公有静态数据成员可以在对象定义之前被访问
- cout<<"KMyClass::j = "<<KMyClass::j<<endl;
- KMyClass ob1, ob2;
- cout<<"ob1.i = "<<ob1.Geti()<<endl;
- cout<<"ob1.j = "<<ob1.Getj()<<endl;
- cout<<"ob2.i = "<<ob2.Geti()<<endl;
- cout<<"ob2.j = "<<ob2.Getj()<<endl;
- ob1.j = 300; //公有静态数据成员也可通过对象进行访问
- cout<<"ob1.j = "<<ob1.Getj()<<endl; //静态数据成员是对象的共享数据项
- cout<<"ob2.j = "<<ob2.Getj()<<endl;
- return 0;
- }
程序结果：
MyClass：：j = 200;
ob1.i = 0;
ob1.j = 200;
ob2.i = 0;
ob2.j = 200;
ob1.j = 300;
ob2.j = 300;
二、静态成员函数
定义格式：
static 返回类型 静态成员函数名（实参表）；
公有静态数据成员的访问格式：
1. 类名：：静态成员函数名（实参表）
2. 对象.静态成员函数名（实参表）
3. 对象指针->静态成员函数名（实参表）
说明：
1. 静态成员函数可以定义成内嵌的，也可以在类外定义（在类外定义时，不要用static前缀）；
2. 一般情况下，静态成员函数主要用来返回全局变量或同一个类中的静态数据成员（当它与静态数据成员一起使用时，达到了对同
一个类中对象之间共享数据进行维护的目的）；
3. 编译系统将静态成员函数限定为内部连接，即，与现行文件相连接的其他文件中的同名函数不会与该函数发生冲突，维护了该函
数使用的安全性，这是使用静态成员函数的另一个原因；
4. 在一般的成员函数中，都隐含有一个this指针，用来指向对象自身，而在静态成员函数中是没有this指针的，因为它不与特定的
对象想联系，调用时使用如下格式较好： 类名：：静态成员函数名（）；
5. 私有静态成员函数不能被类外部函数和对象访问。
例子：
- #include <iostream>
- using namespace std;
- class Small_Cat
- {
- private:
- double weight;
- static double total_weight;
- static double total_number;
- public:
- Small_Cat(double w)
- {
- weight = w;
- total_weight += w;
- total_number++;
- }
- void Display()
- {
- cout<<"The small_cat weights "<<weight<<" pounds/n";
- }
- static void Total_Disp() //静态成员函数，显示小猫的只数和总重量
- {
- cout<<total_number<<" small_cat total weight "<<total_weight<<" pounds"<<endl;
- }
- };
- double Small_Cat::total_weight = 0;
- double Small_Cat::total_number = 0;
- int main()
- {
- Small_Cat w1(1.8), w2(1.6), w3(1.5);
- w1.Display();
- w1.Total_Disp();
- w2.Display();
- w2.Total_Disp();
- w3.Display();
- w3.Total_Disp();
- Small_Cat::Total_Disp();
- return 0;
- }
程序结果：
The small_cat weights 1.8 pounds
3 small_cat total weight 4.9 pounds
The small_cat weights 1.6 pounds
3 small_cat total weight 4.9 pounds
The small_cat weights 1.5 pounds
3 small_cat total weight 4.9 pounds
3 small_cat total weight 4.9 pounds
578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
