C++牛客知识点3

晴山ぺ

已于 2024-03-20 10:53:44 修改

阅读量588

点赞数 15

分类专栏：牛客练习题 C++ 文章标签： c++

于 2024-01-09 20:23:22 首次发布

本文链接：https://blog.csdn.net/2301_77560238/article/details/135489090

版权

C++ 同时被 2 个专栏收录

32 篇文章 0 订阅

订阅专栏

牛客练习题

6 篇文章 1 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、pandas是什么？
二、使用步骤
- 1.引入库
- 2.读入数据
总结

前言

接上文。

2024年

1月2号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

1月9号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

假定MyClass为一个类，则该类的拷贝构造函数的声明语句是：答案C

A、MyClass(const MyClass x)

B、MyClass &(const MyClass x)

C、MyClass(const MyClass &x)

D、MyClass(const MyClass *x)

解释：正确答案：C
拷贝构造函数的参数必须使用引用传递，并且使用 const 修饰。
使用引用是因为，如果不使用引用，那么调用时参数赋值时又会调用拷贝构造函数，就行程了死递归，并且使用引用还能减少数据的拷贝。
使用 const 是因为防止在函数内对原先的数据进行修改。

2、题目2

下面程序应该输出多少？答案A

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

A、POINTERSTEW

B、FERSTEPOINW

C、NEWPOINTW

D、POINTFIREST

解释：答案A。这个题目我做对了，但是感觉还是一知半解。

虽然项目中不这么用，但是要答对还是需要扎实的基础知识。其中考了指针应用，隐含中也考了运算符优先级的问题（*--*++cpp+3）具体运算符优先关系记忆这个写的比较好http://blog.csdn.net/skywalker_leo/article/details/6237222 c是一个指针数组，每个数组单元都是一个指针，指向一个字符串。即c[0]="ENTER"......c[3]="FIRST" 由于[]与*运算本质几乎是一致的，以下用[]替换*更容易理解。 c[i]=*(c+i) c和c+i都是char*[]类型，它可以退化成char**类型，它正好是一个char**数组 cp[0]=c+3 .....cp[3]=c 引用后cp[0][0]=*(c+3)=c[3]="FIRST" cp是char**[]类型，它可以退化成char***类型，正好与cpp类型一致。 1>++ccp的值是cp+1 *++p=*(cp+1)=cp[1] **++p=*(cp[1])=c[2]="POINT"

2>运算符优先级决定运算先后关系 ++ccp的值是cp+2 *++p=*(cp+2)=cp[2]=c+1 --*++p=c *--*++p=*(c+0)=c[0]="ENTER"再+3字符串指向"ER"

3>cpp的值为cp+2 cpp[-2]=*(cpp-2)=*(cp+2-2)=cp[0]=c+3再引用*（c+3）=c[3]="FIRST"字符串指到"ST"

4>cpp的值没变，cpp[-1]=*(cpp-1)=*(cp+2-1)=cp[1]=c+2再[-1]得*(c+2-1)=c[1]="NEW",+1字符创指针指到"EW" 翻来覆去，记得这个换算关系式即可，c[i]=*(c+i)。

上面是解释，下面我还要写一些自己的感受。就是我一开始看到这个题目，被

char **cp[] = { c+3, c+2, c+1, c };

这个写法搞蒙了，就是为什么这个数组要写成二级指针，一级指针不行吗？然后我想了一下，其实可以，但是写成一级指针就没办法通过解引用解析一开始的数据了。至少是不方便。

char* setInfo(char *str, int len)
{
    char* arrayStr = (char*)malloc(len);
    strcpy(arrayStr, str);
    return arrayStr;
}

int main() {
  char* p = setInfo("pen",20);            //这个是想验证常量指针能否传给非const指针。评论有的人说跟编译器有关，vs上不行。同时c++也不行
  printf("%s\n", p);

  int a1[] = {1, 2, 3, 4, 5};
  int* a2[] = {a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4};
  int** a3[] = {a2, a2 + 1, a2 + 2, a2 + 3, a2 + 4, a2 + 5};
  printf("%d, %d, %d, %d, %d\n", **a2, **(a2+1), **(a2+2), **(a2+3), **(a2+4) );
  printf("%d, %d, %d, %d, %d\n", ***a3, ***(a3+1), ***(a3+2), ***(a3+3), ***(a3+4) );

  //如果a2不是用指针接收
//  int a2b[] = {a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4};         //error: invalid conversion from 'int*' to 'int'
//  printf("%d\n", a2b[0]);

  //那么如果写数组会变易报错，那就直接写个变量
  //int a2b2 = a1;        //这边也会报类型不符
  unsigned int a2b2b = (unsigned int)a1;
  printf("%d\n", a2b2b);
  unsigned int* p2 = (unsigned int*)a2b2b;
  printf("%d\n", *p2);
  //这样将地址强制转化为指针才能访问到指针地址指向的数据

  return 0;
}


//pen
//1, 2, 3, 4, 5
//1, 2, 3, 4, 5
//6422272
//1

vs上上述常量指针传参给非const指针会编译错误

对于这题，可以总结一个做题技巧，那就是指向数组的二级指针解引用就是所指向的数组的成员。没解引用就是数组成员的地址。

3、题目3

所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。答案B

A、是

B、否

4、题目4

设有以下定义程序 ; 则以下合法的调用语句是（正确答案BC）

#include <iostream>
using namespace std;
class A1 {
public:
    void show1() {
        cout << "class A1" << endl;
    }
};
class A2 : public A1 {
    void show2() {
        cout << "class A2" << endl;
    }
};
class A3 : protected A2 {
    void show3() {
        cout << "class A1" << endl;
    }
};
int main() {
    A1 obj1;
    A2 obj2;
    A3 obj3;
    return 0;
}

A、obj3.show3();

B、obj2.show1();

C、obj1.show1();

D、obj3.show1();

5、32位系统中关于下面程序说法正确的是（正确答案ABCD ）

A、main函数定义了一个stock对象占8个字节

B、storage和desc成员各占4个字节

C、存在内存泄漏的问题

D、存在编译错误

