C++公司真题

最新推荐文章于 2024-07-18 23:31:00 发布
最新推荐文章于 2024-07-18 23:31:00 发布
阅读量465 收藏 3
点赞数 1
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30347421/article/details/105693407
版权

C++公司真题

趋势科技

在这里插入图片描述
abort()函数用于不正常地终止一个正在执行的程序。
exit()函数用于正常终止程序。
atexit()函数可以把一些函数注册为退出函数（exit function）。
return 0; 一般0代表的是正常结束
return -1; -1代表非正常结束
return ; void 返回是空，void返回值可以什么也不写，可以写return；
return NULL; 如果数据类型是指针类型，那我们一般成功的时候返回相应的地址，失败的时候返回NULL
在这里插入图片描述
答案：是x|y, |是按位或的操作运算，1010 | 0101 =1111=15，加上1，就为16
在这里插入图片描述
答案：True封装
在这里插入图片描述
答案： 计算机程序设计中的分叉函数。返回值： 若成功调用一次则返回两个值，子进程返回0，父进程返回子进程标记；否则，出错返回-1。
fork函数将运行着的程序分成2个（几乎）完全一样的进程，每个进程都启动一个从代码的同一位置开始执行的线程。这两个进程中的线程继续执行，就像是两个用户同时启动了该应用程序的两个副本。

第一次第一个cout输出一个"-"。
然后fork函数将运行的程序分成两个（几乎）完全一样的进程。
第一次第二个cout输出两个“-”。
第二次第一个cou还是输出两个“-”。
然后fork函数将运行的两个程序分成四个（几乎）完全一样的进程。
第二次第二个cou输出四个“-”。
所以总共输出的“-”个数为count=1+2+2+4=9
在这里插入图片描述
答案：A 2
B 4
C 7
D 2
E 21
F 8
细心
在这里插入图片描述
这个题目出的好！
本题考察两个知识点：
一、赋值兼容：
1.子类对象可以赋值给父类对象
2.子类对象可以初始化父类对象
3.父类指针可以指向子类对象
4.父类引用可以引用子类对象
二、子类重写父类

这两个知识点也就是解释多态的关键

本题中，根据兼容性原则：当父类指针（引用）指向子类对象时，子类对象退化成父类对象，只能访问父类中定义的成员
如果B对象没有virtual修饰的话，B* pb = ⅆ dd就会退化为父类对象，pd就只能访问父类的成员B::Fun()。
但是又virtual修饰的话，就会展现多态行为，会根据实际指针指向的对象判断函数的调用。pb 和pd都指向子类对象，所以调用D::Fun()。
在这里插入图片描述
class Empty
{
public:
Empty(); //缺省构造函数
Empty(const Empty &rhs); //拷贝构造函数
~Empty(); //析构函数
Empty& operator=(const Empty &rhs); //赋值运算符
Empty* operator&(); //取址运算符
const Empty* operator&() const; //取址运算符(const版本)
};
在这里插入图片描述
1、两个或多个枚举常量可以具有相同的值；
2、当没有为枚举常量指定值时，它的值比前一个常量的值大1（第一个枚举常量的值默认为0）；
3、枚举常量遵循C语言的作用域规则。
在这里插入图片描述
a=-1,表达式的值为-1，非零，为真，故b=2;
a=0,表达式的值为，为零，为假，故c=3;

腾讯

在这里插入图片描述
1、int (p)[4]：表示行指针，单位移动量为4个int类型。即p+1，则一次移动4个int类型
2、(int ()[4])m：表示以数组指针类型组织m，每4个为一个数组
3、这样一来，m为｛｛1，2，3，4｝，｛5，6，7，8｝，｛9，0， ， ｝｝，p指向第一行
4、故p[1][2]即*（（p+1）+2），表示第二行第三个元素，为7
C语言中 intp[4] 和 int（*p）[4]的区别：
int *p[4]; //定义一个指针数组，该数组中每个元素是一个指针，每个指针指向哪里就需要程序中后续再定义了。
int (*p)[4]; //定义一个数组指针，该指针指向含4个元素的一维数组（数组中每个元素是int型）。

