c++题目整理

题1：

判断下述语句的对错：MFC中CString是类型安全的类。

• 对
• 错

答案：B

B

不是，其它数据类型转换到CString可以使用CString的成员函数Format来转换.

题2：

 

union Test {    char a[4];    short b; }; Test test; test.a[0]=256; test.a[1]=255; test.a[2]=254; test.a[3]=253; printf("%d\n",test.b);

问题：在80X86架构下，输出什么值？

• -128
• -256
• 128
• 256

答案：B

题3：

以下程序的输出是

class Base {    public:    Base(int j): i(j)  {}    virtual~Base() {}    void func1() {        i *= 10;        func2();    }    int getValue() {        return  i;    }    protected:    virtual void func2() {        i++;    }    protected:    int i;};class Child: public Base {    public:    Child(int j): Base(j) {}    void func1() {        i *= 100;        func2();    }    protected:    void func2() {        i += 2;    }};int main() {    Base * pb = new Child(1);    pb->func1();    cout << pb->getValue() << endl; delete pb; }

• 11
• 101
• 12
• 102

答案： C

 

题4：

下列代码编译时会产生错误的是（）

#include <iostream>using namespace std;struct Foo {    Foo() {}    Foo(int) {}    void fun() {}};int main(void) {    Foo a(10); //语句1      a.fun(); //语句2      Foo b(); //语句3      b.fun(); //语句4      return 0;    16.}

• 语句1
• 语句2
• 语句3
• 语句4

答案： D

题5：

下面这段代码会打印出什么？

class A{public:    A()    {        printf("A ");    }    /*virtual*/    ~A()    {        printf("deA ");    }}; class B{public:    B()    {        printf("B ");    }    ~B()    {        printf("deB ");    }}; class C: public A, public B{public:    C()    {        printf("C ");    }    ~C()    {        printf("deC ");    }};int main(){    A *a = new C();    delete a;    return 0;}

• A B C deA
• C A B deA
• A B C deC
• C A B deC

答案 A

解释：

构造函数的执行先执行父类，再执行子类。析构顺序想反

A B的析构函数不是虚函数，所以不会执行子类的虚函数。

 题6：

有以下程序

#include <stdio.h>#include <stdlib.h>void fun ( int ﹡pl,int ﹡p2,int ﹡s ){    s ＝ (int﹡) calloc(1,sizeof(int));    ﹡s ＝ ﹡pl + ﹡p2;    free (s); }main ( ){    int a [2] ＝ ｛1,2｝,b [2] ＝ ｛40,50｝,﹡q ＝ a;    fun(a,b,q) ;    printf ( "%d＼n", ﹡q);}

程序运行后的输出结果是?

• 42
• 41
• 1
• 0

答案： C

题目7：

下列程序执行后输出的结果是

#include<iostream>using namespace std; int f(int a){    int b = 0;    static int c = 3;    a = c++, b++;    return (a);}int main(){    int a = 2, i, k;    for (i = 0; i < 2; i++)        k = f(a++);    printf(" % d\n", k);         return 0;}

• 3
• 0
• 5
• 4

答案： D

 

 题目8：

给定程序中，函数fun的功能是：将参数给定的字符串、整数、浮点数写到文本文件中，再用字符串方式从此文本文件中逐个读入，并调用库函数atoi和atof将字符串转换成相应的整数、浮点数，然后将其显示在屏幕上。 

#include <stdio.h>#include <stdlib.h>void fun(char *s, int a, double f){FILE *fp;char str[100], str1[100], str2[100];int a1;double f1;fp = fopen("file1.txt", "w");fprintf(fp, "%s %d %f\n", s, a, f);fclose(fp);fp = fopen("file1.txt", "r");fscanf(fp, "%s %s %s", str, str1, str2);fclose(fp);a1 = atoi(str1);f1 = atof(str2);printf("\nThe result: \n %s %d %f\n", str, a1, f1);}int main(){char a[10] = "Hello!";int b = 12345;double c = 98.76;fun(a, b, c);return 0;}

 题9

在64位系统中，有如下类：

class C{public:    char a;    static char b;    void *p;    static int *c;    virtual void func1();    virtual void func2();};

