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

int gcd( int i,  int j) {      int r = i % j;      return r == 0 ? j : gcd(j, r); }

正确性分析: