18.04.28 17年程设考试题

编程填空部分

A01:编程填空：统计动物数量

描述

代码填空，使得程序能够自动统计当前各种动物的数量

#include 
using namespace std;
// 在此处补充你的代码
void print() {
    cout << Animal::number << " animals in the zoo, " << Dog::number << " of them are dogs, " << Cat::number << " of them are cats" << endl;
}

int main() {
    print();
    Dog d1, d2;
    Cat c1;
    print();
    Dog* d3 = new Dog();
    Animal* c2 = new Cat;
    Cat* c3 = new Cat;
    print();
    delete c3;
    delete c2;
    delete d3;
    print();
}

输入

无

输出

0 animals in the zoo, 0 of them are dogs, 0 of them are cats
3 animals in the zoo, 2 of them are dogs, 1 of them are cats
6 animals in the zoo, 3 of them are dogs, 3 of them are cats
3 animals in the zoo, 2 of them are dogs, 1 of them are cats样例输入

None

样例输出

0 animals in the zoo, 0 of them are dogs, 0 of them are cats
3 animals in the zoo, 2 of them are dogs, 1 of them are cats
6 animals in the zoo, 3 of them are dogs, 3 of them are cats
3 animals in the zoo, 2 of them are dogs, 1 of them are cats

 1 #include 
 2 using namespace std;
 3 class Animal {
 4 public:
 5     static int number;
 6     Animal() {
 7         number++;
 8     }
 9     Animal(Animal &a) {
10         number++;
11     }
12     virtual ~Animal() {
13         number--;
14     }
15 };
16 class Dog :public Animal {
17 public:
18     static int number;
19     Dog() {
20         number++;
21     }
22     Dog(Dog &a) {
23         number++;
24     }
25     ~Dog() {
26         number--;
27     }
28 };
29 class Cat :public Animal {
30 public:
31     static int number;
32     Cat() {
33         number++;
34     }
35     Cat(Cat &a) {
36         number++;
37     }
38     ~Cat() {
39         number--;
40     }
41 };
42 int Animal::number = 0, Dog::number = 0,Cat::number=0;
43 void print() {
44     cout << Animal::number << " animals in the zoo, " << Dog::number << " of them are dogs, " << Cat::number << " of them are cats" << endl;
45 }
46 
47 int main() {
48     print();
49     Dog d1, d2;
50     Cat c1;
51     print();
52     Dog* d3 = new Dog();
53     Animal* c2 = new Cat;
54     Cat* c3 = new Cat;
55     print();
56     delete c3;
57     delete c2;
58     delete d3;
59     print();
60 }

View Code

A02:编程填空：简单的计算

描述

补充代码，使程序按要求输出 

#include 
using namespace std;
template <class T>
class Add{
public:
// 在此处补充你的代码
};

int main(){
    double f;
    int n;
    while( cin >> f >> n) {
        
        Add<double> a1(f);
        Add<int> a2(n);
        double x,y;
        int p,q;
        cin >> x >> y >> p >> q;
        cout << a1(x, y) << endl;
        cout << a2(p, q) << endl;
    }
    return 0;
}

输入

有若干组数据
每组数据三行
第一行是一个浮点数f和一个整数 n
第二行是两个浮点数 x 和 y
第三行是两个整数 p 和q

输出

对每组数据
先输出 x + y - f
再输出 p + q - n样例输入

2.2 3
1.0 2.0
10 20
4.5 30
4.8 9.2
100 200

样例输出

0.8
27
9.5
270

 1 #include 
 2 using namespace std;
 3 template <class T>
 4 class Add{
 5 public:
 6 float minus;
 7     Add(float a) :minus(a) {}
 8     float operator ()(T x, T y) {
 9         return (float)(x + y) - minus;
10     }
11 };
12 
13 int main(){
14     double f;
15     int n;
16     while( cin >> f >> n) {
17         
18         Add<double> a1(f);
19         Add<int> a2(n);
20         double x,y;
21         int p,q;
22         cin >> x >> y >> p >> q;
23         cout << a1(x, y) << endl;
24         cout << a2(p, q) << endl;
25     }
26     return 0;
27 }

View Code

A04:编程填空：回调函数

描述

输入x1 x2 x3 x4 x5 ，输出y = x5^5 + x4^4 + x3^3 + x2^2 + x1^1 + 1的y的值

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 
#include 

输入