一、1月10号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

在派生类的函数中，能够直接访问全部基类的公有成员和保护成员。这句话是否正确？正确答案B

A、正确

B、错误

2、题目2

cin 是 istream 类的成员函数。正确答案B

A、正确

B、错误

3、题目3

下面代码的输出结果是什么 ( 正确答案C )

#include <iostream>
using namespace std;
class A
{   
    public: void virtual f() 
    {      
        cout << "A" << " ";
    }
};
class B : public A
{   
    public: void virtual f()
    {      
        cout << "B" << " ";
    }
};
int main(){
    A *pa = new A();
    pa->f();
    B *pb=(B *)pa;
    pb->f();    
    delete pa, pb;
    pa=new B();
    pa->f();
    pb=(B *)pa;
    pb->f();
    return 0;
}

A、A A B A

B、A B B A

C、A A B B

D、A A A B

4、题目4

哪些因素可能会影响到一个类的大小（多选）正确答案：ACF

A、成员个数
B、函数个数
C、是否有虚函数
D、虚函数个数
E、静态变量个数
F、对齐方式

5、题目5

下列关于C++类的说法中错误的有哪些？正确答案BCD
A、一个空类默认会生成构造函数,拷贝构造函数,赋值操作符,析构函数
B、一个类可以有多个析构函数
C、类中析构函数可以为virtual,可以被重载
D、类的构造函数如果都不是public访问属性,则类的实例无法创建

1月15号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

查看下面两段代码（正确答案AC）

①

class classA
{
    ...
};
class classB
{
public:
    classB(classA a)
    {
        mA = a;
    }
private:
    classA mA;
};

②

class classA
{
    ...
};
class classB
{
public:
    classB(classA a): mA(a) {}
private:
    classA mA;
};

A、两种调用方法效果是一样的

B、通常情况下（1）的效率更高

C、通常情况下（2）的效率更高

D、两种调用方法效果是不一样的

解释：

C++ Primer中在讲构造函数初始化列表的时候有这么一段话：
无论是在构造函数初始化列表中初始化成员，还是在构造函数体中对它们赋值，最终结果是相同的。不同之处在于，使用构造函数初始化列表的版本初始化数据成员，没有定义初始化列表的构造函数版本在构造函数体中对数据成员赋值。

1月15号下

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

下面关于c++中const和define的说法错误的是（B）

A、define宏在预处理阶段展开，const变量是编译运行阶段使用

B、在编译阶段会对define宏和const常量做类型安全检查

C、const可以节省空间，避免不必要的内存分配

D、define宏在定义的时候不会分配内存

解释：这个题目我做对了，记录一下

编译器不为const分配内存空间，而是直接保存在符号表中，没有了内存读取操作，效率就提高了。编译器会对const进行安全类型检查，define由于没有类型所以无法进行类型检查

2、题目2

关于C++中volatile说法正确的是

A、使用volatile修饰的变量，在使用的时候，每一次都是重新从内存中取值，而不是从寄存器中

B、使用volatile修饰的变量，不会被编译器优化

C、volatile变量，与非Volatile变量之间的操作，是不会被编译器交换顺序的

D、volatile变量间的操作，是不会被编译器交换顺序的

解释：这个题目我做对了

volatile三个特性：易变性；不可优化性；顺序性。

A易变性：不从寄存器读取，而直接读取内存

B不可优化性：告诉编译器不要对volatile变量进行优化

C，D都涉及顺序性，volatile只保证编译器不对volatile变量之间的顺序进行改变

3、题目3

考虑函数原型void test(int a,int b=7,char* p=”*”)下面的调用中，属于不合法调用的是（B）

A、test(6,'$')

B、test(5,"8")

C、test(0,0,0)

D、test(5)

解释：

A. test(6, '$')，char隐式转int赋值给形参b，形参p使用默认参数。

B. test(5, "8")，const char* 无法转int，报错。参数的赋值是按顺序来的，不可能"8"赋值给形参p，然后形参b使用默认参数。

C. test(0, 0, 0)，0赋值给指针，相当nullptr或NULL赋值给指针。

D. test(5)，形参b和形参p使用默认参数。

4、下面程序的结果是（正确答案D）

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

A、3

B、0

C、5

D、4

解释：这个题目我做对了，但是其实并没有理解题目

选D,这道题目考察的是操作符的优先级，因为逗号表达式的优先级最低，所有先计算赋值操作符，再计算逗号操作符，如果将a = c++, b++写成

a = （c++, b++），则答案选B

1月23号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

64位系统下有 `char ** p[4];` 请问 `sizeof p` 的值是多少? 答案C

A、8

B、16

C、32

D、64

解释:

p 是个数组，所以 sizeof(p) 返回数组的占用大小，64 位情况下

【char **p[4] 】表示【char** 数组】返回 4 * 8 = 32

【char *(*p)[4] 】表示【指向 char* 数组的指针】返回 8

【char (**p)[4] 】表示【指向 char 数组的指针的指针】返回 8

其中，【char **p[4] 】表示【char** 数组】这句话感觉又刷新了我的认知。让我对int *p[3]这个指针数组有了新的认识。之前都是叫这个数组叫指针数组。今天才发现原来是这样理解的。

int p[3]是一个数组，这个没有任何毛病。数组类型是int。
int* p[3]呢？其实这也是一个数组，知识类型是int*，数组名叫p。
而int (*p)[3]是个数组指针，这个p是个指针指向长度为3的int型数组，假设这个数组是int arra[3]，那么p就是指向这个数组的指针。

豁然开朗啊！牛！

2024年3月15日17:32:32更新，见链接突然思考数组-CSDN博客

2、题目2

9.以下代码是否完全正确，执行可能得到的结果是_答案C___。

class A{
   int i;
};
class B{
   A *p;
public:
   B(){p=new A;}
   ~B(){delete p;}
};
void sayHello(B b){
}
int main(){
   B b;
   sayHello(b);
}

A、程序正常运行

B、程序编译错误

C、程序崩溃

D、程序死循环

解释：这个题目还没有理解。

2024年3月15日17:38:47

