实验八静态数据成员和静态函数成员

合集下载

C++语言中静态数据成员和静态成员函数的研究

电脑知识与技术电脑知识与技术研究开发１引言类是类型而不是数据对象，每个类对象都是该类数据成员的拷贝。

然而，在某些情况下需要让类的所有对象在类的范围内共享某个数据，例如一个类的多个对象需要根据同一个数据的状态来决定下一个动作时，这时就会想到利用全局变量，但全局变量在类的外面，既不安全，又影响了重用性，一旦程序庞大，维护量就急剧上升，使用静态数据成员，就可以解决这个问题，同时也节省了空间和构造对象时的时间。

又不破坏面向对象的封装性，静态成员函数的使用也给程序设计带来很大的好处。

２类静态数据成员的定义及声明方法在一个类中，如果它的数据成员使用关键字ｓｔａｔｉｃ进行修饰，这样的成员称为静态数据成员。

静态数据成员提供的是类的所有对象共享的信息，无论建立多少个该类的对象，都只有一个静态数据的拷贝。

尽管静态数据成员看起来有些象全局变量，但它是具有类作用域的。

静态数据成员可以是公有的、私有的或受保护的。

静态数据成员必须在文件作用域内初始化，并且只在文件范围中初始化一次。

在数据成员声明的最前面加上系统关键字ｓｔａｔｉｃ就成了静态数据成员，例如：ｃｌａｓｓｚｙ｛ｐｕｂｌｉｃ：ｓｔａｔｉｃｉｎｔｄａｔａ；｝；３类静态数据成员的访问类的静态数据成员是在编译阶段（而不是运行阶段）时进行空间的分配和初始化的，所以，类的静态数据成员是属于类的，而不是属于某个具体对象的，它们被该类的所有对象共享，被存储在一个公用的内存中，即使还没有建立对象，静态数据成员就已经存在，从而类的ｐｕｂｌｉｃ静态数据成员既可以利用二元作用域运算符通过类名访问，也可以通过类的任何对象直接访问，实际上，通过对象名引用静态数据成员时，Ｃ＋＋系统只关心静态数据成员的类类型；类的ｐｒｉｖａｔｅ和ｐｒｏｔｅｃｔｅｄ静态数据成员应通过类的ｐｕｂｌｉｃ成员函数或通过类的友元访问。

３．１通过类名访问静态数据成员即使类没有一个对象，其静态数据成员依然存在，所以就可以访问，一般来说，通过类名访问静态数据成员，比使用对象名访问静态数据成员要好，因为静态数据成员不是对象的成员，而是属于类的。

实验8-常数据成员、常成员函数

#include <iostream.h> class Rectangle { public: Rectangle(int a,int b)//2个参数的构造函数Rectangle { width=a; length=b; }//负责对对象的宽和长数据成员初始化 int Area()//求矩形的面积 { return width*length; } int Periment()//求矩形的周长 { return 2*(width+length); } void Changesize(int a,int b)//改变矩形的宽和长 { width=a; length=b; } void Print();//负责打印求的的面积和周长 private: int width,length; }; void Rectangle::Print() { cout<<"AREA="<<Area()<<endl; cout<<"PERIMENT="<<Periment()<<endl; } void main() { Rectangle r(5,8);//定义对象r 初始化 r.Print(); r.Changesize(3,9);//调用对象r的成员函数Changesize改变宽和长 r.Print(); }
《教材》第六章例题（lt）： 6.9 （lt6.9.cpp） 6.10 （lt6.5之：
2（xt6.5-2.cpp）; 3（xt6.5-3.cpp）;
2、编程实现一个简单的计算器。要求从键盘上输入两个浮点数，计算出它们的加、减、乘、除运算的结果。
常成员函数常数据成员什么是常数据成员成员函数指针什么是成员函数静态成员函数成员函数类的静态成员函数cstring成员函数static成员函数