那么sizeof（C）的数值是（）

• 9
• 17
• 32
• 24

答案：D

sizeof（类）计算的是类中存在栈中的变量的大小，而类中的b和*c都是static静态变量，存在全局区中，因此不在计算范围之内，于是只剩下char a，void *p和两个virtual虚函数，a是char类型，占用一个字节，p是指针，在64位系统的指针占用8个字节，而两个虚函数只需要一个虚函数表指针，也是八个字节，加上类中的对齐方式（char a对齐时后面补上7个字节），故答案为24.

题10

派生类的对象对它的基类成员中，（）是可以访问的。

• 公有继承的公有成员
• 公有继承的私有成员
• 公有继承的保护成员
• 私有继承的公有成员

答案：A

B，公有继承的私有成员不能被继承，无法访问

C，公有继承的保护成员，只能在派生类中访问，不能用派生类对象访问

D，私有继承的公有成员，成员被私有化，无法访问

 题11

以下程序是用辗转相除法来计算两个非负数之间的最大公约数：

long long gcd(long long x, long long y) {    if (y == 0)        return x;    else        return gcd(y, x % y);}

我们假设x,y中最大的那个数的长度为n，x>y，基本运算时间复杂度为O(1)，那么该程序的时间复杂度为（ ）

• O(1)
• O(logy)
• O(n)
• O(x)

答案： B

求最大公约数的最常用的算法是欧几里得算法,也称为辗转相除法.
问题定义为求i和j的最大公约数gcd(i,j),其中i和j是整数,不妨设i>j.
算法可以递归的表示:
1.如果j能整除i,那么gcd(i,j)=j;
2.j不能整除i,令r=i%j,那么gcd(i,j)=gcd(j,r).
使用C语言实现:

1

2

3

4

5

intgcd(inti, intj)

{

    intr = i % j;

    returnr == 0 ? j : gcd(j, r);

}

正确性分析:
算法的步骤1,显然成立(最大公约数定义).关键是要证明步骤2.
设d是i和j的最大公约数,
那么i=md,j=nd,m和n互质(否则d不是最大公约数).
由r=i%j可以得到i=kj+r,k=⌊m/n⌋,k≥1(我们前面假设过i>j).
把i=md,j=nd代入得到
md=knd+r
那么
r=(m-kn)d
m-kn和m也是互质的.
所以得到d是j和r的最大公约数.

时间复杂度分析:
逆着看该算法,最后的余数是0,倒数第二次余数是d,倒数第三次是kd,k>1…
由于组成了一个数列,{0,d,kd,nkd+d,…}
数列的n项加上n+1项,比n+2项要小,所以比斐波纳契数列增长的要快.
我们已知斐波纳契数列增长速度是指数,那么待分析的数列也是指数增长.
设欧几里得算法需要k次,那么j=O(2^k),则k=O(lg j).

所以欧几里得算法求最大公约数的时间复杂度是对数量级的,速度非常快.

题12

1

time_t t;

哪个选项可以将t初始化为当前程序的运行时间？

• t = clock();
• time( &t );
• time( &t );
• t = localtime();
• None of the above

答案： A

题13

以下程序的打印结果是（）

.#include<iostream>2.using namespace std;3.4.void swap_int(int a , int b)5.{6.    int temp = a;7.    a = b;8.    b = temp;9.}10.11.void swap_str(char*a , char*b)12.{13.    char*temp = a;14.    a = b;15.    b = temp;16.}17.18.int main(void)19.{20.    int a = 10;21.    int b = 5;22.    char*str_a = "hello world";23.    char*str_b = "world hello";24.    swap_int(a , b);.25.    swap_str(str_a , str_b);26.    printf("%d %d %s %s\n",a,b,str_a,str_b);27.28.    return 0;29.}

• 10 5 hello world world hello
• 10 5 world hello hello world
• 5 10 hello world world hello
• 5 10 hello world world hello

答案： A

题14

在 C 语言中下面那个语句的结果是 1 ？

• main 函数正常结束的返回值
• return 7&1;
• char *p="hello"; return p == "hello";
• 上面都不对