多组数据。第一行是数据组数 n
每组数据为一行,5个整数，x1 x2 x3 x4 x5。数值不大，不必考虑溢出

输出

对每组数据，输出一个整数y， y = x5^5 + x4^4 + x3^3 + x2^2 + x1^1 + 1

样例输入

2
2 2 2 2 2
1 1 1 1 1

样例输出

63
6

 1 #include 
 2 #include 
 3 #include 
 4 #include 
 5 #include 
 6 #include 
 7 #include 
 8 #include <string>
 9 #include 
10 #include 

View Code

A05:编程填空：二进制输出

描述

给出一个int表示范围内的正整数x，输出其二进制表示。一共要输出31位，不足处要补0。

#include 
#include <string>
using namespace std;
string dec2bin(int x){
// 在此处补充你的代码
}
int main(){
    int n;
    cin >> n;
    while(n--) {
        int x;
        cin >> x;
        cout << dec2bin(x) << endl;
    }
    return 0;
}

输入

第一行是整数n(n<15)，表示有n个正整数要处理
第二行是n个正整数

输出

对每个给出的正整数，输出其二进制表示。不足31位则用0补齐到31位样例输入

3
1 2 3

样例输出

0000000000000000000000000000001
0000000000000000000000000000010
0000000000000000000000000000011

 1 #include 
 2 #include <string>
 3 using namespace std;
 4 string dec2bin(int x){
 5     string bina = "";
 6     while (x != 0) {
 7         bina += to_string(x % 2);
 8         x /= 2;
 9     }
10     while (bina.length() < 31) {
11         bina += to_string(0);
12     }
13     string b = "";
14     b.resize(31);
15     for (int i = 0; i <= 30; i++) {
16         b[i] = bina[30 - i];
17     }
18     return b;
19 }
20 int main(){
21     int n;
22     cin >> n;
23     while(n--) {
24         int x;
25         cin >> x;
26         cout << dec2bin(x) << endl;
27     }
28     return 0;
29 }

View Code

这道！我当时想的是二进制数一定是32位的，31位是从0开始数的……然后调了很久

虽然是我自己的问题但我觉得还是很坑

A06:编程填空：去除重复元素排序

描述

程序填空，使其按要求输出

#include 
#include 
#include 

输入

第一行是个整数，表示输入数据组数 
每组数据一行,有12个整数

输出

对每组数据, 将12个整数从小到大排序并去除重复元素后输出样例输入

2
34 5 4 6 3 9 8 34 5 3 3 18
31 2 4 6 2 9 8 31 5 3 3 18

样例输出

3 4 5 6 8 9 18 34 
2 3 4 5 6 8 9 18 31 

提示注意：行末都有一个空格

A07:编程填空：还是Fun和Do

描述

填写代码，使输出结果为
A::Fun
B::Do
C::Fun
C::Do
A::Fun
B::Do

#include  
using namespace std;

class A { 
    public: 
        virtual void Fun() { 
            cout << "A::Fun" << endl; 
        }; 
        virtual void Do() { 
            cout << "A::Do" << endl; 
        } 
};
// 在此处补充你的代码
{ 
    p.Fun(); 
    p.Do(); 
} 

void Call2(B p) {
    p.Fun();
    p.Do();
}



int main() { 
    C c;
    B b;
    Call1(b);
    Call1(c); 
    Call2(c);
    return 0;
}

 

输入

无

输出

A::Fun
B::Do
C::Fun
C::Do
A::Fun
B::Do样例输入

None

样例输出

A::Fun
B::Do
C::Fun
C::Do
A::Fun
B::Do

 1 #include  
 2 using namespace std;
 3 
 4 class A { 
 5     public: 
 6         virtual void Fun() { 
 7             cout << "A::Fun" << endl; 
 8         }; 
 9         virtual void Do() { 
10             cout << "A::Do" << endl; 
11         } 
12 };
13 class B:public A {
14 public:
15     void Do() {
16         cout << "B::Do" << endl;
17     }
18 };
19 class C:public B {
20 public:
21     void Do() {
22         cout << "C::Do" << endl;
23     }
24     void Fun() {
25         cout << "C::Fun" << endl;
26     };
27 };
28 void Call1(A &p)
29 { 
30     p.Fun(); 
31     p.Do(); 
32 } 
33 
34 void Call2(B p) {
35     p.Fun();
36     p.Do();
37 }
38 
39 
40 
41 int main() { 
42     C c;
43     B b;
44     Call1(b);
45     Call1(c); 
46     Call2(c);
47     return 0;
48 }