嘿嘿，又看懂了，虽然是看了答案才懂了，但是毕竟也是懂了，看来是有进步啊啊！

1月24号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

7.下列程序的输出结果：答案C

#include <iostream>
using namespace std;
class A
{
public:
    void print()
    {
        cout << "A:print()";
    }
};
class B: private A
{
public:
    void print()
    {
        cout << "B:print()";
    }
};
class C: public B
{
public:
    void print()
    {
        A:: print();
    }
};
int main()
{
    C b;
    b.print();
}

A、A:print()

B、B:print()

C、编译出错

2024年3月15日17:52:02更新，这边有个问题，为什么不能按照作用域符全局访问类A的printf函数呢？

2、题目2

8、有一个类B继承自类A，他们数据成员如下：

class A {
...
private：
   int &a;
};
class B : public A {
...
private:
     int a;
public:
     const int b;
     A c;
     static const char* d;
     A* e;
};

则构造函数中，成员变量一定要通过初始化列表来初始化的是__答案A__。

A、b c

B、b c e

C、b c d e

D、c e

E、b d

F、b e

1月29号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？答案B

C c;
int main()
{
    A*pa=new A();
    B b;
    static D d;
    delete pa;
}

A、A B C D

B、A B D C

C、A C D B

D、A C B D

解释：关键是CD的顺序，一个是全局变量，一个是局部静态变量。都是静态存储区的数据。构造的规则是预先构造全局变量。这就意味着全局变量的构造函数是在main函数前调用，这也说明C++中第一个运行的函数并不是main函数。于是就出现了一个问题：哪一个全局变量的构造函数先调用？规则是在同一个文件中的全局变量，先定义的变量先构造，而不同文件中的全局变量构造的先后顺序并没有规定！！！如何才能保障不同文件中的全局变量构造函数的调用顺序呢？这时可以利用局部静态变量的特点！对于局部静态变量，标准规定，在函数首次调用的时候构造局部静态变量！通过控制函数调用的顺序来控制静态变量的构造顺序！静态区变量都是先构造的后析构，从而保证了变量间的依赖关系不出错！就本题而言，全局变量需要最先构造，静态变量在main函数内，所以在main运行前构造！

2、题目2

什么函数不能声明为虚函数？答案：ABC

A、静态成员函数

B、内联函数

C、构造函数

D、析构函数

解释：什么函数不能声明为虚函数-CSDN博客

3、当不同的类具有相同的间接基类时（答案B）？

A、各派生类无法按继承路线产生自己的基类版本

B、为了建立唯一的间接基类版本，应该声明间接基类为虚基类

C、为了建立唯一的间接基类版本，应该声明派生类虚继承基类

D、一旦声明虚继承，基类的性质就改变了，不能再定义新的派生类

解释：个人认为答案B优于答案C

理由如下:

在派生列表中，同一基类只能出现一次，但实际上派生类可以多次继承同一个类。派生类可以通过两个直接基类分别继承自同一间接基类，也可以直接继承某个基类，再通过另一个基类再次继承该类。但是，如果某个类派生过程中出现多次，则派生类中将包含该类的多个子对象，这种默认情况在很多有特殊要求的类中是行不通的。虚继承就是为了应对这一情况而产生，虚继承的目的是令某个类做出声明，承诺愿意共享其基类。这样不论虚基类在继承体系中出现多少次，派生类中都只包含唯一一个共享的虚基类子对象。

为了建立唯一的间接基类版本，就是要保证间接基类为虚基类，所以选项B对，而选项C说的很拗口，不知道具体怎么理解，像下面的情形，类B/类C虚继承类A,而派生类D,不需要虚继承就可以保证只有一份A，所以感觉选项C说的不太好。

2月18号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

计算机假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句最好为（正确答案C）

A、AB operator+(AB& A,AB& B)

B、AB &operator+(AB A)

C、AB operator+(AB &A)

D、AB *operator+(AB A)

解释：

运算符重载的格式：
返回值类型 operator 运算符名称 (形参表列){
//TODO:
}
由于题中说明是重载成员函数，所以该加号运算符重载函数要在 AB 类中，所以参数只需要一个，并且是 AB 引用类型，这样能够避免拷贝。
运算完后，要得到运算后的新数据，所以返回值也是 AB 类型。

2、题目2

所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。

A、T

B、F

解释：正确答案B，选错为A

友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend。

3、题目3

下面的语句，哪些是正确的，正确答案BC

class Base {
public:
    void f(){cout<<"Base::f()"<<endl;}
protected:
    Base(){cout<<"Base::Base"<<endl;}
private:
    void g() {cout<<"Base::g()"<<endl;}
}
 
class First: public Base{
public:
    First(){cout<<"First::First"<<endl;}
}

A、main() { Base a; }

B、main() { First a; }

C、main() { First a; a.f(); }

D、main() { First a; a.g(); }

解释：

A.构造函数权限为protected，在类外除了继承的方式，无法实例化对象。

B.First类是Base类的子类，可以进行实例化对象。

C.子类调用父类的公有成员函数，是符合语法的，正确

D.子类调用父类的私有成员函数，不符合语法，错误

2月18号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

今天做的题目全对，yes!

不过下面这个题目还是要记录一下

1、题目1

下面哪种情况下,B不能隐式转换为A? 正确答案B

A、class B:public A{}

B、class A:public B{}

C、class B{operator A();}

D、class A{A(const B&);}

解释：

考点：类之间的隐式转换与上下行转换

题目分析：

（A）A是基类，B是派生类，在公有继承方式下，派生类对象/对象指针、对象引用可以赋值给基类的对象/对象指针/对象引用（这时发生隐式转换）。因为派生类中包含了基类中的所有信息。注意：将派生类对象赋值给基类对象，会造成截切问题（派生类中专属的数据和行为会被丢弃掉）

（B）A是派生类，B是基类。基类对象对象指针、对象引用不能赋值给派生类的对象/ 对象指针、对象引用。原因同上。

（C） operator A()是B类中的一个类型转换函数，可以将B类对象隐式转换成B类对象。

（D）A(const B&)是A类的一个复制构造函数，可以将B类对象隐式转换成B类对象。