答案： BC

题15

下面关于多态性的描述，错误的是：

• C++语言的多态性分为编译时的多态性和运行时的多态性
• 编译时的多态性可通过函数重载实现
• 运行时的多态性可通过模板和虚函数实现
• 实现运行时多态性的机制称为动态绑定

答案：C

A，正确，分编译时多态和运行时多态

B，编译时多态可以通过函数重载实现，具体表现在根据参数的个数和类型不同选择合适的同名函数

C，运行时多态通过虚函数实现，就是运行时根据对象类型自动选择正确的调用接口。模板属于编译时多态性，因为编译时自动根据模板生成模板函数。

D，运行时多态是根据对象类型自动选择正确的调用函数，也叫动态绑定。

题16

有以下程序

#include<stdio.h>main(){    int a=3;    printf("%d\n",(a+=a－=a*a));｝

程序运行后的输出结果是？

• 3
• 9
• 0
• -12

答案： D

题17

在c++中，

const int i = 0; int *j = (int *) &i; *j = 1; printf("%d,%d", i, *j)

输出是多少？

• 0，1
• 1，1
• 1，0
• 0，0

答案： A
const修饰的常量值具有不可变性,c++编译器通常会对该变量做优化处理，在编译时变量i的值为已知的，编译器直接将printf输出的变量i替换为0。尽管如此，编译器仍然会为变量i分配存储空间，通过修改内存的hack方式将变量i在内存中的值修改后并不影响printf的输出。
如果将i更改为volatile const int类型的，编译器就不会对变量i做优化，printf输出的结果就为1。

题18

/* 将整型数组p中n个数据增大*/void increment_ints (int p [ ], int n) {   assert(p != NULL);  /* 确保p不为空指针 */   assert(n >= 0);  /* 确保n不为负数 */   while (n)  /* 循环n次. */   {     *p++;          /* 增大p*/     p++, n--;      /* p指向下一位，n减1 */   } }

以上代码的实现有错误，下面哪句话的表述是正确的？

• *p++使得p在解引用之前增大，因为*和++两个运算符有相同的优先级并按自右向左的方式结合。
• 数组的值是一个不能改变的值，所以p不能直接被修改。应该使用一个和p相关联的指针来完成这个操作。
• *p++使得p在解引用之前增大，因为自增运算符的优先级比取址运算符优先级高。
• while循环的条件必须是一个布尔类型的表达式，表达式应该为n!=0.
• An array cannot be initialized to a variable size. The subscript n should be removed from the definition of the parameter p.

答案：A 

题19

In the main() function, after ModifyString(text) is called, what’s the value of ‘text’?

int FindSubString( char* pch ){    int   count  = 0;    char  * p1   = pch;    while ( *p1 != '\0' )    {           if ( *p1 == p1[1] - 1 )        {            p1++;            count++;        }else  {            break;        }    }    int count2 = count;    while ( *p1 != '\0' )    {        if ( *p1 == p1[1] + 1 )        {            p1++;            count2--;        }else  {            break;        }    }    if ( count2 == 0 )        return(count);    return(0);}void ModifyString( char* pText ){    char  * p1   = pText;    char  * p2   = p1;    while ( *p1 != '\0' )    {        int count = FindSubString( p1 );        if ( count > 0 )        {            *p2++ = *p1;            sprintf( p2, "%i", count );            while ( *p2 != '\0' )            {                p2++;            }            p1 += count + count + 1;        }else  {            *p2++ = *p1++;        }    }}void main( void ){    char text[32] = "XYBCDCBABABA";    ModifyString( text );    printf( text );}  

• XYBCDCBABABA
• XYBCBCDAIBAA
• XYBCDCBAIBAA
• XYBCDDBAIBAB

答案C

FindSubString()中

用到了“回文段落跳过” 

*p1 == p1[1] - 1，即看该字符串是不是递增的，即x后面是y，y后面是z，然后用count记录

*p1 == p1[1] + 1，即看该字符串是不是递减的，即z后面是y，y后面是x，然后用count2递减

若回文则返回 回文子串长度，若不回文则返回0

