以下类 MyClass 的属性 count 属于_____属性. class MyClass { int i; int count { get{ return i; } } }A．只读B．只写C．可读写D．不可读不可写

题目

以下类 MyClass 的属性 count 属于_____属性. class MyClass { int i; int count { get{ return i; } } }

A．只读

B．只写

C．可读写

D．不可读不可写

相似考题

1.以下类MyClass的属性count属于_____属性.classMyClass{inti;intcount{get{returni;}}}A.只读B.只写C.可读写D.不可读不可写

2.有如下类声明：class MyClass{int i;private: int j;protected:int k;public:int m, n;};其中，私有成员的数量为【 9 】。

3.有以下程序: include using namespace std; class MyClass { public: static int s; M有以下程序：include＜iostream＞using namespace std;class MyClass{public:static int s;MyClass();void SetValue(int val);};int MyClass::s=0;MyClass::MyClass(){S++;}void MyClass::SetValue(int val){s=val;}int main(){MyClass my[3],*p;p=my;for(int k=0;k＜3;k++){p-＞SetValue(k+1);p++;}cout＜＜MyClass::s＜＜end1;return 0;}运行后的输出结果是______。

4.类MyClass中,下列哪条语句定义了一个只读的属性Count?A.privateintCount;B.privateintcount;publicintCount{get{returncount;}}C.publicreadonlyintCount;D.publicreadonlyintCount{get{returncount;}set{count=value;}}

更多“以下类 MyClass 的属性 count 属于_____属性. class MyClass { int i; int count { get{ return i; } } }”相关问题

第1题：

下面程序的运行结果是【】。 inChlde using namespace std; class count { static int n;

下面程序的运行结果是【】。
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
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”。
第2题：

有如下程序: nclude using namespace Std; Class MyClass{ public:

有如下程序： #nclude＜iostream＞ using namespace Std； Class MyClass{ public： MyClass(int i=0){cout＜＜1;} MyClass(constMyClass&x){cout＜＜2；} MyClass& perator=(const MyClass&x){cout＜＜3；return*this;} ～MyClass(){cout＜＜4;} }； int main(){ MyClass obj1(1)，obj2(2)，obj3(obj1)； return 0： } 运行时的输出结果是( )。
A．112444
B．11114444
C．121444
D．11314444

正确答案：A
解析：此题考查的是函数重载。从主函数入手，定义了MyClass类的对象obj1(1)，obj2(2)和obj3(obj1)。其中对象obj1和obj2中的参数为整型，因此调用构造函数MyClass(int i=O){cout1小输出11；对象obj3中的参数为对象obj1，所以调用构造函数MyClass(const MyClass&x){cout2;}，输出2。在主函数退出时，调用析构函数～MyClassO{cout4;}，清除对象。obj1，obj2和obj3，因此输出444，即答案为选项A)。
第3题：

（ 29 ）已知类 MyClass 声明如下：
class MyClass{
int n;
public;
MyClass （ int k ）： n （ k ） {}
int getValue （） const{return n;}
};
在下列数组定义中正确的是
A ） MyClass x1[2];
B ） MyClass x2[2]={new MyClass （ 1 ）， new MyClass （ 2 ） };
C ） MyClass *x3[2];
D ） MyClass *x4[2]={MyClass （ 1 ）， MyClass （ 2 ） };

正确答案：C
第4题：

有如下程序: include using 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正确。
第5题：

有如下程序:includeusing namespace std;elass MyClass{public:MyClass( ){＋＋count;

有如下程序： #include＜lostreanl＞ using namespace std； elass 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＜＜MyCiass::getCount( )； return 0； } 程序的输出结果是
A．121
B．232
C．221
D．122

正确答案：A
第6题：

有以下程序:include using 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。
第7题：

类的说明如下，请指出错误的地方 ______。 class Myclass { int a=111； public： Myclass(int x, int y); Myclass(int val); ~Myclass(); }
A．int a=111;
B．Myclass(Int x, int y);
C．Myclass(int val);
D．~Myclass();

正确答案：A
第8题：

有以下程序: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 :: 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

正确答案：A
解析：程序首先定义了类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”。
第9题：

若有以下程序:include using namespace std;class myClass{private: int var;public:

若有以下程序： #include ＜iostream＞ using namespace std; class myClass { private: int var; public: myClass(int i) { var=i; } void add() { s+=var; } static int s; void display() { cout＜＜s＜＜end1; } }; int myClass::s=0; int main ( ) { myClass a(1),b(2),c(3); a.add(); b.add(); c.dislay(); return O; } 程序执行后的输出结果是( )。
A．1
B．4
C．3
D．7

正确答案：C
解析：本题考核静态数据成员的应用。解本题的关键是知道静态数据成员类中所有对象共享的成员。每个对象对静态数据成员的操作具有叠加效果。本题在类myClass中定义了一个静态数据成员s，其初始值为0。定义了3个对象a、b和c，并分别初始化各自的私有成员n为1、2和3。执行“a.add()；”语句后，静态数据成员s=1。再执行语句“b.add()；”后，s的值变为3。最后执行输出语句“c.display()；”，即输出s的值7。
第10题：

有以下程序include using 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
第11题：

类MyClass的定义如下： class MyClass { public： MyClass(){} MyClass(int i) { value=new int(i)； } int *value； }；若要对类中的value赋值，则下面的语句中，正确的是( )。
A．MyClass my;my.value=10；
B．MyClass my;*my,value=10；
C．MyClass my;my.*value=10；
D．MyClass my(10)；

正确答案：D
第12题：

有如下程序： #inClude<iostream> using namespaCe耐： Class MyClass{ publiC： MyClass{++Count；} ～MyClass{--Count；} statiC int getCount{retum Count；} private： statiC int Count； }； ‘ int MyClass：：Count=0； int main { MyClass obj； Cout<<obj．getCount； MyClass+ptr=new MyClass： Cout<<MyClass：：9etCount； ’delete ptr； Cout<<MyClass：：9etCount； return 0； } 执行这个程序的输出结果是( )。
A.121
B.232
C.221
D.122

正确答案：A
本题考查静态数据成员。静态数据成员在内存中只占一份空间，静态数据成员属于类，即使不定义对象，也会给静态数据成员分配空间，可以被引用。本题中先是定义了一个对象obj，执行构造函数使得静态数据成员count变为了l，然后又定义了指针对象，执行构造函数后，count变为了2，释放指针后，执行析构函数，使得count变为了1。所以本题答案为A。
第13题：

类MyClass的定如下，若要对value赋值，则下面语句正确的是( )。 class MyClass { public： MyClass(){} MyClass(int i){value＝new int(i)；} int*value； }；
A．MyClass my；my.value=10；
B．MyClass my；*my.value=10；
C．MyClass my；my.*value=10；
D．MyClass my(10)；

正确答案：D
解析：因题目中定义的指针value是指向变量i的，所以直接利用语句MyClass(int i){value=new int(i)；}对 value进行赋值即可。
第14题：

（ 27 ）有如下程序：
#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
第15题：

有如下类定义： ClaSS MyClass{ int value； public： MyClass(int n)：value(n){ } int getValue( )const{return value；} l；则类MyClass的构造函数的个数是
A．1个
B．2个
C．3个
D．4个

正确答案：A
解析：对于类的构造函数，如果有显式定义，那么在构造该类对象时就自动调用显式定义的构造函数，否则系统将给类一个默认的空构造函数。
第16题：

下列程序的输出结果是【】。 includeclass MyClass{public: int number; void set(in

下列程序的输出结果是【】。
include＜iostream. h＞
class MyClass
{
public:
int number;
void set(int i);
};
int number=3;
void MyClass: :set (int i)
{
number=i;
}
void main( )
{
MyClass my1；
int number=10;
my1.set(5),
cout＜＜my1, number＜＜',';
my1.set(number);
cout＜＜my1.number＜＜',';
my1.set(: :number);
cout＜＜my1.number＜＜'.';
}

正确答案：5103
5，10，3 解析：本题考查全局变量，局部变量和类的数据成员之间的使用上的差别。使用全局变量时需要用域作用符来限定该变量，否则编译器无法正确区分。
第17题：

有以下程序: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。
第18题：

下列程序段中，正确的是______。 ①class MvClass { int var = 100; static int getVar() { return var; } } ②public class MyClass { final int date; void MyClass (int d) { date = d; } } ③public class MyMain { public static void main(String args[]) { System.out.println(Myclass1.date); } } class MyClass1 { int data = 10; } ④class IamAbstract { final int f; double d; abstrct void method(); }
A．②④
B．①③
C．②
D．以上都不对

正确答案：D
第19题：

有如下类定义： Class MyClass{ int value； public： MyClass(int n): value(n){} int getValue()const{return value;} }；则类MyClass的构造函数的个数是
A．1个
B．2个
C．3个
D．4个

正确答案：A
第20题：

下面类的定义，有( )处错误。 class MyClass { public: void MyClass(); ～MyClass(int Value); private: int i=0; };
A．1
B．2
C．3
D．4

正确答案：C
解析：上述类的定义共有3处错误。第一处：类的成员变量不能在定义时进行初始化：第二处：类的构造函数不能有返回值(包括void类型)；第三处：类的析构函数不能有参数。
第21题：

如下的类定义，错误的语句是( )。class Myclass {public: int a=1; //A) Myclass( ); //B) Myclass(int i); //C) ～Myclass( ); //D)
A．A
B．B
C．C
D．D

正确答案：A
解析：类中的数据成员不能在定义类时直接赋初值。
第22题：

有如下程序: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对象。析
第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题：

有以下程序include using namespace std;class MyClass{public: MyClass(int n) { nu

有以下程序 #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(obj 1); obj2=fun(obj3); return 0; } 程序执行时，MyClass 类的拷贝构造函数被调用的次数是______ 次。
A．5
B．4
C．3
D．2

正确答案：B
解析：对象初始化和复制时，都要拷贝构造函数。所以程序执行一共调用了4次构造函数

niusouti.com

以下类 MyClass 的属性 count 属于_____属性. class MyClass { int i; int count { get{ return i; } } }A．只读B．只写C．可读写D．不可读不可写

题目

相似考题

更多“以下类 MyClass 的属性 count 属于_____属性. class MyClass { int i; int count { get{ return i; } } }”相关问题

相关内容