cppquiz系列题目1

记录了cppquiz的题目

Q1

#include <iostream>

template <class T> void f(T &i) { std::cout << 1; }

template <> void f(const int &i) { std::cout << 2; }

int main() {
  int i = 42;
  f(i);
}

输出为 1 .
int类型和const int类型不匹配，第一个函数会生成void f(int &i)，因此走的是第一个函数。

Q2

#include <iostream>
#include <string>

void f(const std::string &) { std::cout << 1; }

void f(const void *) { std::cout << 2; }

int main() {
  f("foo");
  const char *bar = "bar";
  f(bar);
}

输出为 22 .
两个参数都为const char*, 优先匹配第二个函数，因为这是非用户自定义转换。若是要选择const std::string&,需要将char*转为std::string, 这是用户自定义类型转换。另外如果将第二个函数传入参数改为bool，也是优先选择这个函数, 因为指针转bool也是非用户自定义转换。

Q3

#include <iostream>

void f(int) { std::cout << 1; }
void f(unsigned) { std::cout << 2; }

int main() {
  f(-2.5);
}

编译错误 .
double => int 和 double => unsigned都属于浮点型-整型转换(floating-integral conversion)，即都是一个级别的，没有其中一个比另一个好，因此程序是非法的，编译错误。

Q4

#include <iostream>

void f(float) { std::cout << 1; }
void f(double) { std::cout << 2; }

int main() {
  f(2.5);
  f(2.5f);
}

输出21. 默认是double.

Q5

#include <iostream>

struct A {
  A() { std::cout << "A"; }
};
struct B {
  B() { std::cout << "B"; }
};

class C {
public:
  C() : a(), b() {}

private:
  B b;
  A a;
};

int main()
{
    C();
}

输出 BA .
初始化的顺序是由声明时的顺序决定，不是由初始化列表顺序决定。

Q6

#include <iostream>

int main() {
  for (int i = 0; i < 3; i++)
    std::cout << i;
  for (int i = 0; i < 3; ++i)
    std::cout << i;
}

输出 012012 .
没区别

Q7

#include <iostream>

class A {
public:
  void f() { std::cout << "A"; }
};

class B : public A {
public:
  void f() { std::cout << "B"; }
};

void g(A &a) { a.f(); }

int main() {
  B b;
  g(b);
}

输出A.
f()非虚函数，无法实现重载，因此调用的是A::f().

Q8

#include <iostream>

class A {
public:
  virtual void f() { std::cout << "A"; }
};

class B : public A {
public:
  void f() { std::cout << "B"; }
};

void g(A a) { a.f(); }

int main() {
  B b;
  g(b);
}

输出A .
虽然f()是虚函数，但是传入函数 g() 时没有用引用或者指针，无法实现重载。

Q9

#include <iostream>

int f(int &a, int &b) {
  a = 3;
  b = 4;
  return a + b;
}

int main() {
  int a = 1;
  int b = 2;
  int c = f(a, a);
  std::cout << a << b << c;
}

输出428.
传的是引用，a先变成3然后又变成4.

Q11

#include <iostream>

int a;

int main () {
    std::cout << a;
}

输出0.
a存储在静态区，因此既默认初始化为0. 如果为局部非静态变量则不一定。

Q12

#include <iostream>

int main() {
  static int a;
  std::cout << a;
}

输出0.
同上

Q13

#include <iostream>

class A {
public:
  A() { std::cout << "a"; }
  ~A() { std::cout << "A"; }
};

class B {
public:
  B() { std::cout << "b"; }
  ~B() { std::cout << "B"; }
};

class C {
public:
  C() { std::cout << "c"; }
  ~C() { std::cout << "C"; }
};

A a;
int main() {
  C c;
  B b;
}

输出 acbBCA .
构造时顺序是ACB，析构时C和B是按照构造时相反的顺序进行，最后在main函数返回时析构A.

• 本文作者： JiXiaw
• 本文链接： http://jixiaw.github.io/2021/02/05/cppquiz/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！