ModifyString()中

过滤XY，找到第一个回文字段的开始，即BCDCB 中的B，然后跨过回文段

到ABABA，进入FindSubString() 得 ABA，即count=1；

sprintf( p2, "%i", count );把B换成1，即A1，然后 *p2++=*p1++  A1BAA

题20

对以下程序，正确的输出结果是()

#include <stdio.h>#define SUB(x,y) x-y#define ACCESS_BEFORE(element,offset,value) *SUB(&element, offset) = valueint main() {    int array[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };    int i;    ACCESS_BEFORE(array[5], 4, 6);    printf("array: ");    for (i = 0; i < 10; ++i) {        printf("%d", array[i]);    }    printf("\n");    return (0);}

• array: 1 6 3 4 5 6 7 8 9 10
• array: 6 2 3 4 5 6 7 8 9 10
• 程序可以正确编译连接，但是运行时会崩溃
• 程序语法错误，编译不成功

答案： D

题21

unsigned int a= 0x1234; unsigned char b=*(unsigned char *)&a; 在32位大端模式处理器上变量b等于()?

• 0x00
• 0x12
• 0x34
• 0x1234

答案：A

//  unsigned int a= 0x1234; 其中int是4字节, 大端存储 ，补齐16进制表示为: 0x00 00 12 34  
//  unsigned char b=*(unsigned char *)&a; 由于大端存储, 所以上述int a变量的最低地址存储的是   
//  十六进制表示中最左边的1字节, 为0x00.  

题22

如下代码输出结果是什么？

#include<stdio.h>char *myString(){    char buffer[6] = {0};    char *s = "Hello World!";    for (int i = 0; i < sizeof(buffer) - 1; i++)    {        buffer[i] = *(s + i);    }    return buffer;}int main(int argc, char **argv){    printf("%s\n", myString());    return 0;}

• Hello
• Hello World!
• Well
• 以上全部不正确

答案：D

题23

i最后等于多少?

int i = 1;int j = i++;if((i>j++) && (i++ == j)) i+=j;

• 3
• 5
• 6
• 7

答案： B

题24

class A{    int _a;public:    A(int a): _a(a)    {    }    friend int f1(A &);    friend int f2(const A &);    friend int f3(A);    friend int f4(const A);};

以下调用哪个是错误的：

• f1(0)
• f2(0)
• f3(0)
• f4(0)

答案： A

非常量引用的初始值必须为左值

要理解这个先得理解左值和右值的概念一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。

本题举例：

执行f1(0),实参0要传成A对象，那么执行

A &a1 = 0;   //这是不行的。

执行f2(0),实参0要传成A对象，那么执行 
const A &a2 = 0;//这是可行的。

题25

以下关于STL的描述中，____是错的。

• STL容器是线程不安全的
• 当容量不够时，vector内部内存扩展方式是翻倍
• std::sort是稳定排序
• std::bitset不是一个STL容器
• std::stack默认是用deque实现的
• std::string中可以存储多个’\0’字符

答案： C

A：“很多程序员希望STL实现是完全线程安全的“。所以不安全。

B：vector的存在可以使开发者不必关心内存的申请和释放。但是，vector的一个缺点就是它的内存分配是按照2的倍数分配内存的。

C：错误。要知道 std::sort 不是稳定的排序算法，它不保证“相等”元素的相对位置，使用 std::stable_sort 来保证这一点

D：STL的容器可以分为以下几个大类: 

一：序列容器，　有vector, list, deque, string.

二 : 关联容器,     有set, multiset, map, mulmap, hash_set, hash_map, hash_multiset, hash_multimap

三: 其他的杂项： stack, queue, valarray, bitset

E：正确。堆栈是一个线性表，插入删除操作都在一端进行，deque是先进先出的，操作原理和stack是一样的

题26

下面程序执行结果:

using namespace std;class A{    public:        virtual void f() { cout << "A::f() "; }        void f() const { cout << "A::f() const "; }};class B : public A {    public:        void f() { cout << "B::f() "; }        void f() const { cout << "B::f() const "; }};void g(const A* a) {    a->f();}int main(int argc, char *argv[]) {    A* p = new B();    p->f();    g(p);    delete(p);    return 0;}

