测验

问题集 1

请学习以下计划，然后回答以下问题。我们希望您通过只看源代码来回答这些问题，也就是说，请不要将其复制到文件中，而是要编译它并在运行后回答问题。这样就会失去所有的乐趣！

int main() {
  int counter, first, last, next;
  first = 1; last = 2;

  for (counter = first; counter <= last; counter++) {
    cout << "\n " << counter;
    next = counter * counter;
    cout << " " << next;
  }

  counter = first;
  while (counter <= last) {
    cout << "\n " << counter;
    next = counter * counter;
    cout << " " << next;
    counter++;
  }

  counter = first;
  do {
    cout << "\n " << counter;
    next = counter * counter;
    cout << " " << next;
    counter++;
  } while (counter < last);
}

问题 1：此程序的输出是什么？

A)	1 2 2.4 1 2 2.4 1 2 2.4
B)	1 1 2.4 1 1 2.4 1 1 2.4
C)	1 1 2.4 1 1 2.4 1 1
D)	1 1 2.4 1 1 1 1 2.4
E)	它不会输出任何内容 - 存在语法错误。

问题 2：如果删除“counter”的初始化，会发生什么情况？

A)	无限循环 - do-while 循环将输出一系列 1 的
B)	程序的输出不会改变
C)	do-while 循环的输出为 2 和 4。
D)	do-while 循环不会输出任何内容
E)	do-while 循环的输出为 3 和 9。

问题 3：假设原始程序位于本页顶部，假设我们有 移除了用于初始化计数器变量的代码行，然后再调用 when 循环。内容 同时移除 while 循环内的 counter++代码行，比如 以下内容？

A)	while 循环不会输出任何内容。
B)	if 循环会输出 1 和 1；do-while 循环不会输出任何内容。
C)	当两行代码都触发时， 包括在内。
D)	系统会输出随机数字，直到我们转动计算机 关闭。
E)	虽然循环是一种无限循环

问题 4：根据此页面顶部的原始程序，会发生什么情况 会怎样呢？

counter = first;
while (counter <= last) {
  cout << "\n" << counter;
  if (first % 2 == 0)
    next = counter * counter;
  cout << "  " << next;
  counter++;
}

A)	if 循环的输出与原始程序中相同。
B)	虽然循环不会输出任何内容
C)	when 循环的输出为 1 1 和 1 4。
D)	when 循环的输出为 1 2 和 2 4。
E)	when 循环的输出为 1 4 和 2 4。
F)	when 循环的输出为 2 4 和 2 4。

问题 5：如果第一个变量大于最后一个变量，会出现什么情况？

A)	虽然循环会输出内容，但其他内容不会。
B)	“dowhile-循环”将输出内容，但其他内容不会输出。
C)	完全不会输出任何内容。
D)	程序将在发生故障或崩溃时
E)	for 循环会输出内容，但其他内容不会。

问题 6：如果初始化第一个变量，程序会输出什么内容 与最后一个变量相同？

A)	“dowhile-循环”将输出内容，但其他内容不会输出。
B)	虽然循环会输出内容，但其他内容不会。
C)	每个循环会输出一行。
D)	do if 循环将输出 2 行，而另一行则会循环。
E)	它不会输出任何内容
F)	for 循环会输出内容，但其他内容不会。

问题集 2

与上个问题集一样，下面是一个程序，供您参考。请只查看源代码，以便回答随后的问题。

#include <iostream>
using namespace std;

int main() {
  int Boys = 3, Girls = 5;
  void F1(int males, int females);
  void F2(int &m, int &f);

  F1(Boys, Girls);
  cout << "\nAfter calling F1, within main()";
  cout << "\n\tBoys = " << Boys; // #2
  cout << "\n\tGirls = " << Girls;

  F2(Boys, Girls);
  cout << "\nAfter calling F2, within main()";
  cout << "\n\tBoys = " << Boys; // #4
  cout << "\n\tGirls = " << Girls;
}

void F1(int b, int g) {
  b += 3, g += 4;
  cout << "\nF1";
  cout << "\n\tBoys = " << b; // #1
  cout << "\n\tGirls = " << g;
}

void F2(int &b, int &g) {
  b = b + 8, g = g + 5;
  cout << "\nF2";
  cout << "\n\tBoys = " << b; // #3
  cout << "\n\tGirls = " << g;
}

问题 1：标记行中的 Boys 变量输出是什么？

A)	#1：6 #2：3 #3：11 #4：11
B)	#1：6 #2：3 #3：11 #4：3
C)	#1：6 #2：6 #3：11 #4：11
D)	它不会输出任何内容，因为它无法编译或运行。

问题 2：选择与计划中以下各行内容相符的所有选项：

void F1(int males, int females);
void F2(int &m, int &f);

