2021腾讯实习一面复盘-小丑竟是我自己

唔仄lo咚锵

发布于 2022-05-10 10:19:07

5550

发布于 2022-05-10 10:19:07

文章被收录于专栏：blog(为什么会重名，真的醉了)blog(为什么会重名，真的醉了)

文章目录

每个岗位和事业群要求肯定不同，题目和答案仅供参考。

开场

自我介绍

主观题

比赛用C++，为何走Java?

主观题

C/C++和Java有什么区别

都是面向对象的语言，都支持继承、封装和多态。
Java不提供指针来直接访问内存，程序内存更安全。
Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是可以实现多个接口。
Java有自动内存管理机制，不需要程序员手动释放无用内存。
C语言中，字符串或字符数组最后有一个额外的字符’\0’表示结束，Java中无结束符这一概念。

手撕算法

连续子数组最大和

可参考：数组面试题-大力出奇迹？

合并两个排序链表

可参考：链表面试题(动图详解)-明明做出来了却为什么没有Offer?

C/C++

sizeof

    double* (*a)[3][6];
    cout << sizeof(a) << endl; // 4 a为指针（64位是8）
    cout << sizeof(*a) << endl; // 72 *a为一个有3*6个指针元素的数组（64位是144）
    cout << sizeof(**a) << endl; // 24 **a为数组一维的6个指针（64位是48）
    cout << sizeof(***a) << endl; // 4 ***a为一维的第一个指针（64位是8）
    cout << sizeof(****a) << endl; // 8 ****a为一个double变量

union和struct的区别

Union 整体空间是占用空间最大的成员（的类型）所占字节数的整倍数。 union的成员共享内存空间，修改某成员值会影响其他成员。
Struct 数据对齐原则：内存按结构成员的先后顺序排列，当排到该成员变量时，其前面已摆放的空间大小必须是该成员类型大小的整倍数，如果不够则补齐，以此向后类推。各成员间互不影响。

#include<bits/stdc++.h>
using namespace std;
struct a {
    char x;//sizeof(char)=1
    int y;//sizeof(int)=4
    double z;//sizeof(double)=8
};
union b {
    char x;//sizeof(char)=1
    int y;//sizeof(int)=4
    double z;//sizeof(double)=8
};
int main() {
    struct a t1;
    union b t2;
    cout << sizeof(t1) << endl;//1+4+8+补齐3
    cout << sizeof(t2) << endl;//max(1,4,8)
    t1.x = 'a';
    t2.x = 'a';
    cout << t1.x << " " << t2.x << endl;//a a
    t1.y = 1;
    t2.y = 1;
    cout << t1.x << " " << t2.x << endl;//a 乱码
    cout << t1.y << " " << t2.y << endl;//1 1
    return 0;
}

指针和数组的区别

指针	数组
相当于一个变量，存放的是其它变量在内存中的地址	储存多个相同类型数据的集合
同类型指针可相互赋值	数组只能一个个拷贝元素
存储很灵活，可指向任意类型的数据	存在一块连续的物理空间上，逻辑上的多维数组其实存的是一维
sizeof在32位下是4，64位下是8	sizeof是数组所占存储空间大小，但是传参时会退化为指针，此时sizeof即指针大小

#include<bits/stdc++.h>
using namespace std;
void test1(double* c) {
    cout << sizeof(c) << endl;//4
    c[0] = 1.0;
}
void test2(double c[]) {
    cout << sizeof(c) << endl;//4
    c[0] = 2.0;
}
int main() {
    int* a[10];//指针数组：存着10个int*类型指针的数组
    int(*b)[10];//数组指针：即一个指针，指向了一个int[10]的数组
    //换言之 []优先级大于*
    cout << sizeof(a) << endl;//40，10×4(32位指针大小)
    cout << sizeof(b) << endl;//4，即一个指针大小(64位是8)
    cout << sizeof(*a) << endl;//4，数组首指针
    cout << sizeof(*b) << endl;//40，所指数组大小10×4(32位int大小)
    //传参时退化成了指针，是引用传递
    double c[10] = { 0 };
    cout << sizeof(c) << endl;
    cout << c[0] << endl;//0
    test1(c);
    cout << c[0] << endl;//1
    test2(c);
    cout << c[0] << endl;//2
    return 0;
}

多态

多态是同一个行为具有多个不同表现形式或形态的能力。比如重写父类方法、重载同一方法等。

C/C++构成多态条件：

调用函数的对象必须是指针或者引用。
被调用的函数必须是虚函数，且完成了虚函数的重写。

#include<bits/stdc++.h>
using namespace std;
class A{ //父类
public:
    virtual void test(){
        cout << "A" << endl;
    }
};
class B : public A{  //子类
public:
    virtual void test(){
        cout << "B" << endl;
    }
};
void fun(A& obj){
    obj.test();
}
int main(){
    A a;
    B b;
    fun(a);//A
    fun(b);//B
    return 0;
}

被调用的函数必须是虚函数，也就是说必须要在两个产生多态的函数前面加virtual关键字。

调用函数的形参对象必须是基类对象，因为派生类能给基类赋值，基类不能给派生类赋值。

调用函数的参数必须是指针或引用，因为派生类改变了虚表，那么这个虚表就属于派生类对象，赋值时只会把基类的成员给过去，虚表指针不会给。

即在调用函数的时候检查，如果满足多态的条件，则触发寻找虚表中虚函数地址。否则会直接用基类对象调用基类函数。

（~~插播反爬信息~~ ）博主CSDN地址：https://wzlodq.blog.csdn.net/

虚函数

虚函数即在类的成员函数前面加virtual关键字。若派生类中有一个跟基类的完全相同虚函数（函数名、参数、返回值相同），我们就称子类的虚函数重写了基类的虚函数。

协变：重写虚函数的返回值可以不同，但是必须分别是基类指针或引用和派生类指针或引用。（VS会报错，linux的G++不会）

class A{ 
public:                                                                  
    virtual A* fun(){
        return new A;                                                    
    }
};
class B : public A{
public:
    virtual B* fun(){
        return new B;
    }
};

纯虚函数：在虚函数的后面写加上’=0’，则这个函数就变成纯虚函数，包含纯虚函数的类叫做抽象类（或接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

class A{
public:
    virtual void test() = 0;
};
class B : public A{
public:
    virtual void Strength(){
        cout << "一键三连" << endl;
    }
};

static关键字

static静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为0，使用时可以改变其值。

修饰局部变量：变量在程序初始化时被分配，直到程序退出前才被释放，也就是static是按照程序的生命周期来分配释放变量的，而不是变量自己的生命周期。多次调用也只需一次初始化。
修饰全局变量：可在不同的cpp文件中定义同名变量，避免命名冲突（隐藏)，保持变量内容的持久。
类的数据成员：必须在class的外部初始化。
类的函数：不需要类的实例即可调用（注意public和private权限）。属于整个类而非类的对象实例，所以没有this指针。静态成员之间可以相互访问。
单例模式中使用，保证一个类在内存中仅有一个实例，并提供一个访问它的全局访问点。