C++科目二

头像
调皮的汽水
    阅读 11 分钟

    • 【单选】设有如下定义，则选项中调用Func函数正确的是（A）

      template <typename T>
struct Type2Type {};

template <typename T>
void Func(Type2Type<T>) {...}

A. Func(Type2Type<int>())

B. Func(Type2Type<int>)

C. Func(<std::string>())

D. Func(<int>(4))

      解析：只有A选项创建了一个Type2Type的实例。B选项是一个类型、C选项和D选项显然不正确（尖括号开头）

    • 【多选】设有如下定义，则选项中调用Func函数正确的是（AD）

      struct Type2Type {};

template <typename T>
void Func(T t) {...}

A. Func(Type2Type<int>())

B. Func(Type2Type<int>)

C. Func(<std::string>())
  
D. Func(4)

      这类题关注哪些选项创建了具体实例即可。

    • 【单选】myAlloc是一个自定义的内存分配方法，若想声明一个myVector，使得myVector使用myAlloc方法分配内存，下面定义正确的是（C）

      template <typename T>

A. typedef vector<T, myAlloc<T>> myVector

B. typedef vector<T, myAlloc<T>> myVector<T>

C. using myVector = vector<T, myAlloc<T>>

D. using myVector<T> = vector<T, myAlloc<T>>

      解析：本题考查 typedef 和 using 定义类型别名的区别
      C++11之前，使用typename定义类型别名，C++11之后，可以使用using来定义类型别名

      using支持定义模板的别名：

      using myVector = std::vector<T, myAlloc<T>>
  
myVector<int> data;

      而typedef不支持带模板参数的别名，只能“曲线救国”：

      struct myVector {
  typedef std:;vector<T, myAlloc<T>> type;
};

myVector<int>::type data; // 使用时需要多写 ::type

    • 【多选】不保证对齐，下列指针转换符合C++编程规范继承自C语言规范条款的有（BD）

      A.
char *pc;
int *pi = reinterpret_cast<int *>(pc);

B.
int *pi;
char *pc = reinterpret_cast<char *>(pi);

C.
char *pc;
void *pv = pc;
int *pi = static_cast<int *>(pv);

D. 
int *pi;
void *pv = pi;
float pf = static_cast<float *>(pv);

    • 【多选】 满足C++编程规范的是（ D ）

      A.
 std::vector<bool> c {true, false, true};
 auto v = c[0];

B. auto p = std::make_unique<Foo>();
 
C. constexpr auto MAX_LEN = 1024L;

D. auto iter = m.find(val); // m 是一个map

    • 【单选】下面位移操作符合规范的是（ D ）

      A. int lhs = 180;
 int a = lhs >> 3;

B. int lhs = 10;
 int a = 3 >> lhs;
 
C. unsigned char lhs = 80;
 unsigned int a  = (~lhs) >> 3;
 
D. constexpr int lhs = 10;
 unsigned int a = 3u >> lhs;

    • 【单选】模板函数，下列选项错误的是（D）

      template <typename T>
void ForWordRef(Args&& ...args)
{
  Foo(std::forward<Args>(args)...);
}

A. 如果参数中有const T&, 则Foo接受的参数类型为const T&
  
B. 如果参数中有T&&， 则Foo接受的参数类型为T&&
  
C. 如果参数中有T，则Foo接受的参数类型为T&
  
D. 如果参数中有T&，则Foo接受的参数类型为T&&

    • 【单选】【tie】下面代码运行结果是（D）

      int a = 1, b =5;
int &r = a;

auto t = std::tie(r,b);
std::get<0>(t) = 3;
std::get<1>(t) += 2;

cout<<a<<" "<<b<<endl;

A. 1 5
B. 3 5
C. 1 7
D. 3 7

    • 【单选】【作用域】下面代码运行结果是（A）

      int count = 10;

namespace test {
  int count = 1;
  int getCount()
  {
      ::count++;
      return count;
  }
}

int main()
{
  int count = 2;
  count = test::getCount();

  cout<<count<<" "<<::count<<endl;
  return 0;
}

