include<iostream>include<string>using namespace std;class MyClass{public:MyClass(int i=0){member=i;}void SetMember(const string m){member="big"+m;m=member;}string GetMember(){return member;}void print()const{cout<<"Stu:"<<member<<endl;}private:string memb
题目
include<iostream>
include<string>
using namespace std;
class MyClass
{
public:
MyClass(int i=0){member=i;}
void SetMember(const string m){member="big"+m;m=member;}
string GetMember(){return member;}
void print()const{cout<<"Stu:"<<member<<endl;}
private:
string member;
};
void main()
{
MyClass obj1,*obj2;
string i="wang lin";
obj2=&obj1;
obj2->SetMember(i);
obj1.print();
}
相似考题
更多“include<iostream>include<string>using namespace std;class MyClass{public: MyCl ”相关问题
-
第1题：
有如下程序: includeusing namespace std; class MyClass { public: 有如下程序： #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
正确答案：A
解析：本题考查的知识点是：静态成员。对于类中的非静态数据成员，每一个类对象都拥有一个拷贝(副本)，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。而类中的静态成员则是解决同一个类的不同对象之间的数据和函数共享问题的。静态成员的特性是不管这个类创建了多少个对象，它的静态成员都只有一个拷贝(副本)，这个副本被所有属于这个类的对象共享。这种共享与全局变量或全局函数相比，既没有破坏数据隐藏的原则，又保证了安全性。题目中，首先定义了一个obj对象，其构造函数使MyClass的静态数据成员count增1，所以第一条输出语句输出的结果是1。然后通过指针动态创建了一个MyClass类的对象，构造函数再次被调用，count变为2，所以第2次输出结果是2。接下来是用delete删除了刚才动态创建的MyClass对象，析构函数被调用，count减1变为1，第3次输出1。故本题的输出为121，选项A正确。 -
第2题：
已知下列程序的输出结果是23,请将横线处缺失的部分补充完整。 includeusing namespace 已知下列程序的输出结果是23，请将横线处缺失的部分补充完整。
include＜iostream＞
using namespace std;
class MyClass{
public:
void Print()const{cout＜＜23;}
};
int main(){
MyClass*p=new MyClass();
______.Print();
return 0;
}
正确答案：(*p)
(*p) 解析：此题考查的知识点是成员函数的调用。通过对象调用成员函数使用“.”运算符，而通过对象的指针调用成员函数则使用“-＞”运算符。题目中，Print()函数之前已经有一个“.”，所以此处应填入一个对象，所以就把指针p转化成指针所指的对象，填入表达式(*P)。 -
第3题：
以下程序的执行结果为______。includeusing namespace std; class base { public: vir 以下程序的执行结果为______。
include＜iostream＞
using namespace std;
class base
｛
public：
virtual void who()
｛
cout＜＜"base class"＜＜endl;
｝
｝;
class derivel：public base
｛
public：
void who()
｛
cout＜＜"d
正确答案：base class derivel class derive2 class
base class derivel class derive2 class -
第4题：
有如下程序: includeusing namespace std; class A { public: 有如下程序： #include＜iostream＞ using namespace std; class A { public: A(){cout＜＜"A";} }; class B＜public:B(){cout＜＜"B";)); class C:public A { B b; public: C(){cout＜＜"C";} }; int main(){Cobj;retum 0;} 执行后的输出结果是
A．CBA
B．BAC
C．ACB
D．ABC
正确答案：D
解析：本题考查基类构造函数，数据成员构造函数的调用次序。系统首先要通过派生类的构造函数调用基类的构造函数，对基类成员初始化：然后对派生类中新增的成员初始化。 -
第5题：
有以下程序:includeusing namespace std; class Base { public: Base() { K=0; } int 有以下程序：
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。
20。 解析： 本题中，虽然Derived1和Derived2由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1中修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obi；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x＝20。最后输出x的值为20。 -
第6题：
有以下程序:includeusing namespace std;class MyClass{public: MyClass(); ~MyClass 有以下程序： #include＜iostream＞ using namespace std； class MyClass { public： MyClass()； ～MyClass()； void SetValue(int val)； private： static int i； }； int MyClass：：i=0； MyClass：：MyClass() { i++； cout＜＜i； } MyClass：：～MyClass() { i--； cout＜＜i； } void MyClass：：SetValue(int val) { i=val； } int main() { MyClass*my[2]； int k； for(k=0；k＜2；k++) my[k]=new MyClass； for(k=0；k＜2；k++) delete my[k]； return 0； } 运行后的输出结果是( )。
A．1210
B．1100
C．1234
D．输出结果不确定
正确答案：A
解析：类MyClass中变量i是静态数据成员，它被MyClass类的所有对象共享，但它不属于任何一个对象，它的作用域是类范围。程序i是用来统计类MyClass所创建对象的个数，每创建一个对象i加1，每删除MyClass类对象i减1。 -
第7题：
有如下程序: includeusing namespace std; class PARENT { public: PARENT() { cout 有如下程序：
include ＜iostream＞
using namespace std;
class PARENT
{
public:
PARENT() { cout ＜＜"PARENT"; }
};
class SON : public PARENT
{
public:
SON() {cout ＜＜ "SON"; }
};
int main()
{
SON son;
PARENT *p;
p = &son;
return 0;
}
执行上面程序的输出是______。
正确答案：PARENTSON
PARENTSON 解析：此题考查的是派生类的构造。主函数开始在定义SON类的对象son时，会先执行PARENT类的构造函数再执行SON类的构造函数，输出 “PAKENTSON”；接下来的语句定义PARENT和让指针p指向son对象，都并未创建任何对象，所以不会调用构造函数。故最终的输出结果是：PARENTSON。 -
第8题：
有如下程序:includeusing namespace std;class AA{public: virtual void f() {cout< 有如下程序: #include ＜iostream＞ using namespace std; class AA { public: virtual void f() { cout＜＜ "AA"; } }; class BB : public AA { public: BB() { cout ＜＜ "BB"; } }; cla
A．AA
B．AABBCC
C．BBAABBCC
D．BBBBAACC
正确答案：D
解析：本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。最后执行语句“p=&cc； p-＞f()；”，输出AA和CC。 -
第9题：
下面程序的运行结果为( )。 includeusing namespace std; class A{ pu 下面程序的运行结果为( )。 #include ＜iostream＞ using namespace std； class A{ public： A(){cout＜＜" "；} ～A(){cout＜＜" "；} } class B：public A{ public： B(){cout＜＜" "；} ～B(){cout＜＜" "；} } void main(){ B b； }
A．1234
B．1324
C．1342
D．3142
正确答案：C
解析：构造函数和析构函数系统可以自动调用。先执行其基类构造函数，输出1；执行派生类的构造函数，输出3；执行派生类析构函数，输出4；执行基类析构函数，输出2。 -
第10题：
有下列程序: includeusing namespace std; class Base { public: Base(){cout<<"B 有下列程序： #include＜iosteram.h＞ using namespace std; class Base { public: Base(){cout＜＜"BB"; f(); } void f(){cout＜＜"Bf";} }; class Derived:public Base { public: Derived(){cout＜＜"D
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf
正确答案：A
解析： 此题考查的是类的继承和派生。派生类执行构造函数的一般次序：首先调用基类构造函数；然后调用成员对象的构造函数；最后是派生类构造函数中的内容。题目中定义派生类对象d时，先调用基类Base的构造函数，输出BBBf，然后调用派生类Derived的构造函数，输出DD。 -
第11题：
有如下程序:includeusing namespace std;class MyClass{public:MyClass(){＋＋count;}~ 有如下程序： #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
正确答案：A
解析： 本题考查的知识点是静态成员。类中的静态成员是解决同—：个类的不同对象之间的数据和函数共享问题的。静态成员被所有属于这个类的对象共享。这种共享与全局变量或全局函数相比，既没有破坏数据隐藏的厚则，又保证了安全性。题目中，首先定义了一个obj对象，其构造函数使MyClass的静态数据成员count增1,所以第一条输出语句输出的结果是1。然后通过指针动态创建了一个MyClass类的对象，构造函数再次被调用，count变为2，所以第2次输出结果是2。接下来是用dilete删除了刚才动态创建的MyClass对象。析 -
第12题：
有以下程序includeusing namespace std;class MyClass{public:MyClass(int n){number 有以下程序 #include＜iostream＞ using namespace std； class MyClass { public： MyClass(int n){number =n； } //拷贝构造函数 MyClass(MyClass& other) {number=other．number；} ～MyClass() {} private： int number； }； MyClass fun(MyClass p) { MyClass temp(p)； return temp； } int main() { MyClass Obj1(10)，obj2(0)； MyClass obj3(obj1)； obj2=fun(obj3)； return 0； } 程序执行时，MyClass类的拷贝构造函数被调用的次数是
A．5
B．4
C．3
D．2
正确答案：B
解析：本题考核C++的拷贝构造函数。调用拷贝构造函数的情况为：一个新对象被另一个已存在的同类型对象初始化；当一个对象作为实参传递给函数时为初始化形参，要调用拷贝构造函数。在函数值返回时形参的生命期结束时它的析构函数被调用；在函数返回一个对象时调用拷贝构造函数。符合以上条件的有：用对象obj1来初始化obj3；obj3作为实参被传入；函数fun返回一个对象时；系统用返回值初始化一个匿名对象时调用了拷贝构造函数。总共调用4次。 -
第13题：
有如下程序:includeusing namespace std;class MyClass{public:MyClass(int x):val(x 有如下程序： #include＜iostream＞ using namespace std； class MyClass{ public： MyClass(int x)：val(x){} void Print()const{cout＜＜“const：val＝”＜＜＜val＜＜‘\’；} void Print(){cout＜＜“val＝”＜＜val＜＜‘t’；} private： int va1； }； int main(){ cons
A．val＝10 const：val＝20
B．const：val＝10 const：val＝20
C．const：val＝10 val＝20
D．val＝10 val＝20
正确答案：B
解析： 本题考查提派生类中构造函数的定义。派生类的构造首先要调用基类的构造函数，对基类成员初始化；然后对派生类中的新增成员初始化。格式：派生类名(构造函数形参表)基类构造函数(形参表)。 -
第14题：
有下列程序:includeusing namespace std; class TestClass1 { public: TestClass1(){ 有下列程序：
include＜iostream＞
using namespace std;
class TestClass1
{
public:
TestClass1(){cout＜＜"A";}
};
class TestClass2＜public:TestClass2(){cout＜＜"B";}
};
class TestClass3:public TestClass1{
TestClass2 b;
正确答案：ABC
ABC 解析： 主函数中定义TestClass3对象。obj，其中TestClass3继承于TestClass1，先初始化基类构造函数，所以输出A。然后在TestClass3中定义TestClass2对象b，输出B，最后派生类的构造函数输出C。所答案为ABC。 -
第15题：
在下面程序的横线处填上适当的语句,使该程序执行结果为10。 includeusing namespace 在下面程序的横线处填上适当的语句，使该程序执行结果为10。
include ＜iostream＞
using namespace std；
class MyClass
{
public：
MyClasS(int A)
{
X=a；
}
【 】//取x的值
private：
int x；
}；
int main()
{
MyClass my(10)；
正确答案：int GetNum(){return x；}
int GetNum(){return x；} 解析：由主函数中调用对象my成员函数GetNum()可得到，成员函数GetNum()的功能是返回其私有数据成员x的值。 -
第16题：
有如下程序: includeusing namespace std; class BASE { public 有如下程序： #include＜iostream＞ using namespace std; class BASE { public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE { public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVEDx;retum 0;} 执行后的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：本题考查基类析构函数和派生类析构函数的调用次序。 -
第17题：
有如下程序:includeusing namespace std;class BASE{public:~BASE(){cout<<"BASE";} 有如下程序： #include ＜iostream＞ using namespace std; class BASE{ public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE{ public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVED x;return 0;} 执行后的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：本题考核派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。所以当main函数结束时，派生类DERIVED的对象x将被删除，那么派生类DERIVED的析构函数先被调用，输出DERIVED，然后调用基类的析构函数输出BASE。 -
第18题：
有以下程序:includeusing namespace std;class myclass{private: int a,b;public: v 有以下程序： #include ＜iostream＞ using namespace std; class myclass { private: int a, b; public: void init( int i, int j ) { a = i; b = j; } friend int sum( myclass x ); }; int sum( myclass x ) { return x.a + x.b; } int main () { myclass y; y.init( 15, 20 ); cout＜＜sum( y )＜＜end1; return 0; } 执行后的输出结果是( )。
A．15
B．20
C．5
D．35
正确答案：A
解析：本题主要考察C++中友元函数的使用。程序中，首先定义一个myclass类，其中包含private类型数据成员inta和intb；并含有成员函数voidinit()，其功能为初始化数据成员a和b，使其值分别为a=i和b=i；同时声明了一个友元函数intsum()，其函数定义在类声明体外，功能为返回myclass类的对象中的两个数据成员之和。程序主函数中，首先创建一个myclass类的对象y，并调用y的初始化函数对其变量进行赋值操作，执行该语句后，应该有：y.a=15和y.b=20。程序最后调用函数sum()计算对象y中数据成员的和，由于sum()为类myclass的友元函数，因此其可以自由访问对象y中的数据成员，显然其返回值为：15+20=35。 -
第19题：
有以下程序:includeusing namespace std;class MyClass{public:MyClass(int n){numbe 有以下程序： #include＜iostream＞ using namespace std； class MyClass { public： MyClass(int n){number=n；} //拷贝构造函数 MyClass(MyClass&other) {number＝other.number；} ～MyClass() {} private： int number； }； MyClass fun(MyClass p)
A．5
B．4
C．3
D．2
正确答案：B
解析： 调用拷贝构造函数的情况为：一个新对象被另一个已存在的同类型对象初始化，当一个对象作为实参传遵给函数时为初始化形参，要调用拷贝构造函数。在函数值返回时形参的生命期结束时它的析构函数被调用，在函数返回一个对象时调用拷贝构造函数。符合以上条件的有：用对象obj1来初始化obj3;obj3作为实参被传入，函数fun返回一个对象时，系统用返回值初始化一个匿名对象时调用了拷贝构造函数。总共调用4次。 -
第20题：
有下列程序:includeusing namespace std;class ONE{ public:virtual void f(){COUt<<" 有下列程序：
include＜iostream＞
using namespace std;
class ONE
{
public:
virtual void f(){COUt＜＜"1";}
};
c1assTWO:public ONE
{
public:
TWO(){cout＜＜"2";}
};
class THREE:public TWO
{
pub
正确答案：2213
2213 解析： 此题考查的是派生类的构造和析构函数。建立TWO的对象bb时，调用TWO的构造函数，输出“2”；THREE类又派生于TWO类，所以建立THREE类的对象cc时又会输出“2”；ONE类的对象指针p指向了THREE类的ONE类的虚函数f()，输出“1”；最后调用THREE类的f()，输出“3”。故最终的输出结果是2213。 -
第21题：
有以下程序includeusing namespace std;class MyClass{public:MyClass(int n) { num 有以下程序#include ＜iostream＞using namespace std;class MyClass{public: MyClass(int n) { number=n; } //拷贝的构造函数 MyClass(MyClass& other) {number=other. number; } ～MyClass() { }private: int number;};MyClass fun(MyClass p){ MyClass temp(p); return temp;}int main() MyClass obj 1 (10), obj 2(0); MyClass obi 3 (obj 1); obj2=fun(obj3); return 0;}程序执行时，MyClass 类的拷贝构造函数被调用的次数是( )。
A．5
B．4
C．3
D．2
正确答案：B
-
第22题：
有如下程序includeinclude using namespace std;class MyClass {public:M 有如下程序#include ＜iostream＞#include ＜iomanip＞using namespace std; class MyClass {public:MyClass(){ cout＜＜'A'; }MyClass(char c){ cout＜＜c; }～MyClass(){ cout＜＜'B'; }};int main() {MyClass p1,*p2;p2=new MyClass('X');delete p2;return 0;}执行这个程序屏幕上将显示输出( )。
A．ABX
B．ABXB
C．AXB
D．AXBB
正确答案：D
-
第23题：
如下程序的输出结果是includeusing namespace std;class MyClass{public:MyClass(int 如下程序的输出结果是 #include＜iostream＞ using namespace std； class MyClass{ public： MyClass(int i=0){cout＜＜1；} MyClass(const MyClass＆x)}cout＜＜2；} }； int main( ){ MyClass objl(1)，obj2(2)，ohj3(objl)； return 0； }
A．112
B．111
C．121
D．113
正确答案：A
解析：MyClass objl(1)，ohj2(2)，obj3(objl)；创建objl和obj2对象时调用第一个构造函数，打印1，创建obj3对象时调用第二个构造函数，打印2。 -
第24题：
有如下程序:includeusing namespace std;class A{public:A(){cout<<"A";}};class B 有如下程序： #include ＜iostream＞ using namespace std; class A { public: A(){cout＜＜"A";} }; class B {public:B(){cout＜＜"B";} }; class C:public A { B b; public:C(){cout＜＜"C";} }; int main(){C obj;return 0;} 执行后的输出结果是( )。
A．CBA
B．BAC
C．ACB
D．ABC
正确答案：D