区分int p[n]; 和int (p)[n]; 就要看运算符的优先级了。
int p[n]; 中，运算符[ ]优先级高，先与p结合成为一个数组，再由int说明这是一个整型指针数组。
int (p)[n]; 中( )优先级高，首先说明p是一个指针，指向一个整型的一维数组。
1、int (p)[4]：定义一个数组指针，该指针指向含4个元素的一维数组（数组中每个元素是int型）； 2、(int ()[4])m：表示将m强制转换为大小为4的数组指针；
在这里插入图片描述
64位操作系统
char ：1个字节(固定)
(即指针变量): 8个字节
short int : 2个字节(固定)
int： 4个字节(固定)
unsigned int : 4个字节(固定)
float: 4个字节(固定)
double: 8个字节(固定)
long: 8个字节
unsigned long: 8个字节(变化其实就是寻址控件的地址长度数值)
long long: 8个字节(固定)
在这里插入图片描述
空类求sizeof为1，加不加构造函数对sizeof没影响，但有了虚函数，则需要有一个指针指向虚函数表，32位下，指针sizeof为4
在这里插入图片描述
Mul(a+b,b+c)经过宏替换变成++a+b(++b)+c，即2+33+3
Mul(a+b,b+c)经过宏替换变成++a+b++b+c，需要注意宏替换的原则，是不会凭空加括号的。另外++优先级大于*，因此会先++a 和++b，然后a=2,b=3进行a+bb+c=2+33+3=14
在这里插入图片描述
在这里插入图片描述
该题考察函数的参数传递：
当用函数做实参时，编译器一般会根据参数传递顺序，先计算出函数的返回值，然后将返回值传递给原来的函数。
在x86架构（Linux或Unix系统）上，函数的参数是通过栈传递的。因此参数从右往左入栈顺序是：printf(“c”)，printf(“b”)，printf(“a”)。依次计算出结果：cba
在x86_64架构（Linux或Unix系统）上，函数的前6个参数是通过寄存器传递的，超出6个的部分（如第7个参数，第8个参数等等）通过栈传递。因此参数进寄存器顺序是：printf(“a”)，printf(“b”)，printf(“c”)。依次计算出结果：abc
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
for(inti=0;i<N;++i)
a[i]=(0==i%2)?(i+2):(i+0);
结果为
[2,1,4,3,6,5,8,7,10,9]
int (b)[N/M]=(int ()[N/M])a;
//int (b)[5]=(int ()[5])a;
b是数组指针,数组指针是指向一大块内存
现在对于b,数据是这样的
[[2,1,4,3,6],[5,8,7,10,9]]
//b[0]–>[2,1,4,3,6]
//b[1]–>[5,8,7,10,9]
//顺序打印
for(int i=0;i<M;++i)
for(int j=0;j<N/M;++j)
printf(“%d”,b[i][j]);
在这里插入图片描述
C++中 的虚函数的作用主要是实现了多态的机制。而虚函数是通过虚函数表(V-Table)实现的。
构造函数不能声明为虚函数，析构函数可以声明为虚函数，而且有时是必须声明为虚函数。
构造函数为什么不能声明为虚函数？
1 构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间确定实际类型的。而在构造一个对象时，由于对象还未构造成功。编译器无法知道对象的实际类型，是该类本身，还是该类的一个派生类，或是更深层次的派生类。无法确定。
2 虚函数的执行依赖于虚函数表。而虚函数表在构造函数中进行初始化工作，即初始化vptr，让他指向正确的虚函数表。而在构造对象期间，虚函数表还没有被初 始化，将无法进行。 析构函数执行时先调用派生类的析构函数，其次才调用基类的析构函数。
析构函数为什么声明为虚函数？
如果析构函数不是虚函数，而程序执行时又要通过基类的指针去销毁派生类的动态对象，那么用delete销毁对象时，只调用了基类的析构函数，未调用派生类的析构函数。这样会造成销毁对象不完全。
包含至少一个纯虚函数的类视为抽象类
答案：ＡＤ
在这里插入图片描述
C++标准规定类的大小不为0，空类的大小为1，当类不包含虚函数和非静态数据成员时，其对象大小也为1。
对有虚函数的类来说，必须为它的对象提供运行时类型信息(RTTI，Run-Time Type Information)和关于虚函数表的信息，常见的做法是在对象中放置一个指向虚函数表的指针，此外，为了支持RTTI，许多编译器都把该类型信息放在虚函数表中。但是，是否必须采用这种实现方法，C++标准没有规定，主流编译器均采用的一种方案。
虚函数、成员函数[包括静态与非静态]、和静态数据成员都是不占用对象的存储空间的
对象大小 = 虚函数指针 + 所有非静态数据成员大小 + 因对齐而多占的字节
另一种解答：类的大小与它的构造函数、析构函数以及其他成员函数无关，只与它的数据成员相关。
当一个类中包含虚函数时，会有一个指向其虚函数表的指针vptr，系统为类指针分配大小为4个字节(即使有多个虚函数)。
在这里插入图片描述
在这里插入图片描述