2月18号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

在C++中，以下定义数组的方式错误的是，答案D

A、int arr[2] = { 1, 2 };

B、int arr[]{ 1, 2 };

C、auto* arr = new int[2]{ 1, 2 };

D、int[] arr = { 1, 2 };

选错为B

2、题目2

关于迭代器失效，下面说法错误的有? 答案C

A、当向vector容器插入（push_back）一个元素后，end操作返回的迭代器肯定失效

B、当向vector容器插入(push_back)一个元素后，capacity返回值与没有插入元素之前相比有改变,此时first和end操作返回的迭代器都会失效

C、当vector容器erase一个元素后，仅指向删除点的迭代器失效

D、在deque容器的任何其他位置的插入和删除操作将使指向该容器元素的所有迭代器失效

E、对于节点式容器(map, list, set)元素的删除，插入操作会导致指向该元素的迭代器失效，其他元素迭代器不受影响

解释：

这个题目一直是懵逼的，平时迭代器讲实话实际用的比较少。贴了一个链接如下：

C/C++ - 迭代器失效_迭代器失效 erase(it++)-CSDN博客

3、题目3

以下程序在32位机器上运行输出是____，答案B

#include<iostream>
using namespace std;
class animal
{
protected:
    int age;
public:
    virtual void print_age(void) = 0;
};
class dog : public animal
{
public:
       dog() {this -> age = 2;}
       ~dog() { }
       virtual void print_age(void)
       {
           cout<<"Wang, my age = "<<this -> age<<endl;
       }
};
class cat: public animal
{
public:
    cat() {this -> age = 1;}     ~cat() { }
    virtual void print_age(void)
    {
        cout<<"Miao, my age = "<<this -> age<<endl;
    }
};
int main(void)
{
    cat kitty;
    dog jd;
    animal * pa;
    int * p = (int *)(&kitty);
    int * q = (int *)(&jd);
    p[0] = q[0];
    pa = &kitty;
    pa -> print_age();
    return 0; 
}

A、Wang, my age = 2

B、Wang, my age = 1

C、Miao, my age = 2

D、Miao, my age = 1

E、程序编译报错

F、程序运行报错

4、题目4

以下哪项描述是正确的，答案BD

A、父类的构造函数与析构函数不会自动被调用

B、成员变量需要用public protected private修饰，在定义变量时不再需要var关键字

C、父类中定义的静态成员，不可以在子类中直接调用

D、包含抽象方法的类必须为抽象类，抽象类不能被实例化

解释：选错为CD

A是错的，如果要使用父类的默认构造函数，会自动调用，只有在子类构造函数中需要用参数化列表方式将父类信息传递给父类构造函数时才会显式调用父类拷贝构造函数。析构函数是自动调用的，先调用子类析构，再调用父类析构

c++中父类的静态成员变量/函数在子类中的使用时，子类是可以共享父类中静态成员变量/函数的

当然有一个前提，父类中的静态成员函数/变量应该为公有的(pulic)，或当为private时，应提供公有的接口函数来调用

至于B为什么是对的，不知道，看评论说var是c#的，相当于auto

5、题目5

关于static用途说法正确的是？答案BCD

A、声明静态外部类

B、声明静态全局变量

C、声明静态函数

D、声明静态局部变量

解释，我选错为ABCD，

1：设置静态局部变量，变量只定义一次，不能被别的函数使用 2：设置静态全局变量，变量不能被外部文件所使用 3：在类中设置静态函数，只能访问静态变量

2月18号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

常对象只能调用它的常成员函数, 而不能调用普通的成员函数。

A、正确

B、错误

解释：正确答案A，选错为B。

可以理解为常对象和常函数的范围小。

（1）非常量对象调用非常量成员函数（正确）

（2）非常量对象调用常量成员函数（正确）

（3）常量对象调用常量成员函数（正确）

（4）常量对象调用非常量成员函数（错误）

2、题目2

友元运算符 a++ 被C++编译器解释为:

A、operator++(a)

B、a.operator++(0)

C、operator++(a,0)

D、a.operator++()

解释：正确答案C，选错为D

运算符重载的本质，就是函数重载，把operator++(或者++)当做一个函数名调用。

方式只有两种：1.写成类的成员函数，就是D选项

2.写成友元函数，就是C选项

某些运算符有限制，比如流运算符>> << 必须重载为友元函数

2月19号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

下面哪一个是无返回值的常成员函数声明（）？

A、void func() const;

B、const void func();

C、void const func();

D、void func(const);

解释：正确答案A

选错为B

const成员函数表示该成员函数只能读类数据成员，而不能修改类成员数据。定义const成员函数时，把const关键字放在函数的参数表和函数体之间。有人可能会问：为什么不将const放在函数声明前呢？因为这样做意味着函数的返回值是常量，意义完全不同。无返回值就返回值类型为void，故选A

2、题目2

下面代码可以打印多少

for (int i = 0; i < 2; i++)
{
    fork();
    printf("-\n");
}

A、4

B、5

C、6

D、8

正确答案：C

选错为A

参考答案：答案：C fork()函数是通过系统调用实现进程的拷贝。第一次for循环，执行完fork函数之后，系统中有两个一模一样的进程，并且都执行到printf函数处，这一次循环会打印出两个“ - ”符号第二次进入for循环，经过fork函数，第一次循环中产生的两个进程分别再次分裂，这时会有4个进程打印 “-”符号，所以最终结果是6个。

3、题目3

代码可以通过编译吗？如果不能应该如何修改？

template<class T> class Foo{
        T tVar;
    public:
        Foo(T t) : tVar(t) { }
};
 
template<class T> class FooDerived:public Foo<T>
{
};
 
int main()
{
    FooDerived<int> d(5);
    return 0;
}

A、代码可以正确通过编译。

B、编译错误，FooDerived是一个继承模板类的非模板类，它的类型不能改变。

C、编译错误，tVal变量是一个不确定的类型。

D、编译错误，可以在FooDerived类中添加一个构造函数解决问题。

正确答案：D

选错为B