A. 1 11
B. 1 10
C. 2 11
D. 2 2

    • 【单选】【lambda】下面代码运行结果是（B）

      int n = 1;

auto func1 = [=] { return n; };
auto func2 = [&] { return n; };

n++;

cout<<func1()<<" "<<func2()<<endl;

A. 1 1
B. 1 2
C. 2 2 
D. 2 1

    • 【多选】在Func的填入相应代码，可以正确编译链接，且输出为0的是（ABCD）

      inline Func(int x)
{
  _____ // 待填入代码
}


int a = Func(1);
cout<<a<<endl;


A.
  if (x == 0) {
      return 0;
  }
  return Func(x - 1);

B. 
  return x - 1;

C. 
  int sum = 0;
  for (int i = 0; i < x; ++i) {
      sum += 0;
  }
  return sum;

D.  
  static int y = x;
  return y - 1;

    • 【单选】以下语句中，s初始化时会触发移动构造的是（ D ）

      A. string str = "hello";

B. string str;
 string s = string("hello");
 
C. string str;
 string&& r = std::move(str);
 string s{r};
 
D. extern string g_str;
 string s = std::move(g_str);

      解析：r 虽然是一个右值引用，但它本身并不是一个将亡的变量，而是一个可以被赋值的变量，因此是一个左值，左值赋给左值会触发拷贝构造而不是移动构造。

    • 【单选】下面代码的输出是（A）

      class A{
public:
  void* operator new(size_t size){
      cout<<"operator new 1"<<endl;
      return malloc(size);
  }

  void* operator new[](size_t size){
      cout<<"operator new 2"<<endl;
      return malloc(size);
  }
};

void* operator new(size_t size){
  cout<<"operator new 3"<<endl;
  return malloc(size);
}

void* operator new[](size_t size){
  cout<<"operator new 4"<<endl;
  return malloc(size);
}

int main()
{
  A* pA = new A();
  return 0;
}

A. operator new 1
B. operator new 2
C. operator new 3
D. operator new 4

      解析：
      自定义的 new 运算符相当于是对全局的 new 运算符的重载。
      自定义了 new 操作符，并且是public 的，因此输出的是 operator new 1。
      若未自定义new 操作符，则会输出operator new 3，作用相当于A* pA = ::new A()，表示调用全局的new操作符
      若定义了，但不是 public的，则只能使用::new A()来调用全局的 new 操作符，此时输出operator new 3。

    • 【单选】下面代码中，c的值是（B）

      unsigned int a = 5;
int b = -20;
int c;

(a + b) > 6 ? (c = 1) : (c = 0);

A. 0
B. 1
C. 运行出错
D. 编译出错

      解析：考察类型转换，int与unsigned int的运算，int提升为unsigned int做计算。

    • 【单选】下列说法正确的是（D）

      unsigned int a = 5;
long b = -20;
auto c = a + b;

A. c的类型推导为long
B. c的类型推导为unsigned int
C. c的类型推导为long long
D. 在不同系统中，c的类型可能推导为long或unsigned long

      解析：在 long 与 int 等价的系统上，推导为 unsiged long，在 long 比 unsigned int 大的系统上，推导为 long。

    • 【单选】基于Linux操作系统所开发的ARM应用程序test.cpp，若要生成其调试信息，应使用的GCC命令是：( D )

      A. arm-linux-gcc -o test test.cpp

B. arm-linux-gcc -S -o test test.cpp

C. arm-linux-gcc -c -o test.o test.cpp

D. arm-linux-gcc -g -o test test.cpp

      解析：

      arm-linux-gcc -o test test test.cpp
-o 参数用于指定输出的文件，输出文件名为test.o，若不指定输出文件，则默认输出 a.o

arm-linux-gcc -S -o test test.cpp
-S 参数将对源程序 test.cpp 进行预处理、编译

arm-linux-gcc -c -o test.o test.cpp 
-c 参数对源程序进行预处理、编译、汇编操作，生成 test.o;去掉指定的输出选项"-o test.o"会自动生成test.o文件，所以这里的-o可加可不加

