C++静态成员

本文地址：http://www.cnblogs.com/archimedes/p/cpp-static2.html，转载请注明源地址

静态数据成员

定义：

以关键字static声明的数据成员

class Box
{
public:
    int volume() const;
private:
    int iwitch;
    int length;
    int heigth;
    static int count;
};

初始化：

静态数据成员必须初始化且只能在类外初始化，初始化时不能加static，格式：

类型 类名::静态数据成员名 [= 初值];

class Box
{
public:
    int volume() const;
private:
    int iwitch;
    int length;
    int heigth;
    static int count;
};
int Box::count; //必须在类外初始化

注意：不能通过构造函数初始化、不能通过初始化列表初始化

访问:

静态数据成员属于类而不属于具体的对象，为不同对象共有。因此，公有静态数据成员在类外的访问方式有两种

类名::公有静态数据成员

对象名.公有静态数据成员

静态数据成员可被其所在类的任何成员函数直接引用

void Box::display()const
{
     cout << Box:: s_iCount << " ";
     cout << s_iCount << " ";
}

存储：

静态数据成员编译时开辟内存单元，占据全局区类的对象创建前就能使用。

静态数据成员的内存单元独立开辟，不属于具体的某个对象，为不同的对象共有。

为什么要引入静态数据成员？

各对象之间的数据有了沟通的渠道，实现了数据的共享，C++中涉及到对象之间的数据共享时应使用静态数据成员，而不要使用全局变量，因为全局变量不能体现封装特性。

#include <iostream>
using namespace std;
class Type
{
public:
    Type(int ax=0);
    static int s_value;
    void print();
private:
    int m_value;
};
int Type::s_value;
Type::Type(int ax)
{
    m_value=ax;
}
void Type::print()
{
    cout<<"m_value="
        <<++m_value
        <<endl;
    cout<<"s_value="
        <<++s_value
        <<endl;
}
int main()
{
    Type::s_value=90;
    Type c1,c2;
    c1.print();
    c2.print();
    system("PAUSE");
    return 0;
}

应用举例：统计创建对象的个数

#include <iostream>
#include <string>
using namespace std;
class student
{
public:
    student(string aName="codingwu")
    {
        strName=aName;
        count++;
        cout << "Cons"<<" "<<strName <<endl;
    }
    ~student()
    {
        count--;
        cout<< "Des"<<" "<<strName<<endl;
    }
    void printCount()const
    {
        cout<<"COUNT = "<<count<<endl;
    }
private:
    static int count;
    string strName;
};
int student::count;
int main()
{
    student stu("li");
    student stu1("zhang");
    student *p=new student[5];
    delete []p;
    student("hahahaha");
    stu.printCount();
    system("PAUSE");
    return 0;
}

运行结果：

静态成员函数

1、概念：

用static声明的成员函数

2、访问方式:
      属于类类型的而不属于具体对象

3、特点

①静态成员函数专门用于访问静态成员（包括数据成员和成员函数）

②是属于类的而不属于具体对象，因此既可以通过类名访问，也可以通过对象名引用

③其实静态成员函数就是在类内的全局函数

④静态成员函数没有this指针

#include <iostream>
using namespace std;

class Type
{
public:
    static void print();
    Type(int aValue = 0);
private:
    int m_iValue;
    static int s_iValue;
};
int Type::s_iValue;

Type::Type(int aValue)
{
    m_iValue = aValue;
    s_iValue++;
}
void Type::print()
{
    //cout << ++m_iValue;//Error
    cout << s_iValue << endl;
}
int main()
{
    Type::print();
    Type c1,c2;
    c1.print();
    c2.print();
    return 0;
}

注意:

非静态成员函数可以访问本类中的任何成员

静态成员函数专门用于访问静态成员，不能直接访问非静态成员。

#include <iostream>
#include <string>
using namespace std;

class Student
{
public:
    Student(int aNum=0,int aAge=0,double aScore=0);
    void total();
    static double s_average();
    double m_iScore;
private:
    static int s_iCount;//对象个数
    static double s_iSum;//总成绩
    int m_iNum;
    int m_iAge;
};
double Student::s_iSum;
int Student::s_iCount;

Student::Student(int aNum,int aAge,double aScore):m_iNum(aNum),m_iAge(aAge),m_iScore(aScore)
{
}
void Student::total()
{
    s_iSum += m_iScore;
    s_iCount++;
}
double Student::s_average()
{
    return s_iSum/s_iCount;
}
int main()
{
    Student stud[3] =
    {
        Student(1001,18,60),
        Student(1002,19,90),
        Student(1005,20,0),
    };
    for(int i = 0;i<3;i++)
        stud[i].total();
    cout << Student::s_average()<<endl;
    system("PAUSE");
    return 0;
}