参考答案：当基类构造函数需要外部传递参数才能进行初始化时，派生类必须显式定义构造函数，为基类传递参数；基类如果不需要传递或者可以不传递参数，派生类可以不用显式定义构造函数。

2月19号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

如果定义如下类：

class Empty{}

请选择编译器为之生成的函数有哪些？（）

1.Empty() { … }

2.Empty(const Empty& rhs){ … }

3.Empty& operator=(const Empty& rhs) { … }

4.~Empty() { … }

A、124

B、1234

C、123

D、14

解释：正确答案B

选错为D

c++编译器至少给一个类添加4个函数

1. 默认构造函数(无参，函数体为空)

2. 默认析构函数(无参，函数体为空)

3. 默认拷贝构造函数，对属性进行值拷贝

4. 赋值运算符 operator=, 对属性进行值拷贝

2月20号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

下列关于数组与指针的区别描述正确的是？

A、数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。

B、用运算符sizeof 可以计算出数组的容量（字节数）

C、指针可以随时指向任意类型的内存块。

D、用运算符sizeof 可以计算出指针所指向内容的容量（字节数）

解释：正确答案B

A:动态数据

C:const指针不能随意指向任意类型的内存块

D:sizeof(指针)结果为指针大小

2、题目2

下列关于数组的描述，错误的是（）

A、C++中数组的存储方式为列优先存储

B、数组名可以作为实参赋值给指针类型的形参

C、数组下标索引从1开始，至数组长度n结束

D、数组指针的语法形式：类型名 *数组名[下标表达式]

解释：正确答案ACD

选错为CD

二维数组是按行优先存储的
也就是说，在内存中存储一个二维数组时，先把数组中第一行的元素存完，再接着存下一行的元素，直到存完为止。

2月20号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

今天10道题又是全对！棒

2月21号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

类方法中可以直接调用对象变量？

A、正确

B、错误

解释：正确答案B

静态方法中不能调用对象的变量，因为静态方法在类加载时就初始化，对象变量需要在新建对象后才能使用

2、题目2

类B是类A的公有派生类，类A和类B中都定义了虚函数func(),p是一个指向类A对象的指针，则p->A::func()将（）？

A、调用类B中函数func()

B、即调用类A中函数，也调用类B中的函数

C、调用类A中函数func()

D、根据p所指的对象类型而确定调用类A中或类B中的函数func()

解释：正确答案C

选错为CD

至于为什么不选D，看了解释，这里使用了A::域限制符，规定了调用限制。即使B类型的指针指向B对象，使用了域限制符A::，也会调用父类A的fun方法

3、题目3

（C++）设 A 为基类，AX 为派生类，有以下代码，下面选项不会出现内存泄漏的是？

class A {
public:
  A();
  ~A();
 
  Data* data;
};
 
class AX : public A {
public:
  AX();
  ~AX();
 
  AXData* ax_data;
};

A、AX* p = new AX(); delete p;

B、A* p = new AX(); delete p;

C、std::shared_ptr<AX> p{new AX()};

D、std::shared_ptr<A> p{new AX()};

解释：正确答案ACD

选错为BD

这个题目我是意识到派生类的析构函数不是虚函数，但是这只是第一步，后面的我没有做对。甚至是一团浆糊。做了和这个题目我才又理解，类的析构函数的用法。

所以AC都是对的。对于B选项，基类指向派生类对象。派生类对象析构函数是虚函数就可以实现派生类析构。

D选型是看的别人的解释，对于D选项，在万能的知乎中找到了解释，简单地说，“智能指针解引用时的指针” 和“所有共享所有权的智能指针共同管理的对象”未必是相同的类型；在引用计数为0时销毁所管理的对象会调用当初赋值时的对象类型；

2月22号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

有如下类模板定义：（）

template<class　T> class　BigNumber{ 
    long　n; 
public: 
    BigNumber(T i):n(i){}
    BigNumber　operator+(BigNumber　b)
    { 
        return　BigNumber(n+b.n); 
    } 
};

已知b1,b2是BigNumber的两个对象,则下列表达式中错误的是?

A、3+3

B、b1+3

C、b1+b2

D、3+b1

解释：正确答案D

选错为B

此题考查的正是C++的运算符重载，+号被重载后相当于该类的一个成员函数了，出现该类对象(b1+)这种就是调用重载函数，+号后面的3或者b2就是参数，如果是3的话就会执行类型转化，将3变为BigNumber类型传给形参。至于D选项的错误我个人理解为+号左右两边的类型不匹配。
重载运算符第一项必须是当前的类对象，这是限定死的，除非就是不重载，就像A中，常数相加

2、题目2

C++当中，以下关于抽象类的说法正确的有( )

A、抽象类只能用作其他类的基类

B、不能使用抽象类定义对象

C、抽象类不能用作参数类型、函数返回类型或显式转换的类型

D、抽象类不能有构造函数和析构函数

解释：正确答案ABC

选错为ABCD

抽象类的定义

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”，有虚函数的类就叫做抽象类。

抽象类有以下几个特点：

（1）抽象类只能用作其他类的基类，不能建立抽象类对象。

（2）抽象类不能用作参数类型、函数返回类型或显式转换的类型。

（3）可以定义指向抽象类的指针和引用，此指针可以指向它的派生类，进而实现多态性。

上面的解释其中有这样一句

可以定义指向抽象类的指针和引用，此指针可以指向它的派生类，进而实现多态性。

由此有引出下面的一题，虽然这题我做对了，但是还是记录一下

3、题目3

若有语句定义rectangle r; r.setLength(3,5); 则编译时无语法错误的语句是（）

#include <iostream>
using namespace std;
 
class shape {
public:
    virtual int area() = 0;
};
 
class rectangle :public shape {
public:
    int a, b;
    void setLength(int x, int y) { 
        a = x; b = y;
    }
    int area() { 
        return a * b; 
    }
};

A、shape *s1=&r;

B、shape &s2=r;

C、shape s3=r;

D、shape s4[3];

解释：正确答案AB，做对的

主要是在B答案犹豫了。

2月22号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

这次的题目里面好多运算符重载的题目啊！