arm-linux-gcc -g -o test test.cpp
-g 参数，可以加入gdb调试信息

    • 【单选】若对于函数Func(int a, int b)，其中a小于0的频度很小，约为每小时一次；若需要在a小于0时，取出b的值，则下列关于gdb捕获b的取值，正确且最有效的是（A）

      A. b Func if a < 0
 commands
 p b
 c
 end
 
B. b Func
 p a
 p b

C. p b if a < 0

D. b Func
 commands
 if a < 0
 p b
 end

    • 【单选】给定如下gtest语句，则一共产生了（ 3 ）个测试用例

      TEST_P(FooTest, HasBlahBlah) {...}

INDTANTIATE_TEST_SUITE_P(InstantiationName,
                      FooTest,
                      ::testing:;Values("meeny", "miny", "moe"));

    • 【多选】关于测试用例运行的独立性，如下描述错误的是 ( B )

      A. 测试用例运行的独立性是为了保证测试用例运行结果的稳定可靠

B. 为了做到用例的复用，测试用例可以将已经执行过的测试结果作为预置条件

C. 测试用例执行的先后顺序不应该影响最终的测试结果

D. 用例执行时不应该存在与外部交互的过程

    • 【单选】对于std::vector<int>类型的对象myVector，下面那种方法可以正确获取myVector所含元素的个数（D）

      A. sizeof(myVector)
B. sizeof(myVector)/sizeof(int)
C. myVector.capacity
D. myVector.size()

    • 【多选】下面可以正确获得string变量str的字符串长度的是（AD）

      A. str.size()

B. str.capacity()

C. sizeof(str)

D. str.length()

E. sizeof(str) - 1

    • 【单选】下面程序运行后，i 和j的值是（A）

      int i = 0;
int j = 0;
for (i = 10; i >= 0; i--) {
  for (j = 10; j == 0; j--) {
      i = j;
  }
}

cout<<i<<" "<<j<<endl; 

A. -1 10
B. 死循环
C. 0 0
D. 1 10

    • 【单选】符合华为C++编码规范的日志打印功能的是（C）

      A. void Log()
 {
     printgf("%s, %s", __LINE__, __FUNC__, "example");
 }

B. inline void Log()
 {
     printgf("%s, %s", __LINE__, __FUNC__, "example");
 }

C. #define LOG printgf("%s, %s", __LINE__, __FUNC__, "example");

D. class Log{
     void Log()
     {
         printgf("%s, %s", __LINE__, __FUNC__, "example");
        }
 }

    • 【单选】下列程序的运行结果是（ “ABC”）

      bool T(char c)
{
  cout<<c;
  return true;
}

bool F(char c)
{
  cout<<c;
  return false;
}

int main()
{
  T('A') && T('B');
  F('C') && T('D');
  
  return 0;
}

    • 【单选】下列代码运行的结果是（ 11 ）

      #define SQ(x) (x * x)

cout<<SQ(3 + 2)<<endl;

    • 【单选】下面变量名最符合规范的一个是（ A ）

      A. int num_completed_connections

B. n1

C. int nerr

D. n_com_conns

    • 【多选】程序中异常处理，说法错误的是（ ACD ）

      A. 可以用异常来控制流程走向，异常的优先级高

B. 不要过多的使用异常，在捕获异常处理时，尽量捕获最小类

C. 根据程序情况决定使用异常还是使用错误码，或者二者混合使用

D. 当需要扔出error异常时，应自定义一个Error子类供使用

    • 【单选】以下程序打印结果为（ 525210 ）

      int main()
{
  int a = 10;
  int b = 10;
  float beta = 5.2e1;
  
  cout<<(a = static_cast<int>(beta));
  cout<<a;
  cout<<(static_cast<float>(b));
}

    • 【多选】已知char s[] = "hello"， 下列赋值正确的是（ ABC ）

      A. char *p = s;