• B::f() B::f() const
• B::f() A::f() const
• A::f() B::f() const
• A::f() A::f() const

答案： B

题27

下面有关c++线程安全，说法错误的是？

• 线程安全问题都是由全局变量及静态变量引起的
• 若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
• c++标准库里面的string保证是线程安全的
• POSIX线程标准要求C标准库中的大多数函数具备线程安全性

答案：C

题28

有这样一个类：

12345class Eye{    public:    void Look(void);};

现在希望定义一个Head类，也想实现Look的功能，应该使用()方法，实现代码重用。

• 继承
• 组合
• 模板
• 过滤

答案：B 
Look是Eye本身所具有的功能，反过来Eye如果没有Look功能就不是一个完整的Eye。因此Look是Eye必不可少的一部分，就像车胎是汽车的一部分一样，代码复用最好的办法是用组合。
Eye为Head的一部分，是整体和部分的关系，属于UML中的组合关系。可以在Head类中定义一个Eye类型的成员变量，Head类的Look函数直接调用Eye类的函数。

题29

将“引用”作为函数参数有哪些特点？

• 引用传递和指针传递没有差别
• 传递引用给函数与传递指针的效果是一样的
• 使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；
• 在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

答案：BCD

题30

下面哪个操作符不能重载（）

• =
• <
• sizeof
• %

答案：C

C++中绝大部分的运算符可重载，除了成员访问运算符.，作用域运算符::，长度运算符sizeof以及条件运算符?:

题31

下列关于联合的描述中，错误的是？

• 联合变量定义时不可初始化
• 联合的成员是共址的
• 联合的成员在某一个时刻只有当前的是有效的
• 联合变量占有的内存空间是该联合成员占有最大内存空间的成员所需的存储空间

答案： A

union类型的变量在定义时是可以被初始化的，定义如下union类型

1

2

3

4

5

6

union Test

{

    inta;

    floatb;

};

Test test = {1};

test变量的定义可以初始化，初始值的类型必须是union中第一个成员的类型。

题32

下面有关static类变量和实例变量的描述，正确的有？

• 类变量又叫静态成员变量，它不需要创建对象就可以已经在内存中存在了
• 在创建实例对象的时候，内存中会为每一个实例对象的每一个非静态成员变量开辟一段内存空间，用来存储这个对象所有的非静态成员变量值
• 类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果
• 实例变量则属对象私有，某一个对象将其值改变，不影响其他对象

答案：ABCD

题33

什么函数不能声明为虚函数？

• 静态成员函数
• 内联函数
• 构造函数
• 析构函数

答案：ABC

常见的不能声明为虚函数的有:普通函数(非成员函数)、静态成员函数、内联成员函数、构造函数、友元函数。

题34

#include <stdio.h>#include <stdlib.h>#include <string.h>void WriteText(FILE*);void ReadText(FILE*);int main(){FILE *fp;if((fp = fopen("myfile4.txt", "w")) == NULL){printf("open fail!!\n");exit(0);}WriteText(fp);fclose(fp);if((fp = fopen("myfile4.txt", "r")) == NULL){printf("open failed!!\n");exit(0);}ReadText(fp);fclose(fp);}void WriteText(FILE *fw){char str[81];printf("\nEnter string with -1 to end:\n");gets(str);while(strcmp(str, "-1") != 0){fputs(str, fw);fputs("\n", fw);gets(str);}}void ReadText(FILE *fr){char str[81];printf("\nRead file and output to screen:\n");fgets(str, 81, fr);while(!feof(fr)){printf("%s", str);fgets(str, 81, fr);}}

题35

若fp已定义为指向某文件的指针,且没有读到该文件的末尾,C语言函数feof( fp)的函数返回值是？

• EOF
• 非0
• -1
• 0

答案：D

题36

若有以下程序

234567#include<stdio.h>main( ){     int a=-2,b=0;    while(a++) ++b;    printf("%d,%d\n",a,B);}

则程序的输出结果是?

• 1,1
• 1,2
• 2,1
• 2,2

答案： B