中兴0903

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<cstring>
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
const int MAX =6;
const int MAX_NUM= 999999;
vector<vector<int>> path(MAX,vector<int>(MAX ,MAX_NUM));
vector<vector<bool>> isUsed (MAX,vector<bool>(MAX,false));
struct methods{
    public:
        int request(int x,int y){
            if(path[x][y]==MAX_NUM){
                return -1;
            }
            else{
                return path[x][y];
            }
        }
        void solve(int n){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    for(int k=1;k<=n;k++){
                        if(i==j)continue;
                        path[i][j]=min(path[i][j],path[i][k]+path[k][j]);
                    }
                }
            }
        }
    private:
};
int main(){
    methods md;
    int n,m,q;
    while(cin>>n>>m>>q){
        int x,y,l;
        for(int i=0;i<m;i++){
            cin>>x>>y>>l;
            path[x][y]=l;
            path[y][x]=l;
        }
        vector<vector<int>> search(q,vector<int>(2,0));
        for(int i=0;i<q;i++){
            cin>>search[i][0]>>search[i][1];
        }
        md.solve(n);
        for(int i=0;i<q;i++){
            cout<<md.request(search[i][0],search[i][1])<<endl;
        }
    }

}

美的829

选择题
1在这里插入图片描述
答案：B
拷贝构造函数
拷贝构造函数是C++独有的，它是一种特殊的构造函数，用基于同一类的一个对象构造和初始化另一个对象。
当没有重载拷贝构造函数时，通过默认拷贝构造函数来创建一个对象
A a;
A b(a);
A b=a; 都是拷贝构造函数来创建对象b
强调：这里b对象是不存在的，是用a 对象来构造和初始化b的！！
赋值函数
当一个类的对象向该类的另一个对象赋值时，就会用到该类的赋值函数。
当没有重载赋值函数（赋值运算符）时，通过默认赋值函数来进行赋值操作
A a;
A b;
b=a;
强调：这里a,b对象是已经存在的，是用a 对象来赋值给b的！！

赋值运算的重载声明如下：
A& operator = (const A& other)
通常大家会对拷贝构造函数和赋值函数混淆，这儿仔细比较两者的区别：
1）拷贝构造函数是一个对象初始化一块内存区域，这块内存就是新对象的内存区，而赋值函数是对于一个已经被初始化的对象来进行赋值操作。

1.	class  A;  
2.	A a;  
3.	A b=a;   //调用拷贝构造函数（b不存在）  
4.	A c(a) ;   //调用拷贝构造函数  
5.	  
6.	/****/  
7.	  
8.	class  A;  
9.	A a;  
10.	A b;     
11.	b = a ;   //调用赋值函数(b存在)</span>

2
在这里插入图片描述
答案：C
3
在这里插入图片描述
链接：https://www.nowcoder.com/questionTerminal/57eabacc991048c184acc4486667c75c
来源：牛客网
解释：
虚函数也是类的成员函数，A说法是不正确的；
虚函数和函数重载都实现了C+=的多态性，但表现形式不一样，函数重载调用根据参数个数、参数类型等进行区分，而虚函数则是根据动态联编来确定调用什么，故BD说法正确
函数重载可以是类的成员函数也可以是非成员函数，比如:
复制代码
1
2 int fun(int a);
int fun(int a, int b);
这就是非成员重载，虚函数必须是成员函数了，否则就失效了， 所以C对
4
在这里插入图片描述
答案：B
5
在这里插入图片描述
答案：D
https://www.nowcoder.com/questionTerminal/f6d95d878ead4eb895cf7dcbc7f99f7f
6
在这里插入图片描述
答案：D
7
在这里插入图片描述