1、题目1

请问实际运行结果是哪个？（）

#include<iostream>
 
class Base
{
public:
Base(const char* p_szName):m_szName(p_szName) {std::cout << m_szName << ",";}
virtual ~Base() { std::cout <<"~"<<m_szName << ", ";}
private:
const char* m_szName;
};
 
class Derived : public Base
{
public:
    Derived(const char*p_szName): m_szName(p_szName)
    ,m_objA((const char*)"A")
    ,m_objB((const char*)"B")
    ,Base((const char*)"C")
    {
        std::cout << m_szName << ",";
    }
    virtual ~Derived()
    {
        std::cout <<"~"<<m_szName << ",";
    }
private:
const char* m_szName;
Base m_objB;
Base m_objA;
};
int main()
{
    Base* p = new Derived("D");
    delete p;
    return 0;
}

A、B,A,C,D,~D,~C,~A,~B

B、 C,B,A,D,~D,~A,~B,~C

C、 C,A,B,D,~D,~B,~A,~C

D、 A,B,C,D,~D,~C,~B,~A

解释：正确答案B

两个考点：

1.构造函数的调用顺序是：基类》对象》派生类，析构顺序相反；

2.构造函数里初始化列表初始化顺序由成员变量的声明顺序决定。

2024年3月19日15:55:08更新

今天看题目的时候还在纳闷这一行，

Derived(const char*p_szName): m_szName(p_szName)

我在想这边怎么把基类的m_szName赋值成了"D"了，那析构的时候不就是打"D"了吗？

然后仔细想了下，m_szName(p_szName)是把派生类的成员m_szName赋值，跟基类没关系。

2月23号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

C ++处理异常的机制是由（）三部分组成？

A、编辑、编译和运行

B、检查、抛出和捕获

C、编辑、编译和捕获

D、检查、抛出和运行

解释：正确答案B

选错为A

C++处理异常的机制是由（try检查、throw抛出、catch捕获）三部分组成。

2、题目2

如果已定义了一个C++类CMyList并有以下语句：CMyList list(3);

以下说法正确的是_______。

A、该语句会创建一个CMyList类的3个对象；

B、必须为类CMyList定义一个构造函数；

C、必须为类CMyList定义一个析构函数；

D、必须定义函数CMyList list(int)；

解释：正确答案B

选错为D

语句 CMyList list(3); 表示创建一个 CMyList 对象，对象名为 list，使用的是某个带参数的构造函数，参数类型必须是能够接收参数3。例如：
CMyList list(int);
CMyList list(double);

D不是必须要定义函数CMyList list(int)；也可以定义函数CMyList list(float)之类的能隐式转换的函数

2024年3月19日16:02:32 完善一下答案

必须要定义一个有参构造，但是非必须是参数（int），可以是参数给默认值（int a=1,int b=2）; 如果不定义构造函数，使用默认构造函数的话，会无法匹配。

3、题目3

有以下类定义，请为横线处选择合适的程序将派生类C的构造函数补充完整。

using namespace std;
class B1{
    int b1;
public:
    B1(int i){
        b1=i; cout<<b1; }
    ~B1( ){ cout<<"#1"; }
};
class B2 {
    int b2;
public:
    B2( ){b2=0; cout<<"*2"; }
    ~B2( ){ cout<<"#2"; }
};
class C: virtual public B1,public B2 {
    int j;
public:
    C(int a,int b,int c):B1(a),_______ ,j(c){cout<<"*3";}
    ~C( ){ cout<<"#3"; }
private:
    B1 c1;
    B2 c2;
};

A、B1(b)

B、c1(b)

C、c2(b)

D、B2(b)

解释：正确答案B

选错为D

2024年3月19日17:27:17更新

这边有个新的知识点，就是封闭类。即类里面有成员对象就要封闭类。至于封闭类构造函数调用顺序参考了这篇文章：面向对象（C++）之封闭类 - 简书

其中的例子也没有太明白为什么Engine构造函数先执行

#include<iostream>

using std::cout;

using std::cin;

using std::endl;

class CTyre{

  private:

    int radius;

    int width;

  public:

    CTyre(int r,int w):radius(r),width(w){};

    CTyre(){ cout<<"CTyre contructor"<<endl;}

    ~CTyre(){ cout<<"CTyre destructor"<<endl;};
};



class CEngine{

  public:

    CEngine(){ cout<<"CEngine contructor"<<endl;}

    ~CEngine(){ cout<<"CEngine destructor"<<endl;}

};

class CCar{

  // 这个类就是所谓的封闭类
  //其中包括成员对象CEngine和CTyre

  private:

    int price;

    CTyre tyre;

    CEngine engine;

  public:

    CCar(int p, int tr,int tw );

};

CCar::CCar(int p, int tr,int tw ):price(p),tyre(tr,tw)
{
    cout<<"CCar contructor"<<endl;
};

int main(){

  int p,tr,tw;

  cout<<"请输入汽车的价格:"<<endl;

  cin>>p;

  cout<<"请输入汽车轮胎的半径："<<endl;

  cin>>tr;

  cout<<"请输入汽车轮胎的厚度："<<endl;

  cin>>tw;

  CCar(p,tr,tw);

  return 0;

}

//CEngine contructor
//CCar contructor
//CEngine destructor
//CTyre destructor

自己修改了本题的例子，打印信息如下：

#include <iostream>

using namespace std;
class B1{
    int b1;
public:
    B1(int i)
    {
        b1=i; cout<<b1;
        cout << "B1 construct" << endl;
    }
    ~B1( ){ cout<<"#1"; }
};
class B2 {
    int b2;
public:
    B2( )
    {
        b2=0; cout<<"*2";
        cout << "B2 construct" << endl;
    }
    ~B2( ){ cout<<"#2"; }
};
class C: virtual public B2,public B1 {
    int j;
public:
    C(int a,int b,int c):B1(a),c1(b) ,j(c){cout<<"*3";}
    ~C( ){ cout<<"#3"; }
private:
    B1 c1;
    //B2 c2;
};

int main()
{
    C c(15,16,17);
    return 0;
}

