单选题有如下程序：程序的输出结果是（　　）。A val=10　const：val=20B const：val=10　const：val=20C const：val=10　val=20D val=10　　val=20

题目
单选题
有如下程序：程序的输出结果是（　　）。
A

val=10　const：val=20

B

const：val=10　const：val=20

C

const：val=10　val=20

D

val=10　　val=20

相似考题

1.有如下程序：#includeusing namespace std;int main(){void function(double val);double val;function(val);cout<return 0;}void function(double val){val = 3;}编译运行这个程序将出现的情况是A ．编译出错，无法运行B ．输出： 3C ．输出： 3.0D ．输出一个不确定的数

2.以下程序段的输出结果是[ ]。 include void ref(int &i); void main(){int val=1以下程序段的输出结果是 [ ] 。include＜iostream.h＞void ref(int &i);void main(){int val=1;cout＜＜“旧值：”＜＜val＜＜end1；ref(val)；cout＜＜”新值：”＜＜val＜＜end1；}void ref(int &i){i=10；}

3.（ 28 ）有如下程序：#include<iostream>using namespace std;class MyClass{public:MyClass(int x):val(x) {}void Print() const {cout<<"const:val="<<val<<'\t';}void Print(){cout<<"val="<<val<<'t';}private:int val;};int main(){const MyClass obj1(10);MyClass obj2(20);obj1.Print();obj2.Print();return 0;}程序的输出结果是A ） val=10 const:val=20B ） const:val=10 const:val=20C ） const:val=10 val=20D ） val=10 val=20

4.执行以下程序段后，变量e的值是______。a＄="3"：b＄="5"c=Val(a＄)+Val(b＄)d=Val(a＄+b＄)e=c+d

更多“单选题有如下程序：程序的输出结果是（　　）。A val=10　const：val=20B const：val=10　const：val=20C const：val=10　val=20D val=10　　val=20”相关问题

  • 第1题：

    有如下程序: include using namespace std; class Part{ public:

    有如下程序： #include ＜iostream＞ using namespace std; class Part{ public: Part(int x=0):val(x) { cout＜＜val; } ～Part() { cout＜＜val; } private: int val; }; class Whole { public: Whole(int x, int y, int z=0):p2(x),p1 (y),val(z) { cout＜＜val; } ～whole() { cout＜＜val; private: Part p1,p2; int val; }; int main() { Whole obj (1,2,3); return 0; }程序的输出结果是

    A．123321

    B．213312

    C．213

    D．123123


    正确答案：B
    解析：本题考查的知识点是：类的构造与析构。建立一个类的对象时，构造函数的执行顺序如下：
    ①执行基类的构造函数，调用顺序按照各个基类被继承时声明的顺序(自左向右)；
    ②执行成员对象的构造函数，调用顺序按照各个成员对象在类中声明的顺序(自上而下：(如果一行声明了多个对象，则还要遵循自左向右)
    ③执行自身的构造函数。
    析构顺序与之相反。本题的Whole类没有基类，但有两个Part类的成员p1和p2。根据它们定义的顺序，应该先构造p1再构造p2，而不是按Whole的构造函数中初始化列表的顺序那样构造。所以，第1个被构造的是p1(y)，输出一个2；第2个被构造的是p2(x)，输出一个1；最后调用自身构造函数，输出val的值3。析构函数严格与之相反。故输出结果为213312，本题应该选择B。

  • 第2题：

    有如下程序: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
    解析： 本题考查提派生类中构造函数的定义。派生类的构造首先要调用基类的构造函数，对基类成员初始化；然后对派生类中的新增成员初始化。格式：派生类名(构造函数形参表)基类构造函数(形参表)。

  • 第3题：

    有如下程序:includeusing namespace std;class Part{public:Part(int x=0):val(x){co

    有如下程序： #include＜iostream＞ using namespace std； class Part{ public： Part(int x=0)：val(x){cout< ～Part( ){cout＜＜val；} pritave： int val； }； class Whole{ public： Whole(int x，int Y，int z=0)：p2(x)，p1(Y)，val(z){cout＜＜val；} ～Whole( ){cout＜＜val；} pritave： Part p1，p2； int val； f； int main( ){ Whole obj(1，2，3)； return 0； } 程序的输出结果是

    A．123321

    B．213312

    C．213

    D．123123


    正确答案：B
    解析：当类中出现其他类的对象时，先对该对象初始化，即调用对象类的构造函数，然后调用本类的构造函数；进行撤销时，先调用本类的析构函数，然后再调用类中对象所对应的类的析构函数。对象的创建顺序和构造函数声明中的参数顺序无关，而同类中定义的先后顺序有关。故先创建p1，再创建p2，撤销时先撤销p2，再撤销p1。 

  • 第4题：

    下列程序的运行结果为【 】。

    A="1"

    B="2"

    A=Val(A) +Val(B)

    B=Val("12")

    If A＜＞B Then Print A-B Else Print B-A


    正确答案：～9
    ～9 解析：本题考查Val函数的用法。Val函数是返回字符串内的数字，因此 A=Val(A) +Val(B) =1+2=3，而B=Val("12")=12，A -B=-9,B-A=9，而A＞B所以执行PrintA-B，正确答案为-9。

  • 第5题：

    有下列事件过程：

    Private Sub Command1_Click()

    b=10

    Do Until b=-1

    a=InputBox("请输入a的值")

    a=Val(A)

    b=InputBox("请输入b的值")

    b=Val(B)a=a*b

    Loop

    Print a

    End Sub

    程序运行后，依次输入数值30,20,10,-1后，输出结果是( )。

    A．6000

    B．-10

    C．200

    D．-6000


    正确答案：B
    解析：本段程序的执行过程如下：第1次输入30，并给变量a赋值为30；第2次输入20，并给变量b赋值为20，这是执行语句a=a*b=600，接着判断b=20条件不成立，因此继续循环：第3次输入10，给a赋值为10；第4次输入-1并赋值给变量b，再执行语句a=a*b=-10；然后判断循环条件，b=-1条件为真，所以退出循环。

  • 第6题：

    有如下程序： #include<iostream> usingnamespacestd； classMyClass{ public： MyClass(intx)：val(x){} voidPrint（）const{cout<<"const：val="<<<val<<＼t；} voidPrint（）{cout<<"val="<<val<<t；} private： intval； }； intmain（）{ constMyClassobj1(10)； MyClassobj2(20)；

    obj1．Print（）； obj2．Print（）； return0； } 程序的输出结果是（ ）。

    A.va1=10const：va1=20

    B.const：va1=10const：va1=20

    C.const：va1=10val=20

    D.val=10va1=20


    正确答案：D
    D。【解析】在建立类对象时，构造函数的执行顺序如下：执行基类的构造函数，调用顺序按照各个基类被继承的声明顺序；执行成员对象的构造函数，调用顺序按照各个成员在类中的声明顺序；执行自身的构造函数。根据以上总结以及题意可知答案选择D选项。

  • 第7题：

    有如下程序:includeusing namespace std;class MyClass{public: MyClass(int x):val(

    有如下程序： #include＜iostream＞ using namespace std; class MyClass{ public: MyClass(int x):val(x) {} void Print() const {cout＜＜"const:val="＜＜val＜＜'\t';} void Print() {cout＜＜"val="＜＜val＜＜'t';} private: int val; }; int main() const MyClass obj1(10); MyClass obi2(20); obj1.Print(); obj2.Print(); return 0; } 程序的输出结果是( )。

    A．val=10 const:val=20

    B．const:val=10 const:val=20

    C．const:val=10 val=20

    D．val=10 val=20


    正确答案：C
    解析：此题考查的是常成员函数的重载。常成员函数是使用const关键字说明的函数。COHM关键字可用于区分重载函数。此时，常对象调用常成员函数，一般对象调用一般成员函数；题目中的Print()就是通过const重载的两个成员函数，主函数中声明的。obj1是常对象，obj2是一般对象。故输出结果是const::val=10val=20。

  • 第8题：

    有如下程序:includeusing namespace std;class MyClass{public:MyClass(int x):val(

    有如下程序： #include＜iostreanl＞ using namespace std； class MyClass{ public： MyClass(int x)：val(x){ } void Set(int x){val=x；} void Print( )eonst{eout＜＜"val="＜＜val＜＜'\t'；} private： int val； }； int main( ){ eonst MyClass objl(10)； MyClass obj2(20)； objl.Print()； //语句1 obj2.Print( )； //语句2 objl.Set(20)； //语句3 obj2.Set(30)； //语句4 return 0； } 其主函数中错误的语句是

    A．语句1

    B．语句2

    C．语句3

    D．语句4


    正确答案：C

  • 第9题：

    有如下程序： #inClude<iostream> using namespaCe std； Class MyClass{ publiC： MyClass(int X)：val(X){} void PrintConst}tout<<”Const：val=”<<val<<’\t’；} void Print{tout<<”val=”<<val<<’\t’；} private： int val； }； int main{ Const MyClass objl(10)； MyClass obj2(20)； objl．Print； obj2．Print； retum 0； } 执行这个程序的输出结果是( )。

    A.val=10 Const：val=20

    B.Const：val=10 Const：val=20

    C.Const：val=10 val=20

    D.val=10 val=20


    正确答案：C
    本题考查常对象、常成员函数及构造函数。常对象只能调用常成员函数，普通对象调用普通成员函数。所以本题中obj1为常对象，执行obj1．print后，会执行常构造函数，输出const：val=10；而obj2为普通对象，执行obj2．print时，会执行默认构造函数，输出va1=20。放答案为C。

  • 第10题：

    函数DIFF（‘A’）代表（）。

    • A、等价于VAL（‘A’，END）＋A的回零后值-A的回零前值-VAL（‘A’，BEG）
    • B、等价于VAL（‘A’，END）＋A的回零后值＋A的回零前值＋VAL（‘A’，BEG）
    • C、等价于VAL（‘A’，END）－A的回零后值-A的回零前值＋VAL（‘A’，BEG）
    • D、等价于VAL（‘A’，END）－A的回零后值＋A的回零前值-VAL（‘A’，BEG）

    正确答案:D

  • 第11题：

    以下代码的输出结果是（） $va1=0；   for（$val = 9；$val>=0；$val--）   {     $va1++；   }   echo（$va1）；

    • A、 0
    • B、 9
    • C、 10
    • D、 这是一个无限循环，没有输出

    正确答案:C

  • 第12题：

    单选题
    以下代码的输出结果是（） $va1=0；   for（$val = 9；$val>=0；$val--）   {     $va1++；   }   echo（$va1）；
    A

     0

    B

     9

    C

     10

    D

     这是一个无限循环，没有输出


    正确答案： D
    解析： 暂无解析

  • 第13题：

    下列程序的输出结果为( )。 #include＜iostream.h) class TestClass { public： TestClass(){val++；} static，int val； }； int TestClass：：val＝0； void main() { TestClass cs1; cout＜＜csl.val＜＜““； TestClass cs2； TestClass cs3，cs4； co

    A．03

    B．13

    C．14

    D．24


    正确答案：C
    解析： 由主函数main入手，定义TestClass类的对象cs1，执行es1.va1，其中va1为静态变量，根据“tnt TestClass：：val=0：”初始化，TestClass中的TestClass(){val++；}构造函数执行后，val值为1。主函数中接着定义对象cs2，cs3，cs4。执行“coutcs2.va1end1”中的val值为4，所以输出为14。

  • 第14题：

    以下程序的输出结果是_____。 include class object {private:int val; public:objec

    以下程序的输出结果是_____。

    include＜iostream.h＞

    class object

    { private:

    int val;

    public:

    object( ) ;

    object(int i) ;

    ～object( ) ;};

    object: :object( )

    { val＝0;

    cout ＜ ＜ "Default constructor for object" ＜ ＜ endl;}

    object: :object(int i)

    { val＝i;

    cout ＜ ＜ "Constructor for object" ＜ ＜ val ＜ ＜ endl;}

    object: :～object( )

    { cout ＜ ＜ "Destructor for object" ＜ ＜ val ＜ ＜ endl;}

    class container{ private:

    object one;

    object two;

    int data;

    public:

    container( ) ;

    container(int i,int j,int k) ;

    ～container( ) ;};

    container: :container( )

    { data＝0;

    cout ＜ ＜ "Default constructor for container" ＜ ＜ endl;}

    container: :container(int i,int j,int k) :two(i) ,one(j)

    { data＝k;

    cout ＜ ＜ "Constructor for container" ＜ ＜ endl;}

    container: :～container( )

    { cout ＜ ＜ "Destructor for container" ＜ ＜ endl;}

    void main( )

    { container anObj(5,6,10) ;}


    正确答案：Constructor for object6 Constructor for object5 Constructor for container Destructor for container Destructor for object5 Destructor for object6
    Constructor for object6 Constructor for object5 Constructor for container Destructor for container Destructor for object5 Destructor for object6 解析：C＋＋语言中的构造函数和析构函数分别是在声明对象时和对象调用完毕后调用，本题中的调用就是这样成对出现的。

  • 第15题：

    有如下程序:includeusing namespace std;class Part{public:Part(int x=0):val(x) {c

    有如下程序： #include＜iostream＞ using namespace std; class Part{ public: Part(int x=0):val(x) {cout＜＜val;} ～Part(){cout＜＜val;} private: int val; }; class Whole{ public: Whole(int x ,int y, int z=0):p2(x),p1(y),val(z){cout＜＜val;} ～Whole(){cout＜＜val;} private: Part p1,p2; int val; }; int main() Whole obj(1,2,3); return 0; } 程序的输出结果是( )。

    A．123321

    B．213312

    C．213

    D．123123


    正确答案：B
    解析：此题考查的是类的构造与析构。在建立类的对象时，构造函数的执行顺序如下：执行基类的构造函数，调用顺序按照各个基类被继承时声明的顺序(自左向右)，接着执行成员对象的构造函数，调用顺序按照各个成员对象在类中声明的顺序，最后执行自身的构造函数。析构顺序与之相反。本题中，Whole类中有两个Part类的成员p1和p2，根据它们定义的顺序，先构造p1再构造p2。所以，首先被构造的是p1(y)，输出2；第二个被构造的是p2(x)，输出1；最后调用析构函数，输出val的值3；析构函数调用顺序与构造函数相反。故最后输出213312。

  • 第16题：

    下面程序的输出结果为()。includeclass CStatic{public:CStatic() {val＋＋;}static i

    下面程序的输出结果为( )。#include＜iostream.h＞class CStatic{public:CStatic() {val++;}static int val;};int CStatic::val=0;void main(){CStatic cs1;cout＜＜cs1.val＜＜ "";CStatic cs2;CStatic cs3, cs4;cout＜＜cs val＜＜end1;}

    A．14

    B．24

    C．34

    D．54


    正确答案：A

  • 第17题：

    有如下程序： #include<iostream> using namespaee std； int main { void function(double val)； double val： function(val)； eout<<val： return 0； } void function(double val) { val=3； } 编译运行这个程序将出现的情况是( )。

    A.编译出错，无法运行

    B.输出：3

    C.输出：3．0

    D.输出一个不确定的数


    正确答案：D
    本题考查函数调用及传值方式传递参数，执行函数function时，并没有将3的值传回来，而val又没有初始化，所以会输出一个不确定的值，D选项正确。

  • 第18题：

    有如下程序: include using namespace std; int main() { void fu

    有如下程序： #include＜iostream＞ using namespace std； int main() { void function(double val)； double val； function(val); cout＜＜val； return 0； } void function(double val) { val＝3； } 编译运行这个程序将出现的情况是

    A．编译出错，无法运行

    B．输出：3

    C．输出：3.0

    D．输出一个不确定的数


    正确答案：D
    解析：本题考查的是函数参数的传递。在C++中，函数在传递参数时，总是将实参值的副本传递(拷贝)给被调用函数的形参，即传值调用。因此，在函数中对形参所作的任何操作都不会改变函数外的实参。故本题function()函数不会对主函数中的　val变量造成任何改变，val也没有被初始化，所以输出的是一个不确定的值：故应该选择D。

  • 第19题：

    有如下程序：

    #include<iostream>

    usingnamespacestd；

    classMyClass{

    public：

    MyClass(intx)：val(x){}

    voidPrint（）const{cout<<"const：val="<<<val<<'＼t'；}

    voidPrint（）{cout<<"val="<<val<<'t'；}

    private：

    intval；

    }；

    intmain（）{

    constMyClassobj1(10)；

    MyClassobj2(20)；

    obj1．Print（）；

    obj2．Print（）；

    return0；

    }

    程序的输出结果是（ ）。

    A.va1=10const：va1=20

    B.const：va1=10const：va1=20

    C.const：va1=10val=20

    D.val=10va1=20


    正确答案：D
    D。【解析】在建立类对象时，构造函数的执行顺序如下：执行基类的构造函数，调用顺序按照各个基类被继承的声明顺序；执行成员对象的构造函数，调用顺序按照各个成员在类中的声明顺序；执行自身的构造函数。根据以上总结以及题意可知答案选择D选项。

  • 第20题：

    有下列程序:includeusing namespace std;int main(){void function(double val);doub

    有下列程序： #include＜iostream＞ using namespace std; int main() { void function(double val); double val; function(val); cout＜＜val; return 0; } void fimction(double val) { v

    A．编译出错，无法运行

    B．输出3

    C．输出：3.0

    D．输出一个不确定的数


    正确答案：D
    解析： 此题考查的是函数参数的传递。在C++语言中，函数在传递参数时，总是将实参的值传递给被调用函数的形参，即传值调用。因此，在函数中对形参所作的任何操作都不会改变实参的值。

  • 第21题：

    有如下程序:includeusing namespace std;int main(){void function(double val);doub

    有如下程序： #include＜iostream＞ using namespace std; int main() { void function(double val); double val; function(val); cout＜＜val; return 0; } void function(double val) { val= 3; } 编译运行这个程序将出现的情况是( )。

    A．编译出错，无法运行

    B．输出：3

    C．输出：3.0

    D．输出一个不确定的数


    正确答案：D

  • 第22题：

    以下关于选择具有att属性且属性值以val为起始的div元素的写法不正确的是（）。

    • A、div[att=”val”]
    • B、div[att^=”val”]
    • C、div[att==”val”]
    • D、div[att$=”val”]

    正确答案:A,C,D

  • 第23题：

    Val（“52”）+Val（“32ab”）=（）


    正确答案:84

相关内容