题37

下面说法正确的是（）

• 在C++语言中new和malloc都是在堆（heap）上进行动态的内存操作，可以互相代替。
• C++语言重载（over load）是指子类重新定义父类的虚函数的方法。
• C++语言函数既可以嵌套定义又可以递归调用。
• 在C++语言中调用函数时，只能把实参的值传给形参，形参的值不能传送给实参。

答案： D

题38

设 m 和 n 都是 int 类型，那么以下 for 循环语句，___

for(m=0,n=-1;n=0;m++,n++)    n++;

• 循环体一次也不执行
• 循环体执行一次
• 是无限循环
• 有限次循环
• 循环结束判断条件不合法
• 运行出错

答案： A

题39

下列说法正确的有（ ）

• class中的constructor不可省略
• constructor必须与class同名，但方法不能与class同名
• constructor在一个对象被new时执行
• 一个class只能定义一个constructor

答案： C

题40

对于派生类的构造函数，在定义对象时构造函数的执行顺序为？
1：成员对象的构造函数
2：基类的构造函数
3：派生类本身的构造函数

• 123
• 231
• 321
• 213

答案： D

题41

在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是(    ) 

• 派生类的对象可以赋给基类的对象
• 派生类的对象可以初始化基类的引用
• 派生类的对象可以直接访问基类中的成员
• 派生类的对象的地址可以赋给指向基类的指针

答案：C

题42

你认为可以完成编写一个C语言编译器的语言是()

• 汇编
• C语言
• :VB
• 以上全可以

答案： D

题43

两个等价线程并发的执行下列程序，a为全局变量，初始为0，假设printf、++、--操作都是原子性的，则输出肯定不是哪个？

void foo() {    if(a <= 0) {        a++;    }    else {        a--;    }    printf("%d", a);}

• 01
• 10
• 12
• 22

答案: A

题44

下面关于迭代器失效的描述哪个是错误的（）

• vector的插入操作不会导致迭代器失效
• map的插入操作不会导致迭代器失效
• vector的删除操作只会导致指向被删除元素及后面的迭代器失效
• map的删除操作只会导致指向被删除元素的迭代器失效

答案： A

题45

将“引用”作为函数参数有哪些特点？

• 引用传递和指针传递没有差别
• 传递引用给函数与传递指针的效果是一样的
• 使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；
• 在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

答案： BCD

题46

union Test {    char a[4];    short b; }; Test test; test.a[0]=256; test.a[1]=255; test.a[2]=254; test.a[3]=253; printf("%d\n",test.b);

问题：在80X86架构下，输出什么值？

• -128
• -256
• 128
• 256

答案： B

答案解析：首先要知道大小端模式，80X86下是小端模式；当然可以编写下测试就可以了，short占2个字节，设左高地址，右低地址；

  a[1]           a[0]

1111 1111     0000 0000

short占用的是这a[1]、a[0]两个字节，最高位是1是一个负数，在计算机中采用补码表示，那么二进制表示为：1000 0001 0000 0000，转化为十进制就是-256.

题47

class Base {    public:    Base(int j): i(j)  {}    virtual~Base() {}    void func1() {        i *= 10;        func2();    }    int getValue() {        return  i;    }    protected:    virtual void func2() {        i++;    }    protected:    int i;};class Child: public Base {    public:    Child(int j): Base(j) {}    void func1() {        i *= 100;        func2();    }    protected:    void func2() {        i += 2;    }};int main() {    Base * pb = new Child(1);    pb->func1();    cout << pb->getValue() << endl; delete pb; }

• 11
• 101
• 12
• 102

答案： C

Base * pb = new Child(1)， 首先创建子类对象，初始化为1；

func1()不是虚函数，所以pb->func1()执行的是基类的func1函数，i= 10，然后调用func2()函数；

这里的func2是虚函数，要往下派生类寻找，找到后执行派生类中的func2(),此时，i = 12；

最后执行pb->getValue(),结果为12

题48

a=1,b=2,c=3,d=4;a<b ? a:c < d ? a:d的结果是: 1

？： 右结合

题49

turbo c环境下，下面程序运行的结果是()

