计算机二级
有以下程序:include using namespace std;class count{ static int n;public: count有以下程序： #include ＜iostream＞ using namespace std; class count { static int n; public: count ( ) { n++; } static int test() { for (int i = 0; i ＜ 4; i++ ) n++; return n; } }; int count
题目
有以下程序： #include ＜iostream＞ using namespace std; class count { static int n; public: count ( ) { n++; } static int test() { for (int i = 0; i ＜ 4; i++ ) n++; return n; } }; int count :: n = 0; int main() { cout＜＜count :: test()＜＜" "; count c1, c2; cout＜＜count :: test()＜＜end1; return 0; } 执行后的输出结果是( )。
A．4 10
B．1 2
C．22
D．24
参考答案和解析
解析：程序首先定义了类count，其内部含有private类型数据成员“staticintn；”，同时含有public类型构造函数count()和静态成员函数staticinttest()，这两个函数的功能分别是为对象申请系统资源并将静态数据成员n加1和将静态数据成员n加4。主函数前，程序将静态数据成员n初始化为0，该数据成员为所有类count的对象所共有的数据成员。主函数中，程序首先执行静态成员函数test()(由于test声明为static，因此其调用时无需通过具体对象)。而其执行过程中，静态数据成员n应该加4变成n=4，因此此处输出为4。此后程序创建对象c1和c2，由于在每次创建过程中都要调用构造函数count()，而每次调用count()函数后，静态数据成员n值都会加1，因此，创建两个对象之后，n值变为n=6；再次执行test()函数后，n的值再次加4，此时变为n=6+4=10。故程序全部执行后，变量n值变为10，而中间程序输出为“410”。
相似问题和答案
第1题：
【说明】
以下C++代码实现一个简单绘图工具，绘制不同形状以及不同颜色的图形。部分类及其关系如图6－1所示。
【C++代码】
#include?#include?using?namespace?std;class?DrawCircle?{??????//绘制圆形，抽象类? ? ? public: （1）；//定义参数为?int?radius,?int?x,?inty? ?virtual～DrawCircle()?{?}};class?RedCircle：public?DrawCircle?{????//绘制红色圆形? ? ? ? public: void?drawCircle(intradius,?int?x,?int?y)?{cout?<?drawCircle?=?drawCircle;? }? ?virtual～shape()?{?}? public:? ?virtual?void?draw()?=?0;};class?Circle：public?Shape?{????//圆形? ? private:? ? ?int?x,y,radius;? ? public:? Circle(int?x,inty,int?radius,DrawCircle?*drawCircle)? （3）? {? this->x?=?x;? ?this->y?=?y;? ? this->radius?=?radius; }? ? ? public:? void?draw(){? drawCircle?-> （4）; }};int?main(){Shape?*redCirclenew?Circle(100,100,10,????（5）????);//绘制红色圆形? Shape?*greenCircle＝new?Circle(100,100,10, （6）??);//绘制绿色圆形redCircle >draw();? ?greenCircle?->draw();? ?return?0;}
（2）DrawCircle*drawCircle
（3）drawcircle
（4）drawCircle(radius,x,y)
（5）new RedCircle()
（6）new GreenCircle()【解析】
第一空是填接口里面的方法，在接口的实现里面找，可以发现应该填void drawCircle (int radius,int x,int y)。
第二空可以根据后面this drawCircle=drawCircle判断，这里应该有一个drawCircle属性，因此应该填）DrawCircle drawCircle。
第三空这里填drawcircle，用-> drawcircle来引用父类的成员。
第四空调用drawCircle(radius,x,y)方法。
第五、六空分别创建一个红色圆形对象和一个绿色圆形对象作为Circle里面的实参。
第2题：
有如下程序： #include＜iostream＞ using namespace std； class Toy{ public： Toy(char*_n){strcpy(name，_n)；count++；} ～Toy(){count--；} char*GetName( ){return name；} static int getCount( ){return count；} private： char name[10]； static int count； }； int Toy::count=0： int main( ){ Toy tl("Snoopy")，t2("Mickey")，t3("Barbie")； cout＜＜t1．getCount( )＜＜endl； return 0； } 程序的输出结果是
A．1
B．2
C．3
D．运行时出错
解析：静态数据成员是同一个类的不同对象之间的数据共享，无论创建多少个类，均只有一个静态数据成员，通过对静态数据成员的调用，实现了数据共享。本题创建了3个Toy对象，所以调用3次构造函数，count被增加3次，故sount=3。
第3题：
有如下程序： #include＜iostream＞ using namespace std； class MyClass{ public： MyClass(){++count；} ～MyClass(){--count；} static int getCount(){return count；} private： static int count； }； int MyClass：：count=0； int main(){ MyCl
A．121
B．232
C．221
D．122
解析： 本题考查的知识点是静态成员。类中的静态成员是解决同—：个类的不同对象之间的数据和函数共享问题的。静态成员被所有属于这个类的对象共享。这种共享与全局变量或全局函数相比，既没有破坏数据隐藏的厚则，又保证了安全性。题目中，首先定义了一个obj对象，其构造函数使MyClass的静态数据成员count增1,所以第一条输出语句输出的结果是1。然后通过指针动态创建了一个MyClass类的对象，构造函数再次被调用，count变为2，所以第2次输出结果是2。接下来是用dilete删除了刚才动态创建的MyClass对象。析
第4题：
有以下程序：
include＜iostream＞
using namespace std；
class Base
{
public：
Base()
{
K＝0；
}
int x；
}；
class Derivedl：virtual public Base
{
public：
Derivedl()
{
x＝10；
}
}；
class Derived2：virtua1 public Base
20。 解析： 本题中，虽然Derived1和Derived2由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1中修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obi；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x＝20。最后输出x的值为20。
第5题：
有如下程序：
include＜iostream＞
using namespace std；
class pumpkin{
public：
pumpkin(){++count;}
～pumpkin(){--count;}
static void total_count(){
cout＜＜count＜＜"pumpkin(s)"＜＜end1；
}
private：
static int count；
}；
int pumpkin::count=0；
int main(){
pumpkin p1[10]；
pumpkin::total_count()；
return 0；
}
这个程序的输出结果是______。
10pumpkin(s) 解析：此题考查的是静态数据成员。题目中count数据成员要定义成静态的，静态数据成员是类中所有对象共享的成员，而不是某个对象的成员。本题中，pumpkin类定义了一个静态数据成员count，并初始化为0。在主函数中，首先定义了该类对象p1[10]，所以构造函数被调用10次，count累加1十次；然后调用函数total count()，通过函数该输出count的值10。total count()函数结束，对象被释放，故析构函数被调用了10次，count变成0。
第6题：
下面程序的运行结果是【 】。
include ＜iostream＞
using namespace std;
class count
{
static int n;
public:
count()
{
n++;
}
static int test()
{
for(int i=0;i＜4;i++)
n++;
return n;
}
};
int count::n = O;
int main()
{
cout＜＜count:: test()＜＜" ";
count c1, c2;
cout＜＜count:: test()＜＜endl;
return 0;
}
410 解析：本题主要考查C++类中静态数据成员的使用。题目程序首先定义了类count，其内部含有private 类型数据成员static int n；同时含有public 类型构造函数 count()和静态成员函数static int test()，这两个函数的功能分别是为对象申请系统资源并将静态数据成员n加1和将静态数据成员n加4。主函数前，程序将静态数据成员n初始化为0，该数据成员为所有类count 的对象所共有的数据成员；主函数中程序首先执行静态成员函数test() (由于test 声明为 static，因此其调用时无需通过具体对象)，其执行过程中，静态数据成员n应该加4变成n：4，因此此处输出为4；此后程序创建对象c1和c2，由于在每次创建过程中都要调用构造函数count()，而每次调用count()函数后，静态数据成员n值都会加1。因此，创建两个对象之后，n值变为n=6：再次执行test()函数后，n的值再次加4，因此变为n=6+4=10。故程序全部执行后，变量n值变为10，而中间程序输出为“410”。
第7题：
有如下程序： #include ＜iostream＞ using namespace std; class MyClass { public: MyClass() { ++count; } ～MyClass() { --count; } static int getCount() { return count; } private: static int count; }； int MyClass::count=0; int main() { MyClass obj; cout＜＜obj.getCount(); MyClass *ptr=new MyClass; cout＜＜MyClass::getCount(); delete ptr; cout＜＜MyClass::getCount(); return 0; }程序的输出结果是
A．121
B．232
C．221
D．122
解析：本题考查的知识点是：静态成员。对于类中的非静态数据成员，每一个类对象都拥有一个拷贝(副本)，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。而类中的静态成员则是解决同一个类的不同对象之间的数据和函数共享问题的。静态成员的特性是不管这个类创建了多少个对象，它的静态成员都只有一个拷贝(副本)，这个副本被所有属于这个类的对象共享。这种共享与全局变量或全局函数相比，既没有破坏数据隐藏的原则，又保证了安全性。题目中，首先定义了一个obj对象，其构造函数使MyClass的静态数据成员count增1，所以第一条输出语句输出的结果是1。然后通过指针动态创建了一个MyClass类的对象，构造函数再次被调用，count变为2，所以第2次输出结果是2。接下来是用delete删除了刚才动态创建的MyClass对象，析构函数被调用，count减1变为1，第3次输出1。故本题的输出为121，选项A正确。
第8题：
下面程序的运行结果是【 】。
inChlde＜iOStream＞
using namespace std；
class count
{
static int n；
public：
count()
{
n++；
}
static int test()
{
for(int i=0：i＜4；i++)
n++；
return n；
}
}；
int count::n=0；
int main()
{
cout＜＜COUnt::test()＜＜" "；
count c1, c2;
cout＜＜count::test()＜＜end1;
return 0;
}
4 10 解析：本题主要考查C++类中静态数据成员的使用。题目程序首先定义了类count，其内部含有private类型数据成员static int n；同时含有public类型构造函数count()和静态成员函数static int test()，这两个函数的功能分别是为对象申请系统资源并将静态数据成员n加1和将静态数据成员n加4。主函数前，程序将静态数据成员n初始化为0，该数据成员为所有类count的对象所共有的数据成员：主函数中程序首先执行静态成员函数test()(由于test声明为static，因此其调用时无需通过具体对象)，其执行过程中，静态数据成员n应该加4变成n=4，因此此处输出为4：此后程序创建对象c1和c2，由于在每次创建过程中都要调用构造函数count()，而每次调用 count()函数后，静态数据成员n值都会加1因此，创建两个对象之后，n值变为n= 6：再次执行test()函数后，n的值再次加4，因此变为n=6+4=10。故程序全部执行后，变量n值变为10，而中间程序输出为“410”。
第9题：
如下程序的输出结果是______。
include＜iostream＞
using namespace std；
class pumpkin{
public：
pumpkin( ){++count；}
～pumpkin( ){--eount；}
static void total_count( ){cout＜＜count＜＜"pumpkin(s)"＜＜endl；}
private：
static int count；
}；
int pumpkin::count=0；
int main( ){
pumpkin pl[10]；
pumpkin::total_count( )；
return 0；
}
10pumpkin(s) 解析：在主函数中pumpkin pl[10]；定义了一个有10个元素的对象数组，所以调用了10次构造函数，静态数据成员court累加了10次，pumpkin::total_count( )；显式调用类成员函数，直接调用静态成员函数：total_count( )，打印pumpkin(s)。