A)	C++ 规则声明，只要我们能够移除这两行， 方法在使用前就进行了定义
B)	C++ 规则规定， 声明和定义
C)	如果我们移除这两行代码，此程序将会崩溃。
D)	更常见的做法是，在全局范围内 范围。
E)	这称为前向声明。

问题 3：如果我们将以下代码行从 main() 中移出，并将其放置在全局变量中， 范围，会发生什么情况？

int Boys = 3, Girls = 5;

A)	输出内容还是一样的。
B)	在所有输出中，男生为 3，女孩为 5
C)	在 main() 的输出中，男孩为 3，女孩为 5

问题 4：如果我们将程序的开头更改为以下状态，会怎么样：

// We have moved moved these to global scope
const int Boys = 3;
const int Girls = 5;

void main() {
  //int Boys = 3, Girls = 5;

A)	该程序可以编译，但在尝试运行它时会崩溃。
B)	输出内容不会发生任何变化
C)	整个程序的输出为男孩 = 3 个女孩 = 5 个
D)	仅在 main() 的输出中，“Boys = 3 Girls = 5”才是“Boys = 3 Girls = 5”
E)	程序可能无法编译（具体取决于编译器）。

问题 5：数据按 F2 中的值传递。

A)	正确。
B)	错误。

问题集 3

与上个问题集一样，下面是一个程序，供您参考。请 通过只查看源代码来回答随后的问题。这是 比前两种方法更有趣 - 请仔细跟踪代码。

#include <iostream>
using namespace std;

const int MAX_SIZE = 20;
typedef int ARR2D[MAX_SIZE][MAX_SIZE];

void Print(ARR2D in_array, int rows, int cols);
void Fill(ARR2D in_array, int rows, int cols);

int main() {
  ARR2D matrix;
  int row, col;
  do {
    cout << "Please enter the size of the matrix to generate (rows and cols) :" << endl;
    cin >> row >> col;
  } while (row <= 0 || row > MAX_SIZE || col <= 0 || col > MAX_SIZE);
  Fill(matrix, row, col);
  Print(matrix, row, col);
  return(0);
}

void Print(ARR2D in_array, int rows, int cols) {
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++)
      cout << '\t' << in_array[i][j];
    cout << endl;
  }
}

void Fill(ARR2D in_array, int rows, int cols) {
  for(int i = 0; i < rows; i++)
    for (int j = 0; j < cols; j++)
      in_array[i][j] = 0;

  const int limit = rows * cols;
  int cNum = 1;
  int cRow = 0;
  int cCol = 0;
  int cDir = 0;  // 0-north, 1-east, 2-south, 3-west

  while(true) {
    // Place the number.
    in_array[cRow][cCol] = cNum;
    cNum++;
    if (cNum > limit) break;

    int fRow = cRow;
    int fCol = cCol;
    while (true) {
      fRow = cRow;
      fCol = cCol;
      switch(cDir) {
        case 0: fRow--; break;
        case 1: fCol++; break;
        case 2: fRow++; break;
        case 3: fCol--; break;
      }

      if ( fRow >= 0 && fRow < rows && fCol >= 0 && fCol < cols && in_array[fRow][fCol] == 0)
        break;
      cDir = (cDir + 1) % 4;
    }
    cRow = fRow;
    cCol = fCol;
  }
}

问题 1：当输入为 3（行）和 4（行）时，此程序会输出什么内容 列？

A)	1 2 3 4 5 6 7 8 9 10 11 12
B)	1 2 3 4 5 6 7 8 9 10 11 12
C)	12 11 10 9 8 7 6 5 4 3 2 1
D)	1 3 2 4 8 6 7 5 9 11 10 12
E)	1 2 3 4 10 11 12 5 9 8 7 6
G）	9 8 7 6 10 11 12 5 1 2 3 4
标题	它不会输出任何内容 - 逻辑有问题。
I)	它不会输出任何内容 - 存在语法错误。
J)	它不会输出任何结果，
K）	它会输出您等待程序运行时想到的前 12 个数字。

问题 2：如果将下面这行代码添加到 main() 函数中，会怎样？

MAX_SIZE = 10;

A)	在 C++ 中是不允许的。
B)	这是允许的；程序会在 MAX_SIZE 设置为 20 时运行
C)	这是允许的；程序会在 MAX_SIZE 设置为 10 时运行。

问题 3：考虑上述程序中的以下四行代码：

const int MAX_SIZE = 20;
typedef int ARR2D [MAX_SIZE][MAX_SIZE];

void Print  (ARR2D A, int rows, int cols);
void Fill   (ARR2D A, int rows, int cols);

1) 是否可以在类型定义符中使用常量？
2) 在声明某个类型的变量之前，是否可以在声明中使用该类型定义？

A)	1) 是 2) 是
B)	1) 否 2) 否
C)	1) 否 2) 是
D)	1) 是 2) 否