B. sizeof(s)为6
C. strlen(s)为5
D. char *p = "world";
 s = p;              // 错误，不可修改

    • 【单选】有一个main.c文件，共100行代码，假定任意一行都可以设置断点，其中有int main()和void Func(int a, int b)两个函数，编译后的文件执行发生死锁，需要分析相关的信息找到死锁相关代码，以下关于gdb获取死锁相关信息描述正确的是（ B ）

      A. 执行info address可以显示死锁的代码位置

B. 执行info threads显示所有线程信息，找到死锁相关线程

C. 执行info breakpoints显示断点，断点即死锁信息

D. 死锁时操作系统把进程挂起了，无法通过gdb获取任何信息

    • 【单选】下面输出是（ 1 2 ）

      class B;

class A {
public:
  std::shared_ptr<B> m_b;
};

class B {
public:
  std::weak_ptr<A> m_a;
};


int main()
{
  auto a = std::make_shared<A>();
  auto b = std::make_shared<B>();

  a->m_b = b;
  b->m_a = a;

  cout<<a.use_count()<<endl<<b.use_count()<<endl;
  return 0;
}

    • 【单选】下面代码的输出是（ Base ）

      class Base{};

class Derived : public Base {};

void getBase()
{
  Base *b = new Derived();
  throw *b;
}

int main()
{
  try {
      getBase();
  } catch (Derived &d) {
      cout<<"Derived"<<endl;
  } catch (Base &b) {
      cout<<"Base"<<endl;
  } catch (...) {
      cout<<"ELSE"<<endl;
  }
  return 0;
}

    • 【单选】根据华为C++语言编程规范，针对cpp文件中不需要导出的变量，常量或者函数，下列哪种说法是正确的？（ C ）

      A. 只能使用 static 修饰
B. 只能使用匿名 namespace 封装
c. 可以使用匿名namespace封装或static修饰，推荐使用匿名namespace
D. 可以使用匿名namespace封装或static修饰，推荐使用static
    • 【单选】关于地址消毒错误的是
      使用地址消毒编译的程序和未使用地址消毒编译的程序，占用的内存是一样的

    • 【单选】关于gdb获取死锁相关信息描述正确的是（ B ）

      A. 执行info adddress可以显示死锁的代码位置

B. 执行info thread显示所有线程信息，找到死锁相关进程

C. 执行info breakpoints显示断点，断点即死锁信息

D. 死锁时操作系统把进程挂起了，无法通过gdb获取任何信息

    • 【单选】以下代码符合编程规范的是（D）

      A. int sum = num++ + num++;

B. int sum = (num++) + (num++)

C. in sum = Func(num++, num)

D. num++;
 int sum = num + num;
    • 有以下类型别名定义代码 （参考答案C）
      template<typename T>

    using constptrl=const T*;

    template < typename T >

    using constptr2=const constptrl<T *>

    则constptr2<char>的类型等价于()

    A、 const char **

B、 const  char ** const

C、 char * const * const

D、 const char* const*

    • 在哪些函数或操作符不适合抛出异常 （参考答案ABCD）

      A、 全局变量和线程局部变量的构造函数

B、 delete操作符重载函数

C、 只含一个参数的new操作符重载函数

D、 用于交换两个自定义类型实例的swap函数

    • 以下代码的运行结果为（参考答案A）

      enums status{Good=-1,BAD,unknown}

status st[3];

st[0]=GOOD;

 st[1]=static_cast<status> (static_cast<int>)( unknown-1)

 st[2]= BAD;

cout<<st[0]<<st[1]<<st[2];

A、输出：-100   
B、GOODBADBAD  
C、-111  
D、编译出错

    • 符合规范的是（参考答案BC）

      A、
S Fun()
{
S result；
return std::move
}

B、
S Fun()
{
S result；
return result；
}

C、
S && Fun()
{
S result；
return std::move(result);
}

D、
S && Fun()
{
S result；
return std::forward<s>(result);
}

    • 关于断言，下列符合规范的是(D)

      A、if(sizeo(int)!=4){

   abort();

}

B、assert(sizeof(int))==4);

C、ASSERT (sizeof(int)==4)