答案：C
8
在这里插入图片描述
在这里插入图片描述
答案：B
9
在这里插入图片描述
答案：D
https://www.nowcoder.com/questionTerminal/9953a48f422048c1991a10f13894718d?source=relative
10
在这里插入图片描述
在这里插入图片描述
答案：C
11在这里插入图片描述

答案：C
12在这里插入图片描述

在这里插入图片描述
答案：B
13
在这里插入图片描述
14在这里插入图片描述
答案：C
链接：https://www.nowcoder.com/questionTerminal/eeb40b98950540308fc36e974d65bc52
来源：牛客网
把MyClass a[4]，*p[5]；分开写；
MyClass a[4]；
MyClass *p[5]；
则a[4]是类数组，有4个对象，调用构造函数4次
*p[5]是指针数组，也就是5个元素存放的是指向MyClass类型的对象的指针，没有初始化的指针为空，不指向任何对象，也不调用构造函数。
15
在这里插入图片描述
16在这里插入图片描述
在这里插入图片描述

答案：D
开始p指向“
glad to test something”中的g，然后p++，指向l
int *p1 = static_cast§; 把p赋值给int型了
p1++,即加了4个字节位置。即p1指向“glad to test something”中的t
p = static_cast(p1); 把p1的转回了p，p指向了“
glad to test something”中的t
输出从t开始
to test something

17
在这里插入图片描述
在这里插入图片描述
答案： B
这道题主要考察的知识点是 ：全局变量，静态局部变量，局部变量空间的堆分配和栈分配
其中全局变量和静态局部变量时从 静态存储区中划分的空间，
二者的区别在于作用域的不同，全局变量作用域大于静态局部变量（只用于声明它的函数中），
而之所以是先释放 D 在释放 C的原因是， 程序中首先调用的是 C的构造函数，然后调用的是 D
的构造函数，析构函数的调用与构造函数的调用顺序刚好相反。
局部变量A 是通过 new 从系统的堆空间中分配的，程序运行结束之后，系统是不会自动回收分配给它的空间的，需要程序员手动调用
delete 来释放。
局部变量 B 对象的空间来自于系统的栈空间，在该方法执行结束就会由系统自动通过调用析构方法将其空间释放。
之所以是 先 A 后 B 是因为，B 是在函数执行到 结尾 “}” 的时候才调用析构函数， 而语句
delete a ; 位于函数结尾 “}” 之前。

18
在这里插入图片描述
答案：A
1、当给WEB服务器接上网线的时候，它会自动发送一条ARP信息，使得接入网关能找的到它；
网关上会形成一条类似：2c 96 1e 3c 3e 9b - 192.168.1.123的MAC地址到IP地址的映射记录。
2、当第一个用户使用域名访问WEB服务器的时候，首先要进行一次DNS查询
3、最后才是http协议
19
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
答案：B
20

大疆816

作者：变成光
链接：https://www.nowcoder.com/discuss/479182?type=post&order=create&pos=&page=1&channel=666&source_id=search_post
来源：牛客网
编程题2
时间限制： 3000MS
内存限制： 589824KB
题目描述：
有许多程序员都热爱玩游戏，而小J自称为游戏王，曾玩过几百种游戏，几乎所有能玩到的游戏大作都玩遍了。随着时间的推移，他发觉已经没有游戏可以让他玩了！于是他想改玩一些古老的游戏，以成为真正的“游戏王”。他希望在接下来的一段时间内将过去出的游戏全部玩一遍，但是毕竟时间有限，因此他感到很苦恼。于是他想到一个计划，他先将每个游戏标上一个成就值，同时对每个游戏都估算一个通关所需要的天数，他计划在未来X天内让自己玩游戏的成就达到最大，那么他应该怎么做计划呢？（假设每个游戏最多只计划玩一遍，而且每个游戏必须玩完通关才能取得成就值，且通关每个游戏最小时间单位是1天）
输入描述
第一行输入两个整数N和X，中间用空格隔开，其中N表示游戏的数目N(1<=N<=10)，X表示计划玩游戏的总时间天数 (1<=X<=1000)。
第二行输入第1个游戏的成就值A1(0<=A1<=10000) 和 通关所需要花费时间B1天 (1<=Bi<=500) 中间用空格隔开。
第N+1行输入第N游戏的成就值An(0<=An<=10000) 和 通关所需要花费时间Bn天(1<=Bn<=500) 中间用空格隔开
输出描述
可以达到成就之和的最大值。
样例输入
2 2
10 1
20 2
样例输出
20
提示
输入样例二:
3 4
10 2
18 3
10 2
输出样例二:
20
代码：