类的static成员函数与普通成员函数的区别

类的static成员函数与普通成员函数的区别成员函数:⽆论静态函数还是⾮静态函数,都是属于类的(这⼀点与数据成员的静态⾮静态不同),对象并不拥有函数的拷贝.两者的区别在于:⾮静态的函数由类对象(加.或指针加->;)调⽤,这时将向函数传递this指针.⽽静态函数由类名(::)(或对象名.)调⽤,但静态函数不传递this指针,不识别对象个体,所以通常⽤来对类的静态数据成员操作.程序最终都将在内存中执⾏，变量只有在内存中占有⼀席之地时才能被访问。

类的静态成员(变量和⽅法)属于类本⾝，在类加载的时候就会分配内存，可以通过类名直接去访问；⾮静态成员（变量和⽅法）属于类的对象，所以只有在类的对象产⽣（创建类的实例）时才会分配内存，然后通过类的对象（实例）去访问。

在⼀个类的静态成员中去访问其⾮静态成员之所以会出错是因为在类的⾮静态成员不存在的时候类的静态成员就已经存在了，访问⼀个内存中不存在的东西当然会出错。

C++会区分两种类型的成员函数：静态成员函数和⾮静态成员函数。

这两者之间的⼀个重⼤区别是，静态成员函数不接受隐含的this⾃变量。

所以，它就⽆法访问⾃⼰类的⾮静态成员。

静态数据成员在类中，静态成员可以实现多个对象之间的数据共享，并且使⽤静态数据成员还不会破坏隐藏的原则，即保证了安全性。

因此，静态成员是类的所有对象中共享的成员，⽽不是某个对象的成员。

使⽤静态数据成员可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储⼀处，供所有对象共⽤。

静态数据成员的值对每个对象都是⼀样，但它的值是可以更新的。

只要对静态数据成员的值更新⼀次，保证所有对象存取更新后的相同的值，这样可以提⾼时间效率。

静态数据成员的使⽤⽅法和注意事项如下：1、静态数据成员在定义或说明时前⾯加关键字static。

2、静态成员初始化与⼀般数据成员初始化不同。

静态数据成员初始化的格式如下：<数据类型><类名>::<静态数据成员名>=<值>这表明：(1) 初始化在类体外进⾏，⽽前⾯不加static，以免与⼀般静态变量或对象相混淆。

C++程序设计教程08Chapter08

本章习题
1、数据定义为全局变量，破坏了数据的 ___________；较好的解决办法是将所要共享的数据定义为类的___________。 2、静态数据成员和静态成员函数可由 ___________函数访问 3、___________和___________统称为友元 4、友元的正确使用能提高程序___________，但破坏了类的封装性和数据的隐蔽性
小结
本章需要重点理解静态成员的基本概念，本章需要重点理解静态成员的基本概念，掌握静态数据成员和静态成员函数的概念和使用方法。了解友元的必要性掌握如何使用友元函数和友元类。掌握如何使用友元函数和友元类。
本章习题
一、选择题 1、关于静态数据成员，下面说法错误的是、关于静态数据成员，下面说法错误的是___________。。 A) 使用静态数据成员，实际上是为了消除全局变量。使用静态数据成员，实际上是为了消除全局变量。 B) 可以使用 “ 对象名静态成员 ” 或者 “ 类名静态成员 ” 来访问静态数据成员。可以使用“对象名.静态成员或者“类名::静态成员来访问静态数据成员。静态成员” 静态成员” C) 静态数据成员只能在静态成员函数中引用。静态数据成员只能在静态成员函数中引用。 D) 所有对象的静态数据成员占用同一内存单元。所有对象的静态数据成员占用同一内存单元。 2、下面的函数中，静态成员函数不能访问的是、下面的函数中，静态成员函数不能访问的是___________ A) 静态数据成员 B) 静态成员函数 C) 类以外的函数和数据 D) 非静态数据成员 3、在类的定义中，引入友元的原因是、在类的定义中，引入友元的原因是___________ A) 提高效率 B) 深化使用类的封装性 C) 提高程序的可读性 D) 提高程序的可读性 4、友元类的声明方法是：___________ 、友元类的声明方法是： A) friend class <类名类名>; B) youyuan class <类名类名>; 类名类名 C) class friend <类名类名>; D) friends class <类名类名> 类名类名