D、static_assert(sizeof(int)==4)

    • 以下哪条命令可以正确设置条件断点（test_case.c为文件名，TestCase为函数名，isInit为Testcase中的局部变量）（B）

      A. break test_case.c:100 while (isInit != 0)

B. break test_case.c:100 if (isInit != 0)

C. break TestCase:100 while (isInit != 0)

D. break TestCase:100 if (isInit != 0)

    • 存在int 类型的x y 和 buf，以下关于sprint_f()用法正确的是（B）

      A  sprintf_s(buf, sizeof(buf), ,x,y)

B  sprintf_s(buf, sizeof(buf), '%d' ,x)

C  sprintf_s(buf, sizeof(buf), '' ,x)

D  sprintf_s(buf, sizeof(buf), '%d' ,x,y)

    • gtest单元测试，希望测试检查出问题后直接退出当前执行的用例，使用以下哪个关键（A）

      A. ASSERT
B. EXPECT
C. TearDown
D. SetUp

    • （单选）给了一段代码， 测试代码的坏味道 （题目和以前的有所变化，依赖了其他函数）

      TEST_F(UlschMemoryProtectiont_by_UL, test_ULSCH_MemoryProtectiont)

{

    UINT32 sum = 0;

    UINT32 traceIdx, index;

    L2InfMemallocinfoStru *memStat;

    ULSCH_SetBaseMemSize();

    UINT32 vcpuTraceNum = L2INF_GET_BYTEMEM_TARCENUM();

UINT8 *byteMemStatBuf = L2INF_GET_STATBUF_BYTEMEM();

EXPECT_GE(byteMemStatBuf, memStat.get(index));

    EXPECT_GE(vcpuTraceNum, byteMemStatBuf);

...

}

A. 过度断言

B. 过分保护

C. 测试用例耦合

D. 永不失败的测试

    • （单选）gamma为键盘输入加换行，输出是 考回溯 选 B

      void rec(void)

{

  char c = cin.get();

  if(c != '\n') {

      rec();

      cout<<c;

  }

  return;

}

int  main()

{

  rec();

  return 0;

}

A   输出  gamma

B   输出  ammag

C   输出 g

D   输出 a

    • 怎么让这段代码输出012 （A B）

      int select = 0;

switch (select)

{

case 0: cout<<0;

break;

case 1: cout<<1;

break;

default: cout<<2;

break;

case 2: cout<<3;

break;

}



A 删除第一个break

B 删除第二个break

C 删除default分支

D 删除case1

    • （多选）代码的注释处可以插入的语句有（A B）

      class Alpha {

public: char factor;

Alpha(char value) : factor(value){}; };

int main() {

Alpha a1 = Alpha('a');

Alpha a2 = Alpha('b');

Alpha a3 = Alpha('c');

Alpha *t[] = {&a1, &a2, &a3};

for (Alpha **i = t; t + 2 != i; i++) {

std::cout << *i->factor; } return 0;

 }

}

A、std::cout << (*i)->factor;

B、std::cout << (**i).factor;

C、std::cout << i.factor;

D、std::cout << *i->factor;

    • （单选）以下代码的输出是什么 选 A

      void main(){

char a[20];

std::cin.get(a,5,"d");

cout << a << endl;

}

A.abc

B.abcd

C.abcde

D.abcdef
    c++
    调皮的汽水
    1 声望1 粉丝

    引用和评论

    推荐阅读
    头像
    C++ 中 VS 项目引入公共配置文件

    SHERlocked93赞 1阅读 765

    头像
    Visual Studio Code (VS Code) – C/C++ 入门

    Xi_Xu赞 1阅读 1.3k评论 1

    头像
    AI处理器组合

    灵芸小骏阅读 1.3k

    头像
    想从事嵌入式软件，有推荐的吗？

    良许赞 2阅读 597

    头像
    程序员如何利用周末提升自己

    良许赞 1阅读 582

    头像
    大厂面试必考！C++ 多态底层原理 + 虚函数表，5 分钟看懂！

    小康阅读 874

    头像
    现在纠结于到底是学stm32好还是Arduino好？

    良许阅读 840

    0 条评论
    得票最新