类中static数据成员和static成员函数

最新推荐文章于 2024-10-17 22:11:47 发布

慢慢来比较快

最新推荐文章于 2024-10-17 22:11:47 发布

阅读量1k

点赞数

分类专栏： C&&C++

本文链接：https://blog.csdn.net/m6830098/article/details/8935254

版权

C&&C++ 专栏收录该内容

46 篇文章 0 订阅

订阅专栏

类中的数据成员：static 数据成员和static成员函数

1.static数据成员

在类中用static 声明的数据成员，成员可以是常量，引用，数组，或者类类型等。 static 数据成员必须在类定义体的外部定义和初始化，在类中，普通数据成员的初始化是通过类构造函数进行初始化的，而static数据成员是在定义的时候进行初始化。

静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.

非成静态员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中..

静态数据成员在类声明中声明,在包含类方法的文件中初始化.初始化时使用作用域操作符来指出静态成员所属的类.但如果静态成员是整型或是枚举型const,则可以在类声明中初始化!!!

static成员遵循正常的私有/公有访问规则。

特点：
　　A、该变量在全局数据区分配内存。静态成员存在于内存,非静态成员只有在类的实例化才会存在，其存在于对象的生命周期内。
　　B、初始化：如果不显式初始化，那么将被隐式初始化为0(自动变量是随机的,除非显式地初始化)。
　　C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。

可以这样初始化static成员：

#include <iostream>

using namespace std;


class cat
{
public:
    static int num1;
    int age;
private:
    static int num2;
    static const int m = 2;
};


int cat::num1 = 0;
int cat::num2 = 0;


int main()
{
    cout << cat::num1 << endl;
    //cout << cat::num2 << endl;
    return 0;
}

Static 的用法

C语言中也用static来修饰变量，C++中除了修饰变量外还可以修饰类的成员。

修饰函数中的局部变量，这个变量在这个函数中，无论调用多少次都是共有的。
修饰全局变量，则这个变量在当前文件中有效。在另一文件中，即使是同一程序也不再有效。
修饰类的成员变量或成员函数，则这个类无论产生多少实例，这个成员都是共有的。
static修饰的变量的初始值为0。
在类的静态成员函数中不能使用this指针，也不能作成静态虚函数。
类的静态成员函数不能用const、volatile申明。
静态全局变量的好处：不能被其他文件使用，其他文件可以定义形同名字的变量不会发生冲突。

看一个例子：

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

class A {
    static int a;
    static string b;
public:
    static int c;
    void set(int x, string s) {
        a = x;
        b = s;
    }
    void print() {
        cout << "  a = " << a ;
        cout << "  b = " << b ;
        cout << "  c = " << c << endl;
    }
};

//下面的申明是必须的，这样不会改变访问权限(public,private)
int A::a;
string A::b;
int A::c;

//int A::a = 3;
//string A::b = " ";
//int A::c = 2;

int main ( )
{
    A ca1, ca2;
    cout << "ca1: ", ca1.print();   //实例1的初始值
    cout << "ca2: ", ca2.print();   //实例2的初始值

    ca1.set(25, "hehe");    //设定实例1，实例2 也会改变
    ca1.c = 100;       //公有静态成员可以通过实例来设定
    cout << "ca1: ", ca1.print();   //实例1的设定值
    cout << "ca2: ", ca2.print();   //实例2的设定值

    ca2.set(80, "taotao 2b");    //设定实例2，实例1 也会改变
    A::c = 125;   //公有静态成员也可以不通过实例来设定
    cout << "ca1: ", ca1.print();   //实例1的设定值
    cout << "ca2: ", ca2.print();   //实例2的设定值

    return 0;
}

运行结果：

可以得出以下结果：

类中static 变量必须在外面定义，如果没有初始值就为0 ，也可以设置初始值。

类中公有static 变量可以通过实例对象来设定，但是私有的不可以。

类中的其他函数可以直接对私有或者公有的static 变量进行处理。

类似这样：

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;

class CSta
{
public :
    CSta()
    {
      m_cs++;    //在构造函数中对静态成员变量赋值 但并没有初始化
      m_is++;
    }
//声明可被外部访问的公有静态成员，但并非定义
    static char m_cs;
    void print()
    {
        cout << m_cs << m_is <<endl;
    }
private:
    static int m_is;
};

 // 定义CSta类的两个静态成员变量，并且初始化 默认初始化为0
int CSta::m_is;
char CSta::m_cs;

int main()
{
    //通过类名限定符访问公有静态成员 ，输出初始化值
    printf("%c\n",CSta::m_cs);
    printf("%c\n",CSta::m_cs);
    CSta a;
    //通过对象访问公有静态成员 ，输出当前值

    a.print();
    return 0;
}

对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。因为在类的声明中是不分配给类内存空间，只有实例化对象的时候才会分配内存空间。

2.static 成员函数

与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。static成员函数不能声明为const，将成员函数声明为const 则表示不会修改该函数所属的对象。

例子：

#include <iostream>
using namespace std;
class Myclass
{
public:
    Myclass(int a,int b,int c);
    static void GetSum();
private:
 int a,b,c;
 static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
 this->a=a;
 this->b=b;
 this->c=c;
 Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
}

void Myclass::GetSum() //静态成员函数的实现
{
// cout<<a<<endl; //错误代码，a是非静态数据成员
 cout<<"Sum="<<Sum<<endl;
}

int  main()
{
     Myclass M(1,2,3);
     M.GetSum();
     Myclass N(4,5,6);
     N.GetSum();
     Myclass::GetSum();
     return 0;
}

static 成员函数，可以调用和修改static成员。

关于静态成员函数，可以总结为以下几点：