问题 4：我们能否使用以下内容：

#define MAX_SIZE 20

而不是：

const int MAX_SIZE = 20;

A)	是的，它行得通，可以在 C++
B)	可以，但是我们通常不会对常量使用 #define 使用 C++
C)	C++ 中不支持 #define
D)	您无法在 C 语言环境下执行上述任一操作

问题 5：typedef 用于创建类型名称的别名。

A)	正确。
B)	错误。

问题 6：如果我们没有在 Fill() 函数？

A)	它会运行，但输出将是全部 12 的
B)	它将正常运行，并生成与数组 初始化为 0
C)	程序不会运行或会崩溃
D)	它会运行，但输出结果将全部为 0
E)	它会运行，但可能不会生成任何输出

问题 7：选中所有适用选项。为什么在此程序中对 MAX_SIZE 使用常量？ 直接输入“20”不容易吗？而不是 MAX_SIZE ？

A)	MAX_SIZE 是任何人都可以使用的内置 C++ 值。刚刚设置 并加以使用。
B)	与全局变量一样，应避免使用全局常量
C)	使用常量可使我们的程序更易于理解
D)	程序中的神奇数字通常被认为是一种很好的做法。
E)	如果要更改 MAX_SIZE，只需一次性更改 地点

问题 8： Fill() 函数中的 switch 语句应有一个默认值 因为添加一种样式是不错的选择。

A)	正确。
B)	错误。

问题 9：请注意，在 Fill() 函数中，我们在语句之间声明了变量。 例如，在 for 循环运行后，系统会声明并初始化 cNum 和 cRow。 这适用于 C++，还是所有变量都必须在代码顶部声明 函数呢？

A)	这样做没问题。
B)	所有变量都必须在函数顶部声明。
C)	这两个方面都错误 - C++ 不允许在 计划。
D)	所有变量都必须在全局范围内声明。

问题集 4

以下是一组定义和测试简单类的文件。像往常一样，回答随后的问题仅参考源代码。

头文件 (cow.h) 如下：

#ifndef COW_H
#define COW_H

using namespace std;

typedef enum Color {black, brown, beige, blackandwhite, nocolor};

class Cow {
 public:
  Cow();
  ~Cow();

  // accessors
  double weight() { return weight_; };
  string name() { return name_; };
  Color color() { return color_; };

  // mutators
  void set_name(string inName) { name_ = inName; };
  void set_color(Color inColor) { color_ = inColor; };
  void set_weight(double inWeight) {weight_ = inWeight; };

  void Moo();
  void Properties();

 private:
  Color color_;
  double weight_;
  string name_;
};

#endif

以下是关联的 .cc 文件 (cow.cc)：

#include <iostream>
#include "cow.h"

using namespace std;

Cow::Cow() {}

Cow::~Cow() {}

void Cow::Moo() {
  cout << name() << " says MOO." << endl;
}

void Cow::Properties() {
  cout << name() << " weighs " << weight() << ", is "
       << color() << " and says MOO." << endl;
}

下面是此类的客户端程序 (cowmain.cc)：

#include <iostream>
#include "cow.h"

using namespace std;

int main() {
  Cow cow1;
  cow1.set_name("betsy");
  cow1.set_weight(400.0);
  cow1.set_color(black);

  cow1.Moo();
  cow1.Properties();
}

问题 1：此程序输出什么？

A)	Betsy 说：“MOO”。 betsy 的体重为 400，为 0，并表示“MOO”。
B)	Betsy 说：“MOO”。 CANNOT TRANSLATE
C)	Betsy 说：“MOO”。 betsy 的体重为 400

问题 2：绝不应为访问器和赋值器方法放置代码 放在头文件中（请注意，访问器是指用于返回值的方法， 是修改值的方法。）

A)	正确。
B)	错误。

问题 3：是否需要“牛：”每个函数定义之前 存储在 cow.cc 中？

A)	否 - 因为包含 cow.h
B)	是

问题 4：职责是什么：

#ifndef COW_H
#define COW_H
...
#endif

？

请选择所有适用选项：

A)	这些文件没有任何用途，因为文件名是 cow.h 而不是 COW_H。
B)	如果不执行此操作，将会出现运行时错误
C)	否则，我们可能会多次添加该文件
D)	由于一个或多个关键字拼写错误，因此它们不会执行任何操作。
E)	它们不会执行任何操作，因为 Cow 类只有一个头文件。

问题 5：如果将以下行添加到 cowmain.cc 中，会出现什么情况？

cow1.weight_ = 24;

A)	程序将运行，而权重变量则会修改 按此行添加代码
B)	程序可以编译并运行，但会在该行崩溃。
C)	C++ 不允许这样做。
D)	程序会编译并运行，但权重变量未编译 更改。