package com.likou.test;

import java.util.Arrays;
import java.util.Scanner;
/**
* DJI 1
* @author duzihao
* @date 2020/8/16 - 19:27
* 背包问题，使用贪心
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String ssssss = sc.nextLine();
String[] sd = ssssss.split(" ");
int T = Integer.valueOf(sd[0]);     //获得长度
int cost = Integer.valueOf(sd[1]);     //获得时长 

int[] Ai = new int[T];     //存放游戏
int[] Bi = new int[T];     //每个游戏对应时长

for (int j = 0; j < T; j++) {   //遍历长度输入数据
Ai[j] = sc.nextInt();
Bi[j] = sc.nextInt();
}
dfs(T, cost, Bi, Ai);
sc.close();
}
public static void dfs(int N, int X, int[] Ai, int[] Bi) {
int[] count = new int[X + 1];
Arrays.fill(count,0);      //初始化数据

for (int i = 0; i < N; i++) {
int w = Ai[i];
int v = Bi[i];
for (int j = X; j >= w; j--) {
count[j] = Math.max(count[j], count[j - w] + v);
}
}
System.out.println(count[X]);
}
}

编程题3
时间限制： 3000MS
内存限制： 589824KB
题目描述：
小C平时最喜欢玩数字游戏，最近他碰到一道有趣的数字题，他和他的好朋友打赌，一定能在10分钟内解出这道题，成功完成，小C就可以得到好朋友送他的Switch游戏机啦，你能帮助小C赢得奖品吗？
题目是这样的：给定一个非负的、字符串形式的整形数字，例如“12353789”，字符串的长度也就是整形数字的位数不超过10000位，并且字符串不会以0开头，小C需要挑选出其中K个数字（K小于字符串的长度）并删掉他们，使得剩余字符组成新的整数是最小的。
输入描述
第一行输入一串纯数字形式的字符串，组成一个正整数
第二行输入一个正整数K (K < 字符串的长度)
输出描述
输出一个数字（字符串格式）

样例输入
71245323308
4
样例输出
1223308

提示
输入样例二:
1683212
3
输出样例二:
1212
输入样例三：
100
1
输出样例三:
0
代码：
package com.likou.test;

import java.util.Scanner;

/**

  • 给定一个非负的、字符串形式的整形数字，例如“12353789”，
  • 字符串的长度也就是整形数字的位数不超过10000位，并且字符串不会以0开头，
  • 小C需要挑选出其中K个数字（K小于字符串的长度）并删掉他们，使得剩余字符组成新的整数是最小的。
  • @author duzihao
  • @date 2020/8/16 - 20:00
    */
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String num = scanner.nextLine();    //获取字符串
String len = scanner.nextLine();     //获取删除的长度

System.out.println(Solution.removeKdigits(num,len));
}
}
class Solution {
public static String removeKdigits(String num,String len) {
int k = Integer.valueOf(len);
if(num == null || ("").equals(num) || ("").equals(num.trim()) || k==0 ){
return num;
}

if(num.length() <= k || num.length()>10002 ){
return "0";
}
StringBuffer sb =  new StringBuffer(num);
while(k>0) {
int i=0;
while(sb.length()-1>i && sb.charAt(i)<=sb.charAt(i+1)) {
i++;
}
sb.delete(i, i+1);
k--;
}

while(sb.length()!=0 && sb.charAt(0) == '0')
sb.delete(0, 1);

if(sb.length()==0)
return "0";
return sb.toString();
}
}