View Code

A08:编程填空：Printer

描述

完成以下程序，使得输入的整数x，以及若干正整数，将
大于x的正整数输出；然后输入若干字符串，将字符串长度大于x的字符串输出

#include
#include
#include
#include

using namespace std;


class Printer{
// 在此处补充你的代码
int main(){

    int t;
    cin >> t;
    while(t--) {
        int n,x;
        cin>>x>>n;
        
        vector<int> intVec;
        for(int i = 0;i < n; ++i) {
            int y;
            cin >> y;
            intVec.push_back(y);
        }
        for_each(intVec.begin(), intVec.end(), Printer(x));
        cout<<endl;
        
        vector<string> strVec;
        for(int i = 0;i < n; ++i) {
            string str;
            cin >> str;
            strVec.push_back(str);
        }
        for_each(strVec.begin(), strVec.end(), Printer(x));
        cout<<endl;
    }
    return 0;
}

输入

第一行是整数t，表示一共t组数据
每组数据有三行 
第一行是整数x和整数 n 
第二行是n个整数 
第三行是n个不带空格的字符串

输出

对每组数据
先按原序输出第一行中大于x的正整数(数据保证会有输出） 
再按原序输出第二行中长度大于x的字符串 (数据保证会有输出）样例输入

2
5 6
1 3 59 30 2 40
this is hello please me ha
1 1
4
this

样例输出

59,30,40,
please,
4,
this,

 1 #include
 2 #include
 3 #include
 4 #include
 5 
 6 using namespace std;
 7 
 8 
 9 class Printer{
10 public:
11     int x;
12     Printer(int _x):x(_x){}
13     void operator()(int a) {
14         if (a > x)
15             cout << a << ",";
16     }
17     void operator()(string a) {
18         if (a.length() > x)
19             cout << a << ",";
20     }
21 };
22 int main(){
23 
24     int t;
25     cin >> t;
26     while(t--) {
27         int n,x;
28         cin>>x>>n;
29         
30         vector<int> intVec;
31         for(int i = 0;i < n; ++i) {
32             int y;
33             cin >> y;
34             intVec.push_back(y);
35         }
36         for_each(intVec.begin(), intVec.end(), Printer(x));
37         cout<<endl;
38         
39         vector<string> strVec;
40         for(int i = 0;i < n; ++i) {
41             string str;
42             cin >> str;
43             strVec.push_back(str);
44         }
45         for_each(strVec.begin(), strVec.end(), Printer(x));
46         cout<<endl;
47     }
48     return 0;
49 }

View Code

A09:编程填空：前K大的偶数描述

输入

n个整数，输出整数数列中大小排名前k的偶数

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include <string>
#include 

输入

有多组数据
第一行是数据组数 t
对每组数据： 
第一行为整数n (n>=3)和k
接下来的一行为n个整数，保证这些整数中至少有k个偶数。

输出

对每组数据，输出k个整数，降序排列，表示选出来的大小排名前k的偶数样例输入

2
9 4
1 2 4 3 6 6 7 8 9
3 2
18 16 14

样例输出

8 6 6 4
18 16

 1 #include 
 2 #include 
 3 #include 
 4 #include 
 5 #include 
 6 #include 
 7 #include 
 8 #include <string>
 9 #include 

View Code

A10:编程填空：MyClass

描述

补充下列代码，使得程序的输出为：
A:3
A:15
B:5
3
15
5

#include 
using namespace std;
class CMyClassA {
    int val;
public:
    CMyClassA(int);
    void virtual print();
};
CMyClassA::CMyClassA(int arg) {
    val = arg;
    printf("A:%d\n", val);
}
void CMyClassA::print() {
    printf("%d\n", val);
    return;
}
// 在此处补充你的代码
int main(int argc, char** argv) {
    CMyClassA a(3), *ptr;
    CMyClassB b(5);
    ptr = &a; ptr->print();
    a = b;
    a.print();
    ptr = &b; ptr->print();
    return 0;
}

输入

无

输出

见样例

样例输入

None

样例输出

A:3
A:15
B:5
3
15
5

 1 #include 
 2 using namespace std;
 3 class CMyClassA {
 4     int val;
 5 public:
 6     CMyClassA(int);
 7     void virtual print();
 8 };
 9 CMyClassA::CMyClassA(int arg) {
10     val = arg;
11     printf("A:%d\n", val);
12 }
13 void CMyClassA::print() {
14     printf("%d\n", val);
15     return;
16 }
17 class CMyClassB :public CMyClassA {
18 public:
19     int val2;
20     CMyClassB(int x) :CMyClassA(3 * x), val2(x) {
21         printf("B:%d\n", val2);
22     }
23     void print() {
24         printf("%d\n", val2);
25     }
26 };
27 int main(int argc, char** argv) {
28     CMyClassA a(3), *ptr;
29     CMyClassB b(5);
30     ptr = &a; ptr->print();
31     a = b;
32     a.print();
33     ptr = &b; ptr->print();
34     return 0;
35 }

View Code

A11:编程填空：又是MyClass

描述

补充下列代码，使得程序能够按要求输出

#include 
#include  
#include 
#include  
using namespace std;
// 在此处补充你的代码
int  a[40];
int main(int argc, char** argv) {
    int t;
    scanf("%d",&t);
    while ( t -- ) {
        int m;
        scanf("%d",&m);
        for (int i = 0;i < m; ++i) 
            scanf("%d",a+i);
        char s[100];
        scanf("%s",s);
        CMyClass<int> b(a, m);
        CMyClass<char> c(s, strlen(s));
        printf("%d %c\n", b[5], c[7]);
    }
    return 0;
}

输入

第一行是整数t表示数据组数 
每组数据有两行 
第一行开头是整数m，然后后面是m个整数(5 < m < 30)
第二行是一个没有空格的字符串，长度不超过50

输出

对每组数据 先输出m个整数中的第5个，然后输出字符串中的第7个字符。
"第i个"中的 i 是从0开始算的。样例输入

1
6 1 3 5 5095 8 8
helloworld

样例输出

8 r

 1 #include 
 2 #include  
 3 #include 
 4 #include  
 5 using namespace std;
 6 template<class T>
 7 class CMyClass {
 8 public:
 9     T *p;
10     CMyClass(T*s, int wid) {
11         p = new T[wid];
12         for (int i = 0; i < wid; i++) {
13             p[i] = *s;
14             s++;
15         }
16     }
17     T operator[](int x) {
18         return *(p + x);
19     }
20 };
21 int  a[40];
22 int main(int argc, char** argv) {
23     int t;
24     scanf("%d",&t);
25     while ( t -- ) {
26         int m;
27         scanf("%d",&m);
28         for (int i = 0;i < m; ++i) 
29             scanf("%d",a+i);
30         char s[100];
31         scanf("%s",s);
32         CMyClass<int> b(a, m);
33         CMyClass<char> c(s, strlen(s));
34         printf("%d %c\n", b[5], c[7]);
35     }
36     return 0;
37 }

View Code

A12:编程填空：简单的对象

描述

程序填空，使得程序输出:
2
1
1
0

#include 
using namespace std;
class A
{
    static int num;
public:
    A(){num+=1;}
    void func()
    {
        cout<< num <<endl;
    }
// 在此处补充你的代码
};

int A::num=1;

int main()
{
    A a1;
    const A a2 = a1;
    A & a3 = a1;
    const A & a4 = a1;

    a1.func();
    a2.func();
    a3.func();
    a4.func();

    return 0;
}

输入

无

输出

2
1
1
0

样例输入

None

样例输出

2
1
1
0

 1 #include 
 2 using namespace std;
 3 class A
 4 {
 5     static int num;
 6 public:
 7     A(){num+=1;}
 8     void func()
 9     {
10         cout<< num <<endl;
11     }
12     void func()const {
13         num--;
14         cout << num << endl;
15     }
16 };
17 
18 int A::num=1;
19 
20 int main()
21 {
22     A a1;
23     const A a2 = a1;
24     A & a3 = a1;
25     const A & a4 = a1;
26 
27     a1.func();
28     a2.func();
29     a3.func();
30     a4.func();
31 
32     return 0;
33 }

View Code

A13:编程填空：三生三世

描述

近年来，国内电视剧吸引了越来越多的关注；有的以当红的演员阵容而吸引观众，比如《三生三世十里桃花》（Life After Life，Blooms Over Blooms）；有的以贴近时代的剧情而备受关注，比如《人民的名义》（In the Name of People）；有的则以精湛的演技赢得观众的喜欢，比如《大明王朝：1566》（Ming Dynasty: 1566）。
你的任务是根据电视剧的不同属性（演员、剧情和演技）对电视剧进行排行。

#include
#include
#include
#include
using namespace std;

class TV_Drama{
    public:
    char name[100];
    int actor;
    int story;
    int acting_skill;
// 在此处补充你的代码
int main(){
    list lst;
    int n;
    
    cin>>n;
    char  _name[100];
    int _actor, _story, _acting_skill;
    for (int i=0; i){
        cin.ignore();
        cin.getline(_name,100);
        cin>>_actor>>_story>>_acting_skill;
        lst.push_back(TV_Drama(_name, _actor, _story, _acting_skill));
    }

    lst.sort();
    for_each(lst.begin(), lst.end(), Printer);    
    cout<<endl;

    lst.sort(comparator_1);
    for_each(lst.begin(), lst.end(), Printer);    
    cout<<endl;

    lst.sort(comparator_2());
    for_each(lst.begin(), lst.end(), Printer);    
    cout<<endl;

    return 0;
}

输入

首先输入整数n，代表电视剧的个数。接下来，对于每个电视剧有两行输入：第一行一个字符串（可能含有空格，逗号，冒号等标点符号）作为电视剧的名字；第二行包括三个整数，分别为演员阵容、剧情和演技的评分。

输出

输出包括三行，分别为电视剧按演员阵容、剧情和演技的排行榜（评分由高到低），电视剧名字之间以分号隔开样例输入

3
In the Name of People
98 97 99
Life After Life, Blooms Over Blooms
99 82 73
Ming Dynasty: 1566
97 100 100

样例输出

Life After Life, Blooms Over Blooms;In the Name of People;Ming Dynasty: 1566;
Ming Dynasty: 1566;In the Name of People;Life After Life, Blooms Over Blooms;
Ming Dynasty: 1566;In the Name of People;Life After Life, Blooms Over Blooms;

 1 #include
 2 #include
 3 #include
 4 #include
 5 using namespace std;
 6 
 7 class TV_Drama{
 8     public:
 9     char name[100];
10     int actor;
11     int story;
12     int acting_skill;
13 TV_Drama(char *_name, int _actor, int _story, int _ac) :actor(_actor), story(_story), acting_skill(_ac) {
14         int len = 0;
15         for (int i = 0; _name[i] != '\0'; i++) {
16             name[i] = _name[i];
17             len++;
18         }
19         name[len] = '\0';
20     }
21     bool operator<(TV_Drama&l) {
22         return actor > l.actor;
23     }
24 };
25 void Printer(TV_Drama x) {
26     cout << x.name << ";";
27 }
28 bool comparator_1(TV_Drama &x1,TV_Drama &x2) {
29     return x1.story > x2.story;
30 }
31 class comparator_2{
32 public:
33     comparator_2() {}
34     bool operator() (TV_Drama &x1, TV_Drama &x2) {
35         return x1.acting_skill > x2.acting_skill;
36     }
37 };
38 int main(){
39     list lst;
40     int n;
41     
42     cin>>n;
43     char  _name[100];
44     int _actor, _story, _acting_skill;
45     for (int i=0; i){
46         cin.ignore();
47         cin.getline(_name,100);
48         cin>>_actor>>_story>>_acting_skill;
49         lst.push_back(TV_Drama(_name, _actor, _story, _acting_skill));
50     }
51 
52     lst.sort();
53     for_each(lst.begin(), lst.end(), Printer);    
54     cout<<endl;
55 
56     lst.sort(comparator_1);
57     for_each(lst.begin(), lst.end(), Printer);    
58     cout<<endl;
59 
60     lst.sort(comparator_2());
61     for_each(lst.begin(), lst.end(), Printer);    
62     cout<<endl;
63 
64     return 0;
65 }

View Code

选择题部分

关于复制构造函数，下列说法正确的是
A. 系统不会生成缺省复制构造函数，因此必须自己实现
B. 复制构造函数是形如X::X(X)的函数
C. Myclass c1, c2; c1.n = 1; c2 = c1;第三句将会调用复制构造函数
D. 调用函数A Func(){A a(4); return a;}时，将会调用A的复制构造函数

//D

关于虚函数，下列说法不正确的是
A. 不允许以虚函数作为构造函数
B. 没有虚函数便无法实现多态
C. 一般来讲，如果一个类中定义了虚函数，则不可将析构函数也定义为虚函数
D. 不能用抽象类定义对象

//C

下列类模板不支持迭代器的是
A. stack
B. vector
C. list
D. set

//A

关于this指针，以下说法不正确的是
A. static成员函数内部不可以使用this指针 
B. 在构造函数内部可以使用this指针 
C. 在析构函数内部可以使用this指针
D. const成员函数内部不可以使用this指针  

//D

将一个对象放入STL中的容器里时，以下说法正确的是 
A. 实际上被放入的是该对象的指针 
B. 实际上被放入的是该对象的一个拷贝（副本） 
C. 实际上被放入的是该对象的引用 
D. 实际上被放入的就是该对象自身

//B

关于顺序容器迭代器的操作，不正确的是

A. vector::iterator iter1, iter2; iter1
B．list::iterator iter1, iter2; iter1
C. vector::iterator iter1; iter1-=3;
D. deque::iterator iter1; iter1+=5;

//B

map的每个元素包括KEY(first)和VALUE(second)。关于map容器，下列哪种说法错误
A. map支持下标运算符
B. map的不同元素可以有相同的VALUE 
C. map支持STL的sort算法
D. map支持双向迭代器

//C

下列哪个运算符可以被重载
A. ->
B. ?:
C. .
D. ::

//A

关于类的static成员函数，下列哪个说法正确
A. static成员函数中，可以访问当前类的virtual成员函数
B. static成员函数中，可以访问父类的private成员函数
C. static成员函数中，不允许调用当前类的非const成员函数
D. static成员函数中，不允许使用this指针 

//D

下列说法错误的是
A. 可以在一个类的友元函数中使用this指针
B. 每个类只有一个析构函数
C. 抽象类至少包含一个纯虚函数
D. 构造函数不可以是virtual函数

//A

下列说法正确的是
A. 每个类至少有两个构造函数
B. 构造函数的返回值必须是void类型的
C. 有可能通过基类的指针调用派生类的virtual函数
D. C++语法不允许派生类的成员变量和基类的成员变量同名

//C

下列关于运算符重载的描述中，正确的是: 
A. 运算符只能被重载一次
B. 流插入运算符“<<”可以是类的友元函数
C. 所有的运算符可以被重载为普通函数，也可以重载为成员函数
D. 运算符重载可以改变运算符的优先级

//B

关于继承和派生的描述中，下列说法错误的是:
A. 派生类的成员函数中，不能访问基类的private成员
B. 在派生类的析构函数执行之前，会先调用基类的析构函数
C. 派生类对象的地址可以赋值给基类指针
D. 派生类可以有和基类同名同参数的成员函数

//B

以下哪种使用std::sort算法的方式是不合法的： 
A. vector a; …; sort(a.begin(), a.end());
B. bool b[99]; …; sort(b, b + 99);
C. string c = “2333”; …; sort(c.begin(), c.end());
D. listd; …; sort(d.begin(), d.end());

//D

类A重载的运算符声明是int operator<(A &other) const，那么以下说法中正确的是
A. 小于号左侧的A对象不可以是const的
B. 小于号右侧的A对象不可以是const的
C. 这个写法是错误的，因为小于号的返回类型必须是bool
D. 使用小于号的时候，other参数处，传进来的对象实际上会被复制一次

//B

系统在调用重载函数时，往往根据一些条件确定哪个重载函数被调用，在下列选项中，不能作为依据的是
A. 参数个数 
B. 参数的类型
C. 函数的返回值的类型
D. 函数名称

//C

关于构造函数，下列选项错误的是
A. 构造函数可以是虚函数 
B. 构造函数的参数可以有缺省值
C. 定义了构造函数，则编译器不生成默认的无参数的构造函数
D. 构造函数不能继承

//A

以下顺序容器不支持随机访问迭代器的是
A. vector
B. deque
C. list
D. 以上容器都支持

//C

以下STL中的函数模板哪个可以作用于set
A. sort
B. random_shuffle
C. find
D. 都不行

//C

以下关于多态的说法哪个不正确
A. 在成员函数中调用虚函数，是多态
B. 通过“基类对象名.函数名”的方式调用虚函数，不是多态
C. 多态的函数调用语句中，函数一定是虚函数
D. 通过“基类引用名.函数名”的方式调用虚函数，是多态

//A

　　　　题好多……原以为能在十分钟排完的……所以可能排的时候并不认真，也许选择题部分会有错误

 做了一遍发现基本上知识点全忘了（x

转载于:https://www.cnblogs.com/yalphait/p/8969555.html