问题 6：在执行下面一行代码后，系统会调用 Cow 类中的构造函数：

Cow cow1;

构造函数有哪些重要特征？

请选择所有适用选项

A)	它们通常不会返回任何值
B)	如果我们没有在类中提供构造函数，那么该类 不编译
C)	Cow 类中的构造函数是非典型的，因为它不会初始化 私有变量
D)	它们始终与类具有相同的名称
E)	一个类中可以有多个构造函数，只要 不同
F)	当某个类被实例化时，系统会调用构造函数。

问题 7：析构函数有哪些重要特征？

A)	当对象超出范围时，系统会调用析构函数
B)	析构函数与类具有相同的名称，但以“~”开头
C)	cow.cc 中的析构函数存在问题， 什么都不会执行任何操作。
D)	如果没有为类创建析构函数，该类便不会创建 编译

问题 8：考虑到客户端程序使用类的方式，请考虑使用 以下：

在 Cow 类中将成员划分为公共和私有成员是不合适的。也就是说，某些私有内容应该为公开内容，或者某些内容应该是不公开的内容。

A)	正确。
B)	错误。

问题 9：如果除了 我们只能访问 cow.cc新的构造函数如下所示：

Cow::Cow(string inName, double inWeight, Color inColor) {
  set_name(inName);
  set_weight(inWeight);
  set_color(inColor);
}

并将以下几行代码添加到 main() 中：

Cow cow2("milly", 350.2, brown);
cow2.Moo();
cow2.Properties();

我们可以这样做吗？

请选择所有适用选项

A)	main() 中我们初始化 cow2 的代码行将崩溃。
B)	我们只能有一个构造函数。
C)	这在 C++ 中很常见，
D)	是的，但这不是典型的 C++ 用法
E)	此命令可以运行，但它不会输出任何内容， privates 未初始化。
F)	无法从内部调用 setName()、setColor() 和 setWeight() 是同一个类的一个方法。

奖励问题

问题 1) 以下输出是什么？

#include <iostream>
using namespace std;

void HelpMe(int *p, int *num, int *q);
void WhereAmI(int *p, int *q, int a);

void HelpMe(int *p, int *num, int *q) {
  int a;

  a = 2;
  q = &a;
  *p = *q + *num;
  num = p;
}


void WhereAmI(int *p, int *q, int a) {
  a = 6;
  *p = a + *p;
  *q = a + 3;
  HelpMe(q, &a, p);
}


int main() {
  int *p;
  int q;
  int *num;
  int a;

  a = 3;
  q = 5;
  p = &a;
  num = &q;

  HelpMe(&a, p, num);
  WhereAmI(&q, p, *num);

  cout << "*p = " << *p << " q = " << q << " *num = " << *num << endl;
}
 

问题 2) 假设存在一个 Apple 类并已初始化，请考虑以下陈述。Apple 类具有 color_ 实例变量：

Apple* granny_smith = new Apple; 

请选择以下所有正确表述：

A)	Apple* granny_smith = NULL;if (granny_smith == NULL)...这不好，因为 NULL 不是一个可以通过这种方式检查的值。
B)	Apple* granny_smith、fuji；这会声明两个指向 Apple 对象的指针
C)	granny_smith 变量包含与 Apple 对象关联的实例变量值
D)	Apple* granny_smith = NULL;没关系，
E)	granny_smith 变量包含 Apple 对象的地址
F)	string gs_color = *(granny_smith.get_color());此语句会返回 granny_smith 对象的颜色，并假设该对象已初始化。
G）	新 Apple 对象的存储空间会在堆中分配
标题	新 Apple 对象的存储空间会在运行时堆栈中分配
I)	int* a = &b;这会将 b 的地址放入 a 中。

问题 3) 以下程序的输出是什么？

#include <iostream>
using namespace std;

const int kNumVeggies = 4;

void Grill(int squash, int *mushroom);
int Saute(int onions[], int celery);


void Grill(int squash, int *mushroom) {
  *mushroom = squash/4;
  cout << *mushroom + squash << endl;
}

int Saute(int onions[], int celery) {
  celery *= 2;
  onions[celery]++;
  Grill(onions[0], &onions[3]);
  cout << celery << " " << onions[3] << endl;
  return celery;
}

int main() {
  int broccoli, peppers[kNumVeggies], *zucchini;

  for (broccoli = 0; broccoli < kNumVeggies; broccoli++)
    peppers[broccoli] = kNumVeggies - broccoli;
  zucchini = &peppers[Saute(peppers,1)];
  Grill(*zucchini, zucchini);
  zucchini--;
  cout << peppers[3] + *zucchini + *(zucchini + 1) << endl;
}

知识问答

您应该尝试回答上述所有问题，而不查看答案。最好向他人求助，而不是直接跳到答案表寻求帮助。

您可以点击此处查看上述问题的解答。