牛客网-c++专项练习简单版

牛客网-c++专项练习简单版

1.#include<file.h> 与 #include "file.h"的区别？

答：前者首先从当前工作路径搜寻并引用file.h，而后者首先从Standard Library的路径寻找和引用file.h

2.求输出结果

#include <stdio.h>
main(){
    int i=0;
    i=～i;
    printf("%d\n",i);
｝

• 1
• 2
• 3
• 4
• 5
• 6

答：-1 
解析： 
0 = 00000000000000000000000000000000 
取反11111111111111111111111111111111就是-1在计算机的存储形式 
计算机内， 负数已反码形式存储， 符号位不变， 源码求反加1， 就是反码 
11111111111111111111111111111111 就是 
10000000000000000000000000000001 求反 11111111111111111111111111111110 
加1 就是 11111111111111111111111111111111

3.下面程序的错误

struct Test
 {
     Test( int ) {}
     Test() {}
     void fun() {}
 };
 void main( void )
 {
     Test a(1);
     a.fun();
     Test b();
     b.fun();
 }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

答：b.fun()会出错。 
解析： 
Test a(1); //新建了一个对象 
a.fun(); //因此可以调用函数 
Test b(); //声明了一个函数，并没有新建对象 
b.fun(); //没有新建对象，则不能调用函数

4.输出结果是

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; }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

答:12 
解析： Base * pb = new Child(1)， 首先创建子类对象，初始化为1； 
func1()不是虚函数，所以pb->func1()执行的是基类的func1函数，i= 10，然后调用func2()函数； 
这里的func2是虚函数，要往下派生类寻找，找到后执行派生类中的func2(),此时，i = 12； 
最后执行pb->getValue(),结果为12

5.描述正确的是： 
A.虚函数是没有实现的函数 
B.纯虚函数的实现是在派生类中 
C.抽象类是没有纯虚函数的类 
D.抽象类指针可以指向不同的派生类 
答：BD 
解析： 
关键字virtual修饰的成员函数叫做虚函数，虚函数是为了实现多态而存在的，必须 有函数体 
纯虚函数的声明，是在虚函数声明的结尾加=0，没有函数体。在派生类中没有重新定义虚函数之前是不能调用的 
如果一个类中至少含有一个纯虚函数，此时称之为抽象类。所以抽象类一定有纯虚函数 
基类类型的指针可以指向任何基类对象或派生类对象

6:以下为自动变量的是：

A.double k;

B.register int i;

C.static char c;

D.auto long m;

答：AD

解析: 
简单介绍一下register变量：它是把变量存储在cpu中的寄存器中，当一个变量需要反复读写时，不需要反复的访问内存，而直接可以使用它，并且，register是一个建议型的关键字，编译器可能会因为变量不满足一定条件而放弃使用寄存器变量。一般情况下将局部自动变量和函数形参作为寄存器变量。 
所以当定义一个静态变量为寄存器变量，编译器不会通过，它仍然还是静态变量 
普通的变量，不管是否声明为auto，都是自动型变量 
A，普通变量，是auto的 
B，寄存器变量，不是 
C，静态变量，不是 
D，声明为auto，是

7:在C++STL中常用的容器和类型，下面哪些支持下标”[]”运算？

vector :T 
list: 
deque:T 
map:T 
set: 
unordered_map:T 
unordered_set: 
stack: 
string:T

解析： 
vector:随机访问迭代器,复杂度O（1） 
deque：同上，O（1） 
map：双向迭代器，不过由于是关联容器，需要通过key访问alue的方法，O（h），h为树的高度 
unordered_map：前向迭代器，同上，平摊复杂度O（1），最差O（n），也与散列函数的好坏有关。 
string：同vector 
注意：支持随机访问就支持[]； 
8：求k值 
enum { 
a, b=5, c, d=4, e 
} k; 
k =c; 
答：6 
9：下列关于联合的描述中，错误的是？

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

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

union Test
{
    int a;
    float b;
};
Test test = {1};

• 1
• 2
• 3
• 4
• 5
• 6

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

结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。 
对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

10：以下哪种STL容器中的对象是连续存储的:()

list 
vector:T 
map 
set 
解析： 
只有dqeue和vector是连续存储的 
vector的实现是是同个一个连续的数组存放元素。

11: 下面程序段的输出结果是

char *p1 = ”123”, *p2 = ”ABC”, str[50] = “xyz”; 
strcpy(str + 2, strcat(p1, p2)); 
printr(“%s\n”, str); 
答：出错。 
解析： 
char *p1=”123” 声明了个字符串指针p1，指向字符串“ 123 ”，此时的“ 123 ”存放在常量区，并没有在拷贝到栈中，所以不能修改，如修改p1[0] = ‘2’就是错误的。 
建议改为char p1[10] = “123”，就可以修改p1的值。

原代码有错：p1和p2都指向常量字符串，在常量区，所以不能对其进行操作；改为数组即可，但是用字符串初始化数组时要记得将数组长度加1，因为字符串默认的末尾有一个‘\0’；第二点要注意的是，strcat函数的p1要有足够的空间来容纳p1和p2连接后的串长。

修改为以下代码将可以： 
char p1[7] = “123”; 
char p2[] = “ABC”; 
char str[50] = “xyz”; 
strcpy(str + 2, strcat(p1, p2)); 
printf(“%s\n”, str);

12：x为整型，请用位运算实现x%8 
答：x&7 
解析： 
当我们求余的时候，相当于除以2的N次冥，也就是相当于把数本身右移N位，但是右移掉的那些位需要通过位运算进行保留；用以上例子来说，X%8即X%2^3,那么就需要右移三次，那么移去的三位需要保留下来，而8=1000，刚好，可以使用0111来保留下来后三位，于是，对于除数都是2的整数次幂的情况，可以使用x & (2^n-1)的方法进行与运算，保留下来的最末尾的n位就是余数。 
该题中，结果为x&7.