C#中的静态成员、静态方法、静态函数之说.doc

C#中的静态成员、静态方法、静态函数之说.docC#静态成员I静态方法I静态构造函数一、静态成员(static)(1)静态成员属于类所有，非静态成员属于类的实例所有。

⑵ 每创建一个类的实例，都会在内存中为非静态成员新分配一块存储；非静态成员属于类所有，为各个类的实例所公用，无论类创建了多少实例，类的静态成员在内存中只占同一块区域。

二、静态方法(1)静态方法属于类所有，类实例化前即可使用。

(2)非静态方法可以访问类中的任何成员，静态方法只能访问类中的静态成员。

因为静态方法在类实例化前就可以使用，而类中的非静态变量必须在实例化之后才能分配内存，这样，静态方法调用时无法判断非静态变量使用的内存地址。

所以无法使用?而静态变量的地址对类来说是固定的，故可以使用。

三、静态构造函数(1)用于对静态字段、只读字段等的初始化。

⑵添加static关键字，不能添加访问修饰符，因为静态构造函数都是私自有的。

⑶ 类的静态构造函数在给定应用程序域中至多执行一次：只有创建类的实例或者引用类任何静态成员才激发静态构造函数?(4)静态构造函数是不可继承的，而且不能被直接调用。

⑸ 如果类中包含用来开始执行的Main方法，则该类的静态构造函数将在调用Main方法之前执行。

任何带有初始值设定项的静态字段，则在执行该类的静态构造函数时，先要按照文本顺序执行那些初始值设定项。

(6)如果没有编写静态构造函数，而这时类中包含带有初始值设定的静态字段，那么编译器会自动生成默认的静态构造函数。

(7)无参数的构造函数可以与静态构造函数共存。

尽管参数列表相同，但一个属于类，一个属于实例，所以不会冲突。

MSDN对静态构造函数的解释：静态构造函数用于初始化任何静态数据，或用于执行仅需执行一次的特定操作。

在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数。

静态构造函数具有以下特点：⑴静态构造函数既没有访问修饰符，也没有参数。

(2)在创建第一个实例或引用任何静态成员之前，将自动调用静态构造⑶函数来初始化羹。

C++中静态成员函数与非静态成员函数的区别

C++中静态成员函数与⾮静态成员函数的区别静态成员函数与⾮静态成员函数的区别数据成员：静态数据成员是类的⼀部分，为类的所有实例共享(静态区)；⾮静态数据成员，类的每个实例都有⼀份拷贝(动态区)。

静态数据成员的访问：静态数据成员是类的⼀部分，在产⽣任何实例之前已经存在，通过类名::静态成员变量名访问。

函数成员(都在代码区)：静态函数成员与⾮静态函数成员都为类所有，对象并不存在函数的拷贝。

静态成员函数和⾮静态成员函数的根本区别在于⾮静态函数由对象名.或者对象指针->调⽤，调⽤时编译器会向函数传递this指针；静态成员函数则有类名::或者对象名.调⽤，编译器不向函数传递this指针，不识别对象个体，经常⽤来操作类的静态数据成员，要访问类的⾮静态成员可以通过对象来实现。

内存⾓度分析：类的静态成员(数据成员和函数成员)为类本⾝所有，在类加载的时候就会分配内存，可以通过类名直接访问；⾮静态成员(数据成员和函数成员)属于类的实例所有，所以只有在创建类的实例的时候才会分配内存，并通过实例去访问。