//虚继承只有一个父类，看打印信息应该是走的B2。然后根据参数列表实例化。
//第一个*2B2 construct是C派生类的父类实例化。第二个*2B2 construct是成员对象实例化。可以注释B2 c2;验证
//*2B2 construct
//15B1 construct
//16B1 construct
//*2B2 construct
//*3#3#2#1#1#2

4、题目4

引用与指针有什么区别？

A、指针是一个实体，而引用仅是个别名

B、指针没有 const，引用有 const；

C、引用不能为空，指针可以为空；

D、“sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小；

E、从内存分配上看：程序为引用变量分配内存区域，而指针不需要分配内存区域

F、指针和引用的自增(++)运算，意义一样

解释：正确答案ACD

选错为ACE

对于B，我百度一下，引用是否可以用const。

C++【const 引用】详解-CSDN博客

这个帖子写的可以。

5、题目5

【多选】以下哪些做法是不正确或者应该极力避免的：（）

A、构造函数声明为虚函数

B、派生关系中的基类析构函数声明为虚函数

C、构造函数中调用虚函数

D、析构函数中调用虚函数

解释：正确答案ACD，做对的

所谓虚函数就是多态情况下只执行一个,而从继承的概念来讲,总是要先构造父类对象,然后才能是子类对象,如果构造函数设为虚函数,那么当你在构造父类的构造函数时就不得不显示的调用构造,还有一个原因就是为了防错,试想如果你在子类中一不小心重写了个跟父类构造函数一样的函数,那么你的父类的构造函数将被覆盖,也即不能完成父类的构造.就会出错.

在构造函数不要调用虚函数。在基类构造的时候，虚函数是非虚，不会走到派生类中，既是采用的静态绑定。显然的是：当我们构造一个子类的对象时，先调用基类的构造函数，构造子类中基类部分，子类还没有构造，还没有初始化，

如果在基类的构造中调用虚函数，如果可以的话就是调用一个还没有被初始化的对象，那是很危险的，所以C++中是不可以在构造父类对象部分的时候调用子类的虚函数实现。但是不是说你不可以那么写程序，你这么写，编译器也不会报错。只是你如果这么写的话编译器不会给你调用子类的实现，而是还是调用基类的实现。

在析构函数中也不要调用虚函数。在析构的时候会首先调用子类的析构函数，析构掉对象中的子类部分，然后在调用基类的析构函数析构基类部分，如果在基类的析构函数里面调用虚函数，会导致其调用已经析构了的子类对象里面的函数，这是非常危险的。

6、题目6

关于static变量，请选择下面所有说法正确的内容。

A、若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度

B、若全局变量仅由单个函数访问，则可以将这个变量改为该函数内的静态局部变量，以降低模块间的耦合度

C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题

D、静态全局变量过大时，可能会导致堆栈溢出

解释：正确答案ABC

选错为ABCD

对于D：静态变量放在程序的全局数据区，而不是在堆栈中分配，所以不可能导致堆栈溢出，D是错误的

（转）重入和不可重入

这种情况出现在多任务系统当中，在任务执行期间捕捉到信号并对其进行处理时，进程正在执行的指令序列就被信号处理程序临时中断。如果从信号处理程序返回，则继续执行进程断点处的正常指令序列，从重新恢复到断点重新执行的过程中，函数所依赖的环境没有发生改变，就说这个函数是可重入的，反之就是不可重入的。

