测验

第 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：如果我们在 do-while 循环之前移除“counter”的初始化，会发生什么情况？

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

问题 3：根据本页顶部的原始程序，假设我们在 while 循环之前移除了用于初始化计数器变量的代码行。如果我们同时移除 while 循环中的 counter++ 行，会发生什么情况，如下所示？

A)	when 循环不会输出任何内容。
B)	when 循环会输出 1 和 1，而 do-while 循环不会输出任何内容。
C)	when 循环的输出与包含两行时的输出相同。
D)	系统会输出随机数字，直到我们关闭计算机。
E)	when 循环是一种无限循环

问题 4：根据本页顶部的原始程序，如果 while 循环如下所示，会发生什么情况？

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

A)	when 循环的输出与原始程序中的输出相同。
B)	when 循环不会输出任何内容
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)	而 while 循环将输出某些内容，但其他不会输出。
B)	执行 when 循环会输出一些内容，但不会输出任何内容。
C)	不会有任何输出。
D)	程序将细分故障或崩溃
E)	for 循环会输出某些内容，但不会输出任何内容。

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

A)	执行 when 循环会输出一些内容，但不会输出任何内容。
B)	而 while 循环将输出某些内容，但其他不会输出。
C)	每个循环将输出一行。
D)	执行 when 循环将输出 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)	在整个项目中，输出结果为“Boys = 3 Girls = 5”
D)	输出结果为“Boys = 3 Girls = 5”，但仅在来自 main() 的输出
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
H）	它不会输出任何内容，因为逻辑存在问题。
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) 是否可以在 typedef 中使用常量？
2) 在声明某个类型的变量之前，能否在声明中使用 typedef？

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

问题 4：是否可以使用以下指标？

#define MAX_SIZE 20

，而不是：

const int MAX_SIZE = 20;

A)	可以，它可以正常工作，并且可以对 C++ 中的常量使用 #define 属性
B)	可以，不过我们可以用，但我们通常不会对 C++ 中的常量使用 #define
C)	#define 在 C++ 中不可用
D)	您无法在 C 代码中执行上述任一操作

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

A)	正确。
B)	错误。

问题 6：如果未在 Fill() 函数中将数组初始化为 0，会发生什么情况？

A)	它会运行，但输出内容将是所有 12。
B)	它将正常运行，并生成与数组初始化为 0 时相同的输出
C)	程序无法运行或崩溃
D)	它会运行，但输出内容全是 0
E)	它会运行，但可能不会生成任何输出

问题 7：选中所有适用项。为什么在此程序中针对 MAX_SIZE 使用 const？ 在需要的位置只输入“20”而不是 MAX_SIZE 会不会更容易？

A)	MAX_SIZE 是任何人都可以使用的内置 C++ 值。您只需设置并使用它即可。
B)	应该像避免使用全局变量一样，避免使用全局常量
C)	使用 const 可以使我们的程序更易于理解
D)	程序中的魔数通常被视为良好的做法。
E)	如果要更改 MAX_SIZE，只需在一个位置进行更改即可

问题 8：Fill() 函数中的 switch 语句应具有默认 case，因为包含该 case 语句被视为一种很好的样式。

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。 Betsy 体重为 400，黑人，说 MOO。
C)	Betsy 说：MOO。 betsy 的体重为 400，为

问题 2：我们绝不应将访问器和更改器方法的代码放在头文件中。（请注意，访问器是返回值的方法，更改器是修改值的方法。）

A)	正确。
B)	错误。

问题 3：我们是否需要在 cow.cc 中的每个函数定义前面加上“Cow::”？

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)	用于初始化 cow2 的 main() 行会崩溃。
B)	我们只能有一个构造函数。
C)	这在 C++ 中很常见
D)	可以，但这不是典型的 C++ 用法
E)	此命令可以正常执行，但不会输出任何内容，因为私有资源未初始化。
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 对象的存储空间在堆中分配
H）	新 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;
}

测验答案

您应该尝试在不看答案的情况下完成上述所有问题。向他人寻求帮助比直接跳到答案表寻求帮助要好。

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