编程题1
时间限制： 3000MS
内存限制： 589824KB
题目描述：
最近DJI发布了一款Robomaster S1机器人，小伙伴们都沉迷其中不能自拔。小J为了能够在竞速比赛中迅速获胜，他决定利用开发的优势，在里面植入一套最优化的寻路算法。
比赛规则如下: 在比赛场地内预先设置N个路标，路标编号从0到N-1，S1只能沿直线在两个有连接的路标之间移动（部分路标之间是没有连接的） 比赛场地内的S1机器人从编号为0的路标出发，然后裁判给出随机一个路标（从0到N-1号路标中随机挑选一个）作为终点路标，要求S1机器人以尽可能快的速度从0号路标达到终点路标，总路程用时最短者获胜。
裁判会确保从0号路标和随机挑选的终点路标之间肯定存在至少一条路径。 小J在比赛开始前就已经得知了路标的数量 、通道的数量（每两个可以直接连接的路标点为一个通道）以及小车在每个通道上移动需要的时间。他需要编写一套算法，以确保能够快速找到最短路径，并输出小车在该路径移动所需要的时间，你能帮他实现这套算法吗?

输入描述
第一行输入两个个正整数 N和 P，其中N表示路标的数量， P表示通道的数量。 (1 < N <= 200, 0 <= P <= N * (N - 1) / 2 ）
接下来的P行，每行输入三个正整数 A, B, T，A表示起点路标的编号，B表示终点路标的编号，T表示路标A到路标B需要时间T。 (0 <= A, B <= N-1, 1 <= T <= 100)
最后一行输入一个正整数 X，表示裁判给出的终点路标编号 (0 =< X <= N)
输出描述
输出一个正整数，表示小车从0号路标到X号路标之间移动的最短用时

样例输入
4 5
0 1 15
1 2 15
0 3 50
1 3 30
2 3 10
3

样例输出
40

代码：
作者：我一肚子火
链接：https://www.nowcoder.com/discuss/479182?type=post&order=create&pos=&page=1&channel=666&source_id=search_post
来源：牛客网

 public static int min = Integer.MAX_VALUE;

 public static void main(String[] args) {

  Scanner scanner = new Scanner(System.in);
  int N = scanner.nextInt();
  int M = scanner.nextInt();
  int[][] road = new int[N][N];
  for(int i = 0 ; i < M ; i++){
   int a = scanner.nextInt();
   int b = scanner.nextInt();
   int t = scanner.nextInt();
   road[a][b] = t;
   road[b][a] = t;
  }
  int x = scanner.nextInt();
  min = Integer.MAX_VALUE;
  int[] flags = new int[N];
  flags[0] = 1;
  findPath(road, 0, x, flags, 0);
  System.out.println(min);
 }

 public static void findPath(int[][] path, int curIndex, int target, int[] flags, int sum){
  if(curIndex == target){
   min = Math.min(min, sum);
  }else{
   for(int i = 0; i < path.length ; i++){
    if(flags[i] != 1 && path[curIndex][i] != 0 && path[curIndex][i] < min && sum < min){
     flags[i] = 1;
     sum += path[curIndex][i];
     findPath(path, i, target, flags, sum);
     sum -= path[curIndex][i];
     flags[i] = 0;
    }
   }
  }
 }
}

思路：感觉是个图的最短路径问题，时间不够了，做不出来

中兴831

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2在这里插入图片描述

在这里插入图片描述

海康828

选择题
1
在这里插入图片描述

答案：D
2
在这里插入图片描述

答案：B
3
在这里插入图片描述

答案:A
变量的声明bai有两种情况： （1） 一种是需要du建立存储空间的（定zhi义、声明）。例如：daoint a在声明的时候就已经建立了存储空间。 （2） 另一种是不需要建立存储空间的（声明）。例如：extern int a其中变量a是在别的文件中定义的。 前者是"定义性声明（defining declaration）“或者称为"定义（definition）”,而后者是"引用性声明（referncing declaration）".从广义的角度来讲声明中包含着定义，但是并非所有的声明都是定义，例如：int a它既是声明，同时又是定义。然而对于extern a来讲它只是声明不是定义。一般的情况下我们常常这样叙述，把建立空间的声明称之为"定义",而把不需要建立存储空间称之为"声明".很明显我们在这里指的声明是范围比较窄的，也就是说非定义性质的声明。
4
在这里插入图片描述

答案：D
5
在这里插入图片描述

答案：B
6
在这里插入图片描述