满足下面条件之一的多数是不可重入函数：
(1)使用了静态数据结构;
(2)调用了malloc或free;
(3)调用了标准I/O函数;标准io库很多实现都以不可重入的方式使用全局数据结构。
(4)进行了浮点运算.许多的处理器/编译器中，浮点一般都是不可重入的 (浮点运算大多使用协处理器或者软件模拟来实现。

7、题目7

关于虚函数的说法,哪些是正确的

A、构造函数中调用该类的虚函数，动态绑定机制会生效

B、静态函数不可以是虚函数

C、虚函数可以声明为inline

D、构造函数和析构函数都可以声明为虚函数

解释：正确答案BC

虚函数用于实现运行时的多态，或者称为晚绑定或动态绑定。而内联函数用于提高效率。内联函数的原理是，在编译期间，对调用内联函数的地方的代码替换成函数代码。内联函数对于程序中需要频繁使用和调用的小函数非常有用。默认地，类中定义的所有函数，除了虚函数之外，会隐式地或自动地当成内联函数(注意：内联只是对于编译器的一个请求，编译器可以自己决定是否进行内联). 无论何时，使用基类指针或引用来调用虚函数，它都不能为内联函数(因为调用发生在运行时)。但是，无论何时，使用类的对象(不是指针或引用)来调用时，可以当做是内联，因为编译器在编译时确切知道对象是哪个类的所以c是对的静态函数不属于对象，只属于类，所以b也是对的

2月23号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

如下程序的输出为？

#include <stdio.h>
class A
{
public:
    A()
    {
        printf("1");
    }
    A(A &a)
    {
        printf("2");
    }
    A &operator=(const A &a)
    {
        printf("3");
        return *this;
    }
};
int main()
{
    A a;
    A b = a;
}

A、12

B、13

C、无法确定

D、编译出错

正确答案A

选错为B

A b = a;是定义了b，并对b进行初始化，是调用构造函数。所以调用A(A &a)；

如果写成A b; b = a;那打印结果是113。

2、题目2

以下对于方法覆盖的说法正确的有（）

A、方法覆盖发生在同一类中

B、方法的覆盖发生在子类型中

C、方法名一定要一样

D、参数类型一定要一样

E、返回类型一定要一样

F、访问权限只能一样

解释：BCD

A 重载是发生在一个类中而方法重写（覆盖）是发生在父子类之间

E 子类返回类型小于等于父类

F 子类的访问权限应该大于等于父类的访问权限

总结起来，方法重写遵循“两小两同一大”原则

1.“两小” ：子类方法的返回值类型、抛出的异常均应小于等于父类方法的

2.“两同”：子类方法的方法名、参数列表均应该与父类方法相同

3.“一大”：子类方法的访问权限应该大于等于父类方法的访问权限

2024年3月19日19:18:49更新

重载Overloading	重写/覆盖Override	隐藏Overwrite
同一个类	父子类关系	父子类关系
函数名相同	函数名相同；加virtual实现	函数名相同
参数列表一定不同；	参数列表一定相同	参数列表无要求
返回类型可以不同，协变	返回类型必须相同或者为其子类	返回值无要求
访问修饰符可以不同	访问修饰符范围必须大于等于父类；如果父类方法访问修饰符为private，则子类不能重写该方法。	无要求

3、题目3

以下输出正确的是

#include <iostream>
using namespace std;
 
class Base {
public:
    void virtual Func() {
        cout << "Base" << endl;
    }
};
 
class Derived : public Base {
public:
    void virtual Func() {
        cout << "Derived " << endl;
    }
};
 
int main() {
    Base* pBase = new Base();
    pBase->Func();
    Derived* pDerived = (Derived*)pBase;
    pDerived->Func();
    delete pBase;
 
    pDerived = new Derived();
    pBase = pDerived;
    pBase->Func();
 
    delete pDerived;
    return 0;
}

A、Base Derived Base

B、Base Base Derived

C、Base Derived Derived

D、Derived Base Derived

解释：正确答案B。做对了。

由于 func 是一个虚函数，所以将指针赋值给基类或者派生类对象不会对虚函数调用造成影响。pBase 是一个 Base 对象，前两次 func 会调用 Base 对应的 func 函数，输出两次 Base。而 pDerived 是一个Derived 对象，因此是输出 Derived。B 选项正确。

3月13号

牛客网公司真题_免费模拟题库_企业面试|笔试真题

1、题目1

（C++部分）下列关于对象初始化的叙述中，正确的是:

A、定义对象的时候不能对对象进行初始化

B、定义对象之后可以显式地调用构造函数进行初始化

C、定义对象时将自动调用构造函数进行初始化

D、在一个类中必须显式地定义构造函数实现初始化

正确答案C，选错为B

解释：

对于B选项：定义对象之后不能调用构造函数，因为构造函数是用来初始化的。

对于C选项：每个类必须有构造函数。可以自己实现构造函数。如果没有默认构造函数，系统会默认加上一个无参构造函数。

2、题目2

要求打开文件D:\file.dat，并能够写入数据，正确的语句是（）？

A、ifstream infile("D:\\file.dat", ios::in );

B、ifstream infile("D:\\file.dat", ios::out );

C、ofstream outfile("D:\\file.dat", ios::in );

D、fstream infile("D:\\file.dat", ios::in|ios::out );

正确答案D，做对了。

评论有人说C也对，并且写了demo，我照着写了一遍，一开始还没写对

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <fstream>

using namespace std;

int main()
{
    ifstream in;
    ofstream out;
    char c;
    out.open("D:\\APP\\codeBlock\\testDel2\\test.txt", ios::in);
    out << "this is test string";
    out.close();
    in.open("D:\\APP\\codeBlock\\testDel2\\test.txt", ios::out);
    while(in.get(c))
    {
        printf("%c",c);
    }

    return 0;
}

需要注意一下几点：

1、需要创建test.txt文件

2、windows下路径要写''\\''或者''/''

3、codeblock需要加头文件<fstream>,vs需要加<sstream>

4、out需要close()

详细参考文档：文件操作方式-CSDN博客文章浏览阅读275次。例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。https://blog.csdn.net/2301_77560238/article/details/132624385

3、题目3

C++语言中，下面描述中，正确的是()

A、一个基类的声明中有纯虚函数，该基类派生类一定不再是抽象类

B、函数返回值类型不能作为重载函数的调用的依据

C、静态数据成员不是所有对象所公有的

D、内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方

解释：正确答案B，做对了。关于D选项，内联函数是在函数编译时插入调用的地方。

4、题目4

下列等式正确的是（）？

class Af{virtual ~A(){}};
class Bf{virtual ~B(){}};
class C:public A,public B{
};
C* pC = new C();
A*pA=(A*)pC;
B*pB=(B*)pC;

A、pA==pC&&pB!=pC

B、pA==pC&&pB==pC

C、pA!=pC&&pB!=pC

D、pA!=pC&&pB==pC

正确答案A,选错为B

4、题目4

用C++语言编写的源程序要成为目标程序必须要经过（ BD ）？

A、解释

B、汇编

C、编辑

D、编译

解释：预处理-编译-汇编-链接

5、题目5

下列哪段代码是实现在一个vector中查找匹配值value并删除：

A、for (std::vector::iterator iter = numbers.begin(); iter != numbers.end(); ++iter) { if (*iter == value) { numbers.erase(iter); } }

B、for (std::vector::iterator iter = numbers.begin(); iter != numbers.end(); ++iter) { if (*iter == value) { numbers.erase(iter); iter--; } }

C、for (std::vector::iterator iter = numbers.begin(); iter != numbers.end();) { if (*iter == value) { iter = numbers.erase(iter); } else { ++iter; } }

D、以上代码都不对

解释：正确答案BC，选错为AB

erase（）函数的特点就是删除当前的元素，并自动指向下一个元素，所以这里iter不需要在自增了。

有评论说B选项不对：

可以清楚的看到, erase 容器内的元素之后,所有在 erase 元素之后的迭代器失效.在 erase 之后,继续遍历的话,那么在下一次遍历的时候,必须使用 erase 所返回的迭代器.

这道题的B选项是错误的，运行之后会提示“引发了异常: 读取访问权限冲突。**_Mycont** 是 nullptr。“这个错误并且程序崩溃，运行环境：visualstudio2022版，编译器默认配置。

6、题目6

以下叙述中正确的是( )

A、在C++中数据封装是通过各种类型来实现的

B、在C++中，数据封装可以由struct关键字提供

C、数据封装就是使用结构类型将数据代码连接在一起

D、数据封装以后，仍然可以不通过使用函数就能直接存取数据

解释：正确答案BD，选错ABC

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

晴山ぺ

关注

15
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
C++牛客知识点3

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
复制链接

扫一扫

专栏目录