注意：类的静态数据成员是静态存储，它是静态⽣存周期，必须进⾏初始化。

注意：静态数据成员的初始化在类体外进⾏，前⾯不加static以免与⼀般静态变量或者对象混淆。

静态成员函数访问⾮静态成员报错：类的静态成员在类加载的时候就已经分配内存，⽽此时类的⾮静态成员尚未分配内存，访问内存中不存在的东西⾃然会出错。

例⼦：#includeusing namespace std;class Test{public:Test(int a){ A = a; ++B;}static void smf(Test tt);private:int A;static int B;};void Test::smf(Test tt){cout << "tt.A : " << tt.A << endl; //静态成员函数中通过对象来引⽤⾮静态成员cout << "Test::B : " << Test::B << endl;cout << "tt.B : " << tt.B << endl;}int Test::B = 0; //静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值>int main(){Test t1(100);Test t2(200);Test::smf(t1);Test::smf(t2);//静态成员函数调⽤时不⽤对象名system("pause");return 0;}感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

静态函数静态数据成员与静态成员函数为什么虚函数必须是非静态成员函数构造函数能为static吗

静态函数静态数据成员与静态成员函数为什么虚函数必须是非静态成员函数构造函数能为static吗？2009-07-05 14:27静态函数用static声明的函数是静态函数。

静态函数可以分为全局静态函数和类的静态成员函数。

Static关键字在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份。

用static声明的方法是静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。

静态方法不再是针对于某个对象调用，所以不能访问非静态成员。

可以通过对象引用或类名（不需要实例化）访问静态成员C++类静态数据成员与类静态成员函数函数调用的结果不会访问或者修改任何对象（非static）数据成员，这样的成员声明为静态成员函数比较好。

且如果static int func(....)不是出现在类中，则它不是一个静态成员函数，只是一个普通的全局函数，只不过由于static的限制，它只能在文件所在的编译单位内使用，不能在其它编译单位内使用。

静态成员函数的声明除了在类体的函数声明前加上关键字static，以及不能声明为const或者volatile之外，与非静态成员函数相同。

出现在类体之外的函数定义不能制定关键字static。

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

在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据，那么我们会设立全局对象，但面向对象的程序是由对象构成的，我们如何才能在类范围内共享数据呢？这个问题便是本章的重点：声明为static的类成员或者成员函数便能在类的范围内共同享，我们把这样的成员称做静态成员和静态成员函数。

下面我们用几个实例来说明这个问题，类的成员需要保护，通常情况下为了不违背类的封装特性，我们是把类成员设置为protected（保护状态）的，但是我们为了简化代码，使要说明的问题更为直观，更容易理解，我们在此处都设置为public。

C++类静态成员与类静态成员函数=

C++类静态成员与类静态成员函数当将类的某个数据成员声明为static时，该静态数据成员只能被定义一次，而且要被同类的所有对象共享。

各个对象都拥有类中每一个普通数据成员的副本，但静态数据成员只有一个实例存在，与定义了多少类对象无关。

静态方法就是与该类相关的，是类的一种行为，而不是与该类的实例对象相关。

静态数据成员的用途之一是统计有多少个对象实际存在。

静态数据成员不能在类中初始化，实际上类定义只是在描述对象的蓝图，在其中指定初值是不允许的。

也不能在类的构造函数中初始化该成员，因为静态数据成员为类的各个对象共享，否则每次创建一个类的对象则静态数据成员都要被重新初始化。

静态成员不可在类体内进行赋值，因为它是被所有该类的对象所共享的。

你在一个对象里给它赋值，其他对象里的该成员也会发生变化。

为了避免混乱，所以不可在类体内进行赋值。

静态成员的值对所有的对象是一样的。

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

一般形式：数据类型类名：：静态数据成员名＝初值注意：不能用参数初始化表对静态成员初始化。

一般系统缺省初始为0。