7
在这里插入图片描述

class Foo{
    public:
    Foo(int x):value(x){}
    ~Foo(){}
    private:
    Foo(){}
    int value=0;
};
int main(){
    Foo F(1);
    int cc=1;
}

答案：B
8
在这里插入图片描述

答案：B
B：明显错误，参考《Effective C++》第39条,不要向下转型。
A：正确，也是《Effective C++》第37条，如果子类要重写父类方法，需要将父类该方法声明为virtual，实现RTTI。当然你可以不这样干，结果就是静态绑定。补充一点，重写就叫覆盖。如果没有virtual就是隐藏。
9
在这里插入图片描述

答案：B
10
在这里插入图片描述

答案：A
假设是数组，第一位置是空的（从数组下标1开始），对于任意n>1满足a[n]>a[n/2](或）a[n]<a[n/2]的就是堆。
11
在这里插入图片描述

答案：
所谓破坏互斥使用资源，指允许多个进程同时访问资源，但有些资源根本不能同时访问，如打印机只能互斥使用。所以，破坏互斥条件而预防死锁的方法不太可行，而且在有的场合应该保护这种互斥性。其他三个条件都可以实现。
12
在这里插入图片描述

答案；C
13
在这里插入图片描述

答案：
14
在这里插入图片描述

A：可以相同，因为他们是本地有效的
答案：D
15
在这里插入图片描述

答案：C
多选题
1
在这里插入图片描述

答案：BCD
2
在这里插入图片描述
在这里插入图片描述

答案：CD
D中的case里面必须常量
3
在这里插入图片描述

答案:BC
4
在这里插入图片描述

答案：

qq_30347421
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C、C++公司面试题
10-04
这是一些大公司的C和C++的面试题，搜集了很长时间，谢谢诶支持啊，嘿嘿、、、
某公司C++笔试题
IT菜鸟
10-22 352
1.编写函数，检查给定字符串是否整数，如果是，返回其整数值（注：不允许使用某种特定的库函数）。 2.有两个无序链表lsit1和list2，编写函数把list1和list2合并成一个递增的链表。 3.编写一段高效的代码，从排序的后的整数中找出指定整数n的个数。如找出[1,1,3,3,3,     5,5,5,9,9,9,9]中的5的个数（为3个）。 4. 编写函数实现字符串分割。SourceStr为
【分享】某公司C++等级考试试题
Steven Well的专栏
09-18 625
试题类型：编程类 时间：5个小时 编程工具：visual c++ 6.0 试题： 1、用MFC实现窗口聊天工具(一个服务器端和一个客户端)。 2、将两个无序链表A和B合并为一个有序链表，并将值与对应的位置存入数据库C表中。(应用access数据库，实现自动注册数据源) 3、将test.txt文件用栈排序后覆盖并存入test.txt文件。
苏州C/C++方向的公司汇总
天道酬勤
02-09 2046
一、知己知彼 二、后续再更新 1、苏州智华（苏州市吴江经济技术开发区） 2、苏州思必驰（苏州市工业园区星湖街） 3、苏州科达（苏州高新区） 4、苏州ADAS：博世 德尔福 辉创（全球订单量最大、偏倒车） 智华 安智 知行 行业 5、机器人：华晓精密工业（科大智能）、科沃斯、苏州元谋智能机器人 ...
硬核 | 50 家企业 C++ 面经分享
李肖遥的专栏
11-15 1885
昨天一位读者分享了自己的 C++ 面试经历。简单沟通后，读者双非本硕，自嘲校招准备注定就是炼狱模式。50 家公司的 C++ 面经也整理好了。本次就分享下面经。以后分享学习路线和心得。读者情...
蓝桥杯 C++ 历年真题题解
02-29
历届真题 contests 2013 年蓝桥杯 2017 年蓝桥杯 2018 年蓝桥杯 2019 年蓝桥杯 2020 年蓝桥杯 2021 年蓝桥杯 2022 年蓝桥杯 蓝桥杯 C++ 历年真题题解 历届真题 contests ...蓝桥杯 C++ 历年真题题解
GESP C++ 等级考试真题及样题，截止24年3月（全）.rar
03-18
《GESP C++ 等级考试：历年真题与样题详解》 GESP（Global Educational Standards Program）C++等级考试是针对C++编程语言的一项权威认证，旨在测试考生对于C++语言的理解和应用能力。这个压缩包包含了从23年3月至...
C++面试真题
02-25
这份2012年的面试真题集包含了多家知名公司对C++开发者的考核要点，涵盖了许多关键知识点，让我们一起来深入探讨其中的核心概念。 1. **基本语法与数据类型**：面试通常会从基础开始，例如询问C++中的基本数据类型...
蓝桥杯C++省赛真题题解
04-12
蓝桥杯c 蓝桥杯C++省赛真题题解是一本旨在帮助参赛者深入理解和掌握C++编程语言及其在解决实际问题中的应用的宝贵资料。通过题解，参赛者不仅可以学习到题目的正确解法，更能够从中掌握解题的思路和方法，提高自己的...
C++软件工程师笔试真题
11-22
C++软件工程师笔试真题，供大家学习参考，住大家都能找到好工作！
各个公司c++软件面试总结
10-31
海康威视，大华，中兴等公司c++软件面试总结。
C++公司人员和月薪管理系统
12-13
C++系统设计，详细设计 ，该系统实现对公司在职员工及新聘任员工的月薪进行管理，同时能够统计所有员工的月薪总额，让企业知道其资金流动方向，给企业管理带来安全性和便捷性..............................
C++公司员工的简单功能实现
sinat_42721727的博客
08-02 1234
Employee.h #ifndef _EMPLOYEE_H #define _EMPLOYEE_H #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class Employee { protected: static int num; int m_id; string m_name; ...
C++ 50 家企业校招面经
C语言与CPP编程的博客
08-26 1533
校招面经 大家好,我是唐唐。 昨天一位读者分享了自己的 C++ 面试经历。简单沟通后，读者双非本硕，自嘲注定就是炼狱模式。50 家公司的 C++ 面经也整理好了。本次就分享下面经。以后分享学习路线和心得。 程序员书籍资源！ 读者情况：双非本硕，本科机械，硕士做的软件开发课题。 学过一点点 C++，但是面试前连多态都不会写。研三经历炼狱校招，从零开始学习，数据结构和算法也是从零开始。 时间：2020 年 10 月- 2021 年 4 月 结果：几乎面试了所有大厂，收到了 13 份 offe
动态规划问题--“游戏王”，将每个游戏标上一个成就值，同时对每个游戏都估算一个通关所需要的天数，他计划在未来X天内让自己玩游戏的成就达到最大
qq_43515131的博客
08-19 196
import java.util.Scanner; /* 题目描述： 有许多程序员都热爱玩游戏，而小J自称为游戏王，曾玩过几百种游戏，几乎所有能玩到的游戏大作都玩遍了。 随着时间的推移，他发觉已经没有游戏可以让他玩了！于是他想改玩一些古老的游戏，以成为真正的“游戏王”。 他希望在接下来的一段时间内将过去出的游戏全部玩一遍，但是毕竟时间有限，因此他感到很苦恼。于是他想到一个计划 ，他先将每个游戏标上一个成就值，同时对每个游戏都估算一个通关所需要的天数，他计划在未来X天内让自己玩游戏的成就达到最大 ，那么他应
07:收集瓶盖赢大奖
www.imayuan.com
09-01 6923
原题链接 总时间限制: 1000ms 内存限制: 65536kB 描述 某饮料公司最近推出了一个“收集瓶盖赢大奖”的活动：如果你拥有10个印有“幸运”、或20个印有“鼓励”的瓶盖，就可以兑换一个神秘大奖。 现分别给出你拥有的印有“幸运”和“鼓励”的瓶盖数，判断是否可以去兑换大奖。 输入一行，包含两个整数，分别是印有“幸运”和“鼓励”的瓶盖数，用一个空格隔开。
C++ 继承篇
最新发布
2301_79201049的博客
07-18 692
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
程序员面试宝典：C++真题详解与实战指南
"《cc++真题库》是由猿媛之家编著的一本计算机专业面试、笔试真题集，主要针对C++程序员的求职需求。该书旨在帮助读者应对各大IT企业的面试和笔试，特别是那些在系统软件、搜索引擎、电子商务、手机应用和安全关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值