int main(){    printf("\n");    int a[5] = {1, 2, 3, 4, 5};    int *p, **k;    p = a;    k = &p;    printf("%d", *(p++));    printf("%d", **k);    return 0;}

• 11
• 21
• 22
• 12

答案： D

题50

以下哪些对象可用于Windows进程间通信？

• 事件
• 临界区
• 互斥量
• 共享内存

答案： D

windows进程间通信方法有：文件映射、共享内存、匿名管道、命名管道、邮件槽、剪切板、动态数据交换、对象连接与嵌入、动态连接库、远程过程调用等

题51

enum string{        x1,        x2,        x3=10,        x4,        x5,    } x;

问x等于什么？

• 5
• 12
• 0
• 随机值

答案： C

题52

#define a 10main(){   printf("%d..",a);   foo();   printf("%d",a);}void foo(){   #undef a   #define a 50}

• 10..10
• 10..50
• Error
• 0

答案： A

处理#define的时候，忽略代码的逻辑。

题53

运算符优先级 
unsigned char i=0x80; 
printf("0x%x\n", ~i>>3+1);
输出什么？ 

输出：0xfffffff7（提示：+的优先级优于>>） 
如果将unsigned去掉，则输出0x7。

题54

运算符优先级 
unsigned char i=0x80; 
printf("0x%x\n", ~i>>3+1);输出什么？ 
输出：0xfffffff7（提示：+的优先级优于>>） 
如果将unsigned去掉，则输出0x7。

题55

静态对象是否调用构造函数？

#include <iostream>using namespace std;class A{public:    A() { cout << "A's Constructor Called " << endl;  }};class B{    static A a;public:    B() { cout << "B's Constructor Called " << endl; }};int main(){    B b;    return 0;}

解释：上面的程序只是调用了B的构造函数，没有调用A的构造函数。因为静态成员变量只是在类中声明，没有定义。静态成员变量必须在类外使用作用域标识符显式定义。 
如果我们没有显式定义静态成员变量a，就试图访问它，编译会出错，比如下面的程序编译出错：

#include <iostream>using namespace std;class A{    int x;public:    A() { cout << "A's constructor called " << endl;  }};class B{    static A a;public:    B() { cout << "B's constructor called " << endl; }    static A getA() { return a; }};int main(){    B b;    A a = b.getA();    return 0;}

输出：