静态成员是类所有的对象的共享的成员，而不是某个对象的成员。

它在对象中不占用存储空间，这个属性为整个类所共有，不属于任何一个具体对象。

所以静态成员不能在类的内部初始化，比如声明一个学生类，其中一个成员为学生总数，则这个变量就应当声明为静态变量，应该根据实际需求来设置成员变量。

#include "iostream"using namespace std;class test{private:int x;int y;public:static int num;static int Getnum(){x+=5; // 这行代码是错误的，静态成员函数不能调用非静态数据成员，要通过类的对象来调用。

num+=15;return num;}};int test::num = 10;int main(void){test a;cout<<test::num<<endl; //10test::num = 20;cout<<test::num<<endl; //20cout<<test::Getnum()<<endl; //35cout<<a.Getnum()<<endl; //50system("pause");return 0;}通过上例可知： x+=5; // 这行代码是错误的静态函数成员必须通过对象名来访问非静态数据成员。

静态数据成员课程设计

静态数据成员课程设计一、课程目标知识目标：1. 学生能够理解静态数据成员的概念，掌握其在类中的定义和使用方法。

2. 学生能够解释静态数据成员的内存分配特点，并了解其在程序中的作用和优势。

3. 学生能够区分静态数据成员与普通成员变量的不同之处，并掌握其访问方式。

技能目标：1. 学生能够运用静态数据成员编写简单的类和对象程序，实现对共享数据的操作。

2. 学生能够通过实际案例，学会使用静态数据成员解决实际问题，提高编程能力。

3. 学生能够运用静态数据成员进行类的封装，提高代码的可维护性和可读性。

情感态度价值观目标：1. 学生通过学习静态数据成员，培养对程序设计的好奇心和探究精神，增强学习兴趣。

2. 学生在团队合作中，学会倾听他人意见，提高沟通与协作能力。

3. 学生通过解决实际问题，认识到编程在实际生活中的应用价值，培养解决问题的能力和创新精神。

课程性质：本课程为计算机科学课程，旨在帮助学生掌握C++面向对象程序设计的基础知识，提高编程能力。

学生特点：学生处于高中阶段，已具备一定的编程基础和逻辑思维能力，对新鲜事物充满好奇心。

教学要求：结合学生特点和课程性质，采用案例教学、任务驱动等方法，引导学生主动探索，培养实践能力和创新精神。

通过分解课程目标为具体学习成果，为教学设计和评估提供依据。

二、教学内容1. 静态数据成员的定义与声明：介绍静态数据成员的概念、语法和基本使用方法，对比普通成员变量的特点。

- 教材章节：第三章“类的成员”2. 静态数据成员的内存分配与访问：分析静态数据成员在内存中的存储方式，讲解静态成员的访问控制。

- 教材章节：第三章“类的成员”3. 静态数据成员的应用实例：通过实际案例，展示静态数据成员在计数、统计等场景中的应用。

- 教材章节：第三章“类的成员”及第四章“类的实例”4. 静态成员函数与静态数据成员的关系：介绍静态成员函数的定义与使用，以及与静态数据成员的关联。

- 教材章节：第四章“类的实例”5. 静态数据成员的初始化：讲解静态数据成员的初始化方法，以及静态成员的构造和析构顺序。

静态成员和实例成员小结

静态成员：在类的成员的类型或者返回值类型前面加上关键字static，就可以将该成员定义为静态成员。

常量或类型声明会隐式地声明为静态成员，其他没有用static修饰的成员都是实例成员。

静态成员属于类，被这个类的所有实例所共享；实例成员属于对象（类的实例），每一个对象都有实例成员的不同副本。

下面看一下静态成员和实例成员的特点：静态成员：1>静态成员必须通过类名使用.运算符来引用，而不能用对象来引用。

2>一个静态字段只标识一个存储位置。

无论创建了一个类的多少个实例，它的静态字段在内存中都只占用同一块区域。

3>静态函数成员（方法，属性，事件，运算符或构造函数）不能作用于具体的实例，在这类函数成员中不能直接使用实例成员，必须通过类名来引用。

实例成员：1>实例成员必须通过对象名使用.运算符来引用，而不能用类名来引用。

2>类的实例字段属于类的实例所有，每创建一个类的实例，都在内存中为实例字段开辟了一块区域。

类的每个实例分别包含一组该类的所有实例字段的副本。

3>类的函数成员（方法，属性，索引器，实例构造函数或析构函数）作用于类的给定的实例，在它们的代码体内可以直接引用类的静态和实例成员。

下面用具体的代码来看它们的用法。

/**//* 要点：静态成员属于类，实例成员属于对象（类的实例）静态成员必须通过类名使用.运算符来引用，而不能用对象来引用实例成员必须通过对象名使用.运算符来引用，而不能通过类名来引用*/using System;usingSystem.Collections.Generic;usingSystem.Text;namespace ConsoleApplication5...{ class Program ...{ int x; //实例字段static int y; //静态字段void F() //实例方法...{x = 1; //正确，实例方法内可以直接引用实例字段y = 1; //正确，实例方法内可以直接引用静态字段}static void G() //静态方法...{// x = 1; //错误，静态方法内不能直接引用实例字段y = 1; //正确，静态方法内可以直接引用静态字段}static void Main(string[] args) //静态方法...{Program t = new Program(); //创建对象t.x = 1; //正确，用对象引用实例字段//t.y = 1; //错误，不能用对象引用实例字段//Program.x = 1; //错误，不能用类名引用实例字段Program.y = 1; //正确，用类目引用静态字段t.F(); //正确，用对象引用实例方法//t.G(); //错误，不能用对象名调用静态方法// Program.F(); //错误，不能用类目调用实例方法Program.G(); //正确，用类名调用静态方法}}}数据成员：数据成员可以分静态变量、实例变量两种.静态成员：静态成员变量是和类相关联的,可以作为类中"共"有的变量(是一个共性的表现),他不依赖特定对象的存在,访问的时候通过类名加点操作符加变量名来访问.实例成员：实例成员变量是和对象相关联的,访问实例成员变量依赖于实例的存在.函数成员：方法可以主要分为静态方法,实例方法静态方法：静态方法是不属于特定对象的方法，静态方法可以访问静态成员变量，静态方法不可以直接访问实例变量，可以在实例函数调用的情况下，实例变量做为参数传给静态方法。

c#static静态数据成员

c#static静态数据成员①静态成员属于类所有，⾮静态成员属于类的实例所有。

②每创建⼀个类的实例，都市在内存中为⾮静（动）态成员新分派⼀块存储；静态成员属于类所有，为各个类的实例所公⽤，⽆论类创建了⼏多实例，类的静态成员在内存中只占同⼀块区域。

静态数据成员区别于动态数据成员，静态变量并不是稳定的，只是静态变量在声明的时候不管有没有赋值，都市凭据它的类型分派对应的内存空间，他的可访问性和作⽤区间与动态变量是⼀样的==========================================================================关于C#中静态数据成员和静态要领的总结。

1.静态数据成员：界说：使⽤static关键字界说的数据成员被称为静态数据成员。

意义：静态数据成员所属类的所有实例都共享相同的静态成员值。

访问：实际上，静态成员并不属于某个实例，静态成员属于类。

因此，在使⽤静态成员的时候，不克使⽤实例名.静态成员名的形式，⽽应该使⽤类名.静态成员名来进⾏那个访问。

原因是因为静态变量没有this指针，只能通过类名引⽤。

内存分派：分派时间点 -> 静态数据成员与全局变量相似，它的内存分派产⽣在应⽤程序类实例化的时候，即程序运⾏期间，其释放在程序运⾏结束时，区别在于其作⽤域差别。

静态数据成员只作⽤在本⽂件内。

分派地点 -> 静态变量和要领在静态存储区分派内存，⽽⾮静态的在栈区或者堆上分派内存。

=====================================================================2.静态要领：界说：使⽤static关键字声明的要领被称为静态要领。

访问：同样是通过类名.要领名来访问。

简述访问规则：a.静态要领是不属于特定东西的要领，静态要领可以访问静态成员变量，静态要领不可以直接访问实例变量.假如在静态要领中访问⾮静态的成员，编译器不会去判定你是通过类直接挪⽤还是通过东西挪⽤，⼀概认为是⾮法的，因为他不克确定这个⾮静态的成员是否被分派了内存，他也懒得去确定。

C++class中的静态（static）成员

C++class中的静态（static）成员（1）静态数据成员①⼀般地静态数据成员在该类定义之外被初始化，如同⼀个成员函数被定义在类定义之外⼀样。

在这种定义中的静态成员的名字必须被其类名限定修饰，例如下⾯是_interestRate的初始化// 静态类成员的显式初始化#include "account.h"double Account::_interestRate = 0.0589;②静态数据成员的初始化不应该被放在头⽂件中，⽽应该放在含有类的⾮inline 函数定义的⽂件中。

静态数据成员可以被声明为任意类型。

例如：#include <string>class Account{// ...private:static const string name;};const string Account::name( "Savings Account" );作为特例，整型的const 静态数据成员可以在类体中⽤⼀常量值初始化。

例如，如果决定⽤⼀个字符数组⽽不是string 来存储账户的姓名那么我们可以⽤int 型的const 数据成员指定该数组的长度，例如：// 头⽂件class Account {// ...private:static const int nameSize = 16;static const char name[nameSize];};// ⽂本⽂件const int Account::nameSize; // 必需的成员定义const char Account::name[nameSize] = "Savings Account";⽤常量值作初始化整型的const 静态数据成员是⼀个常量表达式（constant expression）。

如果需要在类体中使⽤这个被命名的值，那么，类设计者可声明这样的静态数据成员。

c++讲义(9)静态成员

//程序：常数据成员的定义与初始化
#include <iostream.h> class A { private: const int x; //常数据成员 static const int y; //常静态成员 public: const int &r; //常引用成员 A(int i):x(i),r(x) { } //常数据成员的初始化在构造函数 void disp( ) { cout <<"x="<<x<<"\ty="<<y<<"\tr="<<r<<endl; } }; const int A::y=10; //常静态成员的初始化 void main() { A a1(1); A a2(2); a1.disp(); // x=1 y=10 r=1 a2.disp(); // x=2 y=10 r=2 }
Employee::Employee(char*n,float s)//构造函数的实现 { strcpy(name,n); salary=s; allSalary=allSalary+salary; }
float Employee::allSalary=0; //静态数据成员的初始化
void main() //主函数实现 { Employee e1("张三",1000); //声明对象e1 Employee e2("王五",2000); //声明对象e2 Employee e3("李四",1500); //声明对象e3 float all; all=Employee::GetAllSalary(); //计算总工资 cout<<"AllSalary="<<all<<endl; }

C++静态成员和静态成员函数

C++静态成员和静态成员函数⼀：静态数据成员：类体中的数据成员的声明前加上static关键字，该数据成员就成为了该类的静态数据成员。

和其他数据成员⼀样，静态数据成员也遵守public/protected/private访问规则。

同时，静态数据成员还具有以下特点：1、静态数据成员的定义。

静态数据成员实际是类域中的全局变量，其定义⽅式与全局变量相同。

例如：class base{private:static const int x;};const int base::x=10; //初始化时不受private和protected访问限制注意：不要试图在头⽂件中定义（初始化）静态数据成员。

2、静态数据成员被类的所有对象所共享，包括该类派⽣类对象。

即派⽣类与基类共享基类的静态数据成员。

这样的好处在于避免了基类和派⽣类重复定义相同的对象，节省内存空间。

例如：class base{public:static int x;};int base::x=0;class derived:public base{};int main(){base a;derived b;a.x++;cout << a.x <<endl;b.x++;cout << b.x <<endl;}///结果为1，2；可见基类和派⽣类公⽤⼀个静态数据成员。

3、静态数据成员可以成为成员函数的可选参数，⽽普通数据成员则不可以。

例如：class base{public:static int x;int y;void fx1(int i=x); //正确，x为静态数据成员void fx2(int i=y); //错误，y为普通数据成员};4、静态数据成员的类型可以是所属类的类型，⽽普通数据成员则不可以。

普通数据成员只能声明为所属类类型的指针或引⽤。

class base{public:static base x; //正确，静态数据成员base xx; //错误base *y; //正确，指针base &yy; //引⽤};5、静态数据成员的值在const成员函数中可以被合法的改变。

静态函数成员

静态函数成员静态函数成员静态成员函数可以直接访问该类的静态数据和函数成员。

⽽访问⾮静态成员，必须通过对象。

例：class A{public:static void f(A,a);private:int x;};void A::f(A,a){cout<<x; //对x的引⽤是错误的cout<<a.x; //正确}具体事例：#include "pch.h"#include <iostream>using namespace std;class point { //Point 类定义public: // 外部接⼝point(int x = 0, int y = 0) :x(x), y(y) { //构造函数//在构造函数中对count累加，所有对象共同维护同⼀个countcount++;}point(point &p) { //复制构造函数x = p.x;y = p.y;}~point() { count--; }int getx() { return x; }int gety() { return y; }static void showcount() { //静态函数成员cout << "obiect count=" << count << endl;}private: //私有数据成员int x, y;static int count; //静态数据成员声明，⽤于记录点的个数};int point::count = 0; //静态数据成员定义和初始化，实⽤类名限定int main() {point a(4, 5); //定义对象a，其构造函数会使count增1cout << "point a:" << a.getx() << "," << a.gety() << endl;point::showcount(); //输出对象个数point b(a); //定义对象b，其构造函数会使count增1cout << "point b:" << b.getx() << "," << b.gety() << endl;point::showcount(); //输出对象个数return 0;}编译结果：总结：采⽤静态函数成员的好处是可以不依赖于任何对象，直接访问静态数据。

6.5.1 静态数据成员_C++程序设计大学教程_[共2页]

程序的一组运行结果为：输入学生的人数（不大于100）：5输入第1个学生的姓名和年龄：zhao 22输入第2个学生的姓名和年龄：qian 20输入第3个学生的姓名和年龄：sun 20输入第4个学生的姓名和年龄：li 21输入第5个学生的姓名和年龄：zhou 22编号姓名年龄1 zhao 222 qian 203 sun 204 li 215 zhou 226.5 静态成员程序中定义类的目的是为了生成对象，当同一个类生成多个对象时，C++编译程序就为每个对象分配一块存储空间用于存储对象的成员。

其中每个对象的数据成员是各自独立的，而成员函数是所有对象公有的，每个对象的成员函数都通过一个指针指向成员函数的同一个代码空间。

当调用某个对象的成员函数时，系统会将this指针的值传送给该函数，以确保正确地访问该对象的数据。

此外，C++还有一种成员，称为静态成员。

类的静态成员是属于这个类的所有对象公有的，它包括静态数据成员和静态成员函数。

6.5.1 静态数据成员在类中定义静态数据成员的格式为class类名{ …static 数据类型说明符成员名;…};由此可看出，在类中定义静态成员的方法就是在该成员的前面加上关键字static。

【例6-10】分析以下程序的执行结果。

//Li6_10.cpp#include <iostream>using namespace std;class Sample{private:int x;public:static int y;Sample(int a){143。