Compiler Error: undefined reference to `B::a

如果我们加上a的定义，那么上面的程序可以正常运行， 
注意：如果A是个空类，没有数据成员x，则就算B中的a未定义也还是能运行成功的，即可以访问A。

#include <iostream>using namespace std;class A{    int x;public:    A() { cout << "A's constructor called " << endl;  }};class B{    static A a;public:    B() { cout << "B's constructor called " << endl; }    static A getA() { return a; }};A B::a;  // definition of aint main(){    B b1, b2, b3;    A a = b1.getA();    return 0;}

输出：

A's constructor called B's constructor called B's constructor called B's constructor called

上面的程序调用B的构造函数3次，但是只调用A的构造函数一次，因为静态成员变量被所有对象共享，这也是它被称为类变量的原因。同时，静态成员变量也可以通过类名直接访问，比如下面的程序没有通过任何类对象访问，只是通过类访问a。

int main(){    // static member 'a' is accessed without any object of B    A a = B::getA();    return 0;}

输出：

A's constructor called

题56

下面代码的输出是什么？（非常考基础水平的一道题）

char *c[] = {"ENTER","NEW","POINT","FIRST"};  char **cp[] = { c + 3 , c + 2 , c + 1 , c};  char ***cpp = cp;  int main(void)  {      printf("%s",**++cpp);      printf("%s",*--*++cpp+3);      printf("%s",*cpp[-2]+3);      printf("%s\n",cpp[-1][-1]+1);      return 0;  }  

解答： 
c是一个指针数组，每个数组元素都是char*类型的指针，值分别是那些字符串(的首地址)：

c[0] = "ENTER" c[1] = "NEW" c[2] = "POINT" c[3] = "FIRST"

而[]和*是本质一样的运算，即c[i]=*(c+i)。

c和c+i都是char *[]类型，它可以退化成char **类型，再看cp，它正好是一个char **的数组，来看它的值：

cp[0] = c + 3 cp[1] = c + 2 cp[2] = c + 1 cp[3] = c

引用后就有：cp[0][0]=*(c + 3)=c[3]="FIRST"，以此类推。

cp是char **[]类型，它可以退化成char ***类型，看最后的cpp，它正是char ***类型，它是一个指针变量，和上面两个不同，上面两个是数组。

这样分析过后，下面的解析就一目了然了：

• printf("%s",**++cpp); 
  ++cpp的值是cp+1，引用一次后是cp[1]再引用是*cp[1]=c[2]="POINT"，第一句的输出
• printf("%s",*--*++cpp+3); 
  再++cpp的值是cp+2，引用一次是cp[2]=c+1，再对这进行--，减后是c再引用是c[0]="ENTER"再+3，字符串指针指到"ER"，输出是"ER"
• printf("%s",*cpp[-2]+3); 
  这时cpp的值是cp+2，cpp[-2]=*(cpp-2)=*(cp+2-2)=cp[0]=c+3，再引用是c[3]="FIRST",+3 字符串指针指到"ST"，输出是"ST"
• printf("%s\n",cpp[-1][-1]+1); 
  cpp还是cp+2，cpp[-1]=*(cpp-1)=*(cp+2-1)=cp[1]=c+2，再[-1]得*(c+2-1)=c[1]="NEW",+1字符串指针指到"EW"，输出是"EW"。

题57

下列关于C语言中指针的说法错误的是：___

• 指针的值是一个地址
• 非法指针是指该指针的值不是一个已经分配的内存地址
• 两个指向同类型地址的指针之间做减法是没有意义的
• 指针的指针占用的内存空间和其他指针占用的内存空间相同

答案： B

题58

Which of following C++ code is correct?

• int f() { int *a = new int(3); return *a; }
• int *f() { int a[3] = {1, 2, 3}; return a; }
• vector f() { vector v(3); return v; }
• void f(int *ret) { int a[3] = {1, 2, 3}; ret = a; return; }

答案： C

题59

下面的程序的输出是什么？

#include<stdio.h> int main(void){ int n; char y[10] = "ntse"; char *x = y; n = strlen(x); *x = x[n]; x++; printf("x=%s\n",x); printf("y=%s\n",y); return 0;}

x=atse,y=

x=tse,y=

x=atse,y=e

x=tse,y=e答案： B

题60

  void main(){    float a = 1;    cout << boolalpha << ((int)a == (int &)a);    float b = 0;    cout << boolalpha << ((int)b == (int &)b);}

<span style="color: rgb(51, 51, 51); font-family: arial, STHeiti, 'Microsoft YaHei', 宋体; font-size: 14px; line-height: 25.2000007629395px; background-color: rgb(255, 255, 255);">该程序输出结果为</span>

• truetrue
• falsefalse
• truefalse
• falsetrue

答案： D

题61

已知int a[]={1,2,3,4,5}；int*p[]={a,a+1,a+2,a+3}；int **q=p；表达式*(p[0]+1)+**(q+2)的值是____。

• 5
• 6
• 7
• 8
• 4
• 9

答案： A

int*p[]是指针的数组，是一个数组，每个元素是指针。p[0]是a，这个a值是一个指针

= *(p[0]+1)+**(q+2)*(p[0]+1)+*(p[2])*(a+1)+*(a+2)a[1]+a[2]2+35

题62

运行下面这段C语言程序之后，输出在屏幕上的结果是：

void foobar(int a, int *b, int **c){    int *p = &a;    *p = 101;    *c = b;    b = p;} int main(){    int a = 1;    int b = 2;    int c = 3;    int *p = &c;    foobar(a, &b, &p);    printf("a=%d, b=%d, c=%d, *p=%d\n", a, b, c, *p);    return (0);}

• a=1, b=2, c=3, *p=2
• a=101, b=2, c=3, *p=2
• a=101, b=101, c=2, *p=3
• a=1, b=101, c=2, *p=3

答案： A