C++ primer plus学习笔记 --- 第6章、分支语句和逻辑运算符

颖风船

已于 2023-05-06 08:40:15 修改

阅读量210

点赞数

分类专栏： C++ 文章标签： c++ 学习笔记

于 2023-05-05 08:21:43 首次发布

本文链接：https://blog.csdn.net/qq_19432525/article/details/130498642

版权

C++ 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

6.1、if语句

if 语句是 C++ 中最基本的控制流语句之一。其用法如下：

if (condition) {
  // if 条件成立时执行的语句
}

其中 condition 是一个返回 bool 类型的表达式。当 condition 的值为 true 时，if 语句后面的代码块将会被执行；否则，if 语句后面的代码块将被跳过。

以下是一个简单的 if 语句的例子：

#include <iostream>

int main() {
  int x = 10;

  if (x > 5) {
    std::cout << "x is greater than 5" << std::endl;
  }

  return 0;
}

在上面的代码中，定义了变量 x 并将其初始化为 10。if 语句中的条件为 x > 5，因此 if 语句后的代码块被执行，并将 “x is greater than 5” 输出到标准输出流中。

在 if 语句中，如果只有一条语句需要执行，那么可以省略代码块的大括号。例如：

if (x > 5)
  std::cout << "x is greater than 5" << std::endl;

需要注意的是，省略大括号可能会导致代码可读性下降并引起错误，因此建议始终使用大括号。

在 if 语句中，条件表达式可以是任何返回 bool 类型的表达式，包括比较运算、逻辑运算、位运算等。例如：

if (x > 5 && x < 20) {
  std::cout << "x is between 5 and 20" << std::endl;
}

在上面的例子中，使用逻辑运算符 && 判断变量 x 是否同时大于 5 和小于 20，如果成立则执行后面的代码块。如果希望使用或运算，则可以使用 || 运算符。

6.1.1、if else语句

除了单独的 if 语句之外，C++ 中还有一种常见的 if else 语句，其用法如下：

if (condition) {  
  // condition 成立时执行的语句块
} else {
  // condition 不成立时执行的语句块
}

在上面的代码中，当 condition 为 true 时，执行 if 语句后的代码块；如果 condition 为 false，则执行 else 语句后的代码块。

以下是一个 if else 语句的例子，用于判断变量 x 是否为正数：

#include <iostream>

int main() {
  int x = -1;

  if (x > 0) {
    std::cout << "x is positive" << std::endl;
  } else {
    std::cout << "x is not positive" << std::endl;
  }

  return 0;
}

在上面的代码中，定义变量 x 并将其初始化为 -1。通过 if else 语句，判断 x 是否为正数。由于 x 的值小于等于 0，因此执行 else 语句后的代码块，并输出 “x is not positive” 到标准输出流中。

需要注意的是，在 if else 语句中，当条件 condition 成立时，只会执行 if 语句后的代码块，而不会执行 else 语句后的代码块。如果希望执行完 if 语句后，再执行 else 语句后的代码块，则可以使用两个独立的 if 语句，例如：

if (condition1) {
  // condition1 成立时执行的代码块
}
if (condition2) {
  // condition2 成立时执行的代码块
}

在上面的代码中，无论 condition1 是否成立，都会执行第一个 if 语句后的代码块；然后，如果 condition2 也成立，则会执行第二个 if 语句后的代码块。

6.1.2、格式化if else 语句

格式化 if else 语句可以使代码易于阅读和维护。以下是一些常见的格式化 if else 语句的技巧：

在 if 和 else 关键字后面加上空格。
将左括号紧贴着 if 和 else 关键字。
在每个代码块前面使用缩进，以使结构清晰、易于阅读。
对于 if 后面和 else 后面的代码块，使用花括号（大括号）括起来，即使代码块只有一条语句。

以下是一个格式化良好的 if else 语句的例子，用于判断一个整数是否为偶数：

#include <iostream>

int main() {
  int x = 5;

  if (x % 2 == 0) {
    std::cout << "x is even" << std::endl;
  } else {
    std::cout << "x is odd" << std::endl;
  }

  return 0;
}

在上面的代码中，if else 语句使用了缩进，使其结构变得清晰易读。每个代码块都被编写成了多行，并使用了花括号括起来以使代码清晰易懂。

需要注意的是，if else 语句的格式化方式可能因团队或个人的代码风格而异。重要的是让代码保持一致性，以方便团队成员阅读和维护代码。

6.1.3、if else if else 结构

在需要进行多条件判断时，可以使用 if else if else 结构。其语法如下：

if (condition1) {
  // condition1 成立时执行的语句块
} else if (condition2) {
  // condition1 不成立，condition2 成立时执行的语句块
} else if (condition3) {
  // condition1 和 condition2 都不成立，condition3 成立时执行的语句块
} else {
  // condition1, condition2 和 condition3 都不成立时执行的语句块
}

在上面的代码中，条件 condition1 为第一个条件，如果成立就执行 if 语句后的代码块。如果 condition1 不成立，就会接着判断 condition2，如果 condition2 成立，则会执行 else if 语句后的代码块，以此类推。如果所有条件都不成立，则执行 else 语句后的代码块。

以下是一个使用 if else if else 结构的示例，用于判断一个数字的正负性和零：

#include <iostream>

int main() {
  int x = 0;

  if (x > 0) {
    std::cout << "x is positive" << std::endl;
  } else if (x == 0) {
    std::cout << "x is zero" << std::endl;
  } else {
    std::cout << "x is negative" << std::endl;
  }

  return 0;
}

在上面的代码中，使用 if else if else 结构，依次判断 x 是否为正数、是否为零，以及是否为负数，并输出不同的文本信息。

需要注意的是，在 if else if else 结构中，每个条件都有可能被执行，如果一个条件被满足，则后面的条件将不再被判断，因此需要保证条件的顺序合理。

6.2、逻辑表达式

逻辑表达式是指可以返回 true 或 false 的表达式，它通常由以下逻辑运算符和比较运算符构成：

逻辑非运算符（!）：将表达式取反，如果表达式为真，则逻辑非运算符返回假，反之亦然。
逻辑与运算符（&&）：当两个表达式都为真时返回真，否则返回假。
逻辑或运算符（||）：当至少一个表达式为真时返回真，否则返回假。
相等运算符（==）：当两个操作数相等时返回真，否则返回假。
不等运算符（!=）：当两个操作数不相等时返回真，否则返回假。
大于运算符（>）：当左操作数大于右操作数时返回真，否则返回假。
大于等于运算符（>=）：当左操作数大于等于右操作数时返回真，否则返回假。
小于运算符（<）：当左操作数小于右操作数时返回真，否则返回假。
小于等于运算符（<=）：当左操作数小于等于右操作数时返回真，否则返回假。

以下是一个简单的逻辑表达式的例子：

#include <iostream>

int main() {
  int x = 5, y = 7;

  bool result1 = x < y;              // true，x 小于 y
  bool result2 = !result1;           // false，result1 的逻辑非
  bool result3 = x == y || x < y;    // true，x 等于 y 或者 x 小于 y

  std::cout << result1 << std::endl;
  std::cout << result2 << std::endl;
  std::cout << result3 << std::endl;

  return 0;
}

在上面的代码中，定义了两个整数变量 x 和 y，并使用逻辑运算符和比较运算符构建了几个逻辑表达式。这些表达式的结果存储在布尔变量 result1、result2 和 result3 中，并输出到标准输出流中。

需要注意的是，C++ 中的逻辑运算符和比较运算符可以结合使用，以构建更复杂的逻辑表达式。在构建复杂表达式时，优先级和结合性非常重要，需要使用小括号来明确运算的顺序。

6.2.1、逻辑运算符OR:||

逻辑运算符 OR（||）表示逻辑或，用于将逻辑表达式连接为一个新的逻辑表达式。它返回左右两个操作数中任意一个为 true 时结果为 true，否则结果为 false。

以下是一个使用逻辑运算符 OR 的示例，用于判断一个数字是否为正数或偶数：

#include <iostream>

int main() {
  int x = -2;

  if (x > 0 || x % 2 == 0) {
    std::cout << "x is positive or even" << std::endl;
  } else {
    std::cout << "x is negative and odd" << std::endl;
  }

  return 0;
}

在上面的代码中，使用逻辑运算符 OR 连接了两个逻辑表达式，判断 x 是否为正数或偶数。由于 x 的值为 -2，不是正数，但是是偶数，因此这个逻辑表达式返回 true，执行 if 语句后的代码块，输出 “x is positive or even”。

如果两个表达式都返回 false，那么逻辑表达式就会返回 false，执行 else 语句后的代码块。因此，在使用逻辑运算符 OR 时，请确保它们能够涵盖所有情况。

6.2.2、逻辑运算符AND:&&

逻辑运算符 AND（&&）表示逻辑与，用于将逻辑表达式连接为一个新的逻辑表达式。它返回左右两个操作数都为 true 时结果为 true，否则结果为 false。

以下是一个使用逻辑运算符 AND 的示例，用于判断一个数字是否为正偶数：

#include <iostream>

int main() {
  int x = 6;

  if (x > 0 && x % 2 == 0) {
    std::cout << "x is a positive even number" << std::endl;
  } else {
    std::cout << "x is not a positive even number" << std::endl;
  }

  return 0;
}

在上面的代码中，我们使用逻辑运算符 AND 连接了两个逻辑表达式，分别判断 x 是否为正数和偶数，只有当这两个表达式的结果都为 true 时，才会执行 if 语句后的代码块，输出 “x is a positive even number”。因为 x 的值为 6，既是正数也是偶数，所以这个逻辑表达式返回 true。

需要注意的是，使用逻辑运算符 AND 时，如果左操作数为 false，右操作数就不会被计算，因为无论右操作数的值是什么，整个逻辑表达式的结果都必定为 false。这种行为被称为短路逻辑，它可以提高程序效率。

6.2.3、用&&来设置NOT运算符

在某些情况下，可以使用逻辑运算符 AND（&&）和逻辑非运算符（!）来设置逻辑非表达式，例如：

if (!(x > 0)) {
  std::cout << "x is not positive" << std::endl;
}

在上面的代码中，我们使用逻辑非运算符将 (x > 0) 的结果取反，表示 x 不是正数，如果表达式的结果为 true，就会执行 if 语句后的代码块，输出 “x is not positive”。

这种写法可能不够直观，但是可以在代码中减少逻辑非运算符的使用，使得代码更容易理解。

6.2.4、逻辑NOT运算符：！

逻辑非运算符（!）表示逻辑非，用于将一个逻辑表达式取反。如果表达式的结果为真，则逻辑非运算符返回假，反之亦然。例如：

bool b = false;

if (!b) {
  std::cout << "b is true" << std::endl;
}

在上面的代码中，定义了一个布尔变量 b 并将其赋值为 false。在 if 语句中，使用逻辑非运算符对 b 取反，因为 b 的值为 false，所以逻辑非运算符返回 true，执行 if 语句后的代码块，输出 “b is true”。

另外，需要注意的是，在使用逻辑非运算符时，应该格外注意优先级和结合性，否则可能会导致逻辑错误。通常，建议使用小括号来明确运算的顺序，例如：

if (!(x > y)) {
  std::cout << "x is not greater than y" << std::endl;
}

在上面的代码中，使用小括号明确了 x > y 的运算顺序，并将其取反，表示 x 不大于 y。如果省略小括号，则会先计算逻辑非运算符，导致结果与预期不符。

6.2.5、逻辑运算符细节

优先级：逻辑非运算符优先级最高，其次是逻辑与运算符，最后是逻辑或运算符。但是，建议使用小括号明确运算优先级，减少出错的概率。
结合性：逻辑与和逻辑或运算符都具有短路结合性，而逻辑非运算符没有。具体来说，当使用逻辑与运算符时，只有所有的操作数都为 true 才会返回 true，并且当任何一个操作数为 false 时就会停止计算，因为后面的操作数不影响结果了。而当使用逻辑或运算符时，只要有任何一个操作数为 true 就会返回 true，并且当任何一个操作数为 true 时也会停止计算，因为后面的操作数不影响结果了。逻辑非运算符则没有结合性，只翻转操作数的值。
精度问题：逻辑运算符只针对布尔类型的操作数进行计算，不会转换其他数据类型。如果需要对其他数据类型进行逻辑运算，需要先将其转换为布尔类型。通常情况下，非零值会被视为 true，零值会被视为 false。

6.2.6、其他表达方式

在 C++ 中，逻辑运算符可以与赋值运算符（=）结合使用，形成复合运算符。

例如，逻辑与运算符和赋值运算符结合，形成 &= 运算符，逻辑或运算符和赋值运算符结合，形成 |= 运算符。这些复合运算符可以简化一些表达式的书写，提高代码可读性和效率。

以下是一个使用复合运算符的示例，用于统计一个数字的二进制表示中的 1 的个数：

#include <iostream>

int main() {
  int count = 0;
  int x = 12;

  while (x != 0) {
    count += x & 1; // 统计最后一位是否为 1
    x >>= 1; // 将最后一位删掉
  }

  std::cout << "The binary representation of 12 has " << count << " 1's" << std::endl;

  return 0;
}

在上面的代码中，我们使用逻辑与运算符和赋值运算符结合，将 count += x & 1; 简化为 count &= 1;，表示将 count 和 x & 1 的结果进行逻辑与运算并赋值给 count，这个表达式的作用是统计一个数字的二进制表示中最后一位是否为 1。

6.3、字符函数库cctype

字符函数库 cctype 是 C++ 标准库中专门用于处理字符的库，包含了一组关于字符分类（如大小写、字母、数字等）、转换和映射的函数。头文件为 <cctype>。

在 cctype 库中，所有函数都以 is 或 to 为前缀，表示是字符类型判断还是字符转换函数。主要的函数有以下几种类型：

字符类型判断函数：用于确定一个字符是否属于某个字符类型，返回 bool 类型的值。函数名以 is 开头，例如 isalpha、isdigit。
字符转换函数：用于将一个字符转换为指定的大小写、数字、字符类型等等。函数名以 to 开头，例如 tolower、toupper。
其他函数：包含一些与字符处理相关的杂项函数，如 isspace（判断是否为空白字符）、ispunct（判断是否是标点符号）等等。

这些函数的用法与具体示例可以在 C++ 标准库文档中查阅。使用字符函数库可以方便地对字符进行操作，提高字符处理的效率。

6.4、?:运算符

?: 运算符也称为三目运算符，它是 C++ 中唯一的具有三个操作数的运算符。它的一般形式如下：

(condition) ? expression1 : expression2;

其中，condition 是一个布尔表达式（也可以是任何返回布尔值的表达式），expression1 和 expression2 是两个可能的表达式，用于根据 condition 的结果选择执行哪一个。

如果 condition 的结果为 true，则执行 expression1，否则执行 expression2。expression1 和 expression2 必须具有相同的类型，结果将取决于所选表达式的类型。

下面是一个使用 ?: 运算符的示例，判断一个数是否是正数：

#include <iostream>

int main() {
  int x = -5;
  std::string result = (x > 0) ? "positive" : "non-positive";
  std::cout << x << " is " << result << std::endl;

  return 0;
}

在上面的代码中，我们使用 ?: 运算符判断 x 是否是正数。如果 x > 0 的结果为 true，则执行 (x > 0) ? "positive" : "non-positive"，即将 “positive” 赋值给 result。否则执行 (x > 0) ? "positive" : "non-positive"，即将 “non-positive” 赋值给 result。最后输出 x 和 result 的值。

6.5、switch语句

switch 语句是 C++ 中用于多分支判断的一种结构化语句，可以根据一个表达式的值来选择不同的分支执行。switch 语句的一般形式如下：

switch (expression) {
  case value1:
    // 执行语句1
    break;
  case value2:
    // 执行语句2
    break;
  case value3:
    // 执行语句3
    break;
  // ...
  default:
    // 执行默认语句
    break;
}

其中，expression 是一个表达式，它的值将会被和每一个 case 语句后面的 value 进行比较，如果相等，则执行该 case 语句后的语句，直到遇到一个 break 语句或者整个 switch 语句结束为止。如果所有的 case 语句都不满足，就会执行 default 语句。

break 语句用于跳出 switch 语句，避免执行后面的语句。default 语句是可选的，当所有 case 都不满足时才会执行它。

下面是一个使用 switch 语句的示例，根据星期几输出对应的工作日：

#include <iostream>

int main() {
  int day = 3;
  
  switch (day) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      std::cout << "It's a workday" << std::endl;
      break;
    case 6:
    case 7:
      std::cout << "It's a weekend" << std::endl;
      break;
    default:
      std::cout << "Invalid day" << std::endl;
      break;
  }
  
  return 0;
}

在上面的代码中，我们使用 switch 语句根据星期几输出对应的工作日。当 day 的值为 1 到 5 时，会执行 case 1 到 case 5 后面的语句，输出 “It’s a workday”。当 day 的值为 6 或 7 时，会执行 case 6 或 case 7 后面的语句，输出 “It’s a weekend”。如果 day 的值不在 1 到 7 之间，就会执行 default 后面的语句，输出 “Invalid day”。

6.5.1、将枚举量用作标签

在 switch 语句中，我们还可以使用枚举类型的值作为标签，来实现多分支判断。在这种情况下，每个枚举常量对应于一个标签，也可以使用 default 标签来处理不属于任何枚举常量的值。

下面是一个示例，使用枚举类型的值作为标签：

#include <iostream>

enum DayOfWeek { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };

int main() {
  DayOfWeek day = Wednesday;

  switch (day) {
    case Monday:
    case Tuesday:
    case Wednesday:
    case Thursday:
    case Friday:
      std::cout << "It's a workday" << std::endl;
      break;
    case Saturday:
    case Sunday:
      std::cout << "It's a weekend" << std::endl;
      break;
    default:
      std::cout << "Invalid day" << std::endl;
      break;
  }

  return 0;
}

在上面的代码中，我们使用枚举类型 DayOfWeek 定义七个常量，分别对应于每个星期几。在 switch 语句中，将 day 的值与各个常量进行比较，根据不同的常量输出不同的内容。

6.5.2、switch和if else语句

在处理多分支判断时，switch 语句可以与 if else 语句互相替换，但它们有一些不同的特性：

switch 语句只能用于整数类型的值或者枚举类型的值，而 if else 语句可以用于任何布尔类型的表达式；
switch 语句中的标签需要是常量表达式，不能是变量或者运行时计算的表达式，而 if else 语句中没有这个限制；
switch 语句会根据标签值跳转到对应的分支执行，因此执行效率较高，而 if else 语句需要逐个比较条件，效率相对较低。

由于 switch 语句和 if else 语句在使用上有一些差异，因此在实际编程中需要灵活选择并合理使用它们。

下面是一个使用 if else 语句的示例，根据星期几输出对应的工作日：

#include <iostream>

int main() {
  int day = 3;

  if (day >= 1 && day <= 5) {
    std::cout << "It's a workday" << std::endl;
  }
  else if (day == 6 || day == 7) {
    std::cout << "It's a weekend" << std::endl;
  }
  else {
    std::cout << "Invalid day" << std::endl;
  }

  return 0;
}

在上面的代码中，我们使用 if else 语句根据星期几输出对应的工作日。如果 day 的值在 1 到 5 之间，则输出 “It’s a workday”；如果 day 的值是 6 或 7，则输出 “It’s a weekend”；否则就输出 “Invalid day”。

6.6、break和continue语句

在 C++ 中，break 和 continue 语句用于控制程序执行流程。

break 语句用于跳出循环或 switch 语句，即在循环或 switch 语句内部执行 break 后，程序会直接跳出到循环或 switch 语句的外部继续执行后面的代码。

下面是一个使用 break 语句跳出循环的示例：

#include <iostream>

int main() {
  for (int i = 0; i < 10; i++) {
    std::cout << i << std::endl;
    if (i == 5) {
      break;
    }
  }

  std::cout << "End" << std::endl;

  return 0;
}

在上面的代码中，我们使用 for 循环输出 0~9 的数值，并在 i 的值等于 5 时使用 break 跳出循环。当 i 的值为 0~5 时，会输出对应的值。当 i 的值等于 5 时，执行 break 后跳出循环。最后输出 “End”。

continue 语句用于结束当前的迭代，即在循环体内执行 continue 后，程序会直接跳到循环头继续执行下一次循环。

下面是一个使用 continue 语句结束当前迭代的示例：

#include <iostream>

int main() {
  for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
      continue;
    }
    std::cout << i << std::endl;
  }

  return 0;
}

在上面的代码中，我们使用 for 循环输出 1~9 的奇数，并在 i 的值为偶数时使用 continue 结束当前迭代。当 i 的值为奇数时，会输出对应的值。当 i 的值为偶数时，执行 continue 后直接跳到循环头继续执行下一次循环。

6.7、读取数字的循环

在 C++ 中，我们可以使用 while 或 do while 循环来读取数字。通常情况下，我们需要检查输入是否合法，以确保程序不会因为非法输入而崩溃或者进入无限循环。

下面是一个使用 while 循环读取数字的示例：

#include <iostream>

int main() {
  int x;

  while (true) {
    std::cout << "Please enter a number: ";
    if (std::cin >> x) {
      std::cout << "You entered: " << x << std::endl;
      break;
    } else {
      std::cout << "Invalid input, please try again." << std::endl;
      std::cin.clear();
      std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
  }

  return 0;
}

在上面的代码中，我们使用 while 循环读取用户输入的数字，如果输入合法，则输出该数字并跳出循环；如果输入非法，则输出错误信息并继续循环。在读取非法输入后，我们使用 cin.clear() 清空输入流的状态，然后使用 cin.ignore() 忽略不合法的输入，以防错误的输入影响下一轮读取。

下面是一个使用 do while 循环读取数字的示例：

#include <iostream>

int main() {
  int x;

  do {
    std::cout << "Please enter a number: ";
    if (std::cin >> x) {
      std::cout << "You entered: " << x << std::endl;
      break;
    } else {
      std::cout << "Invalid input, please try again." << std::endl;
      std::cin.clear();
      std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
  } while (true);

  return 0;
}

在上面的代码中，我们使用 do while 循环来读取用户输入的数字，如果输入合法，则输出该数字并跳出循环；如果输入非法，则输出错误信息并继续循环。这里的 do while 循环与 while 循环的区别在于，do while 循环至少会执行一次循环体，因此可以保证用户至少会输入一次。

6.8、简单文件输入/输出

在 C++ 中，我们可以使用 fstream 头文件提供的函数来进行简单的文件读取和写入操作。其中，ofstream 类用于写入文件，ifstream 类用于读取文件，fstream 类则同时具有读取和写入文件的能力。

下面是一个使用 ofstream 将数据写入文件的示例：

#include <iostream>
#include <fstream>

int main() {
  std::ofstream outfile("example.txt");

  if (outfile.is_open()) {
    outfile << "Hello, world!" << std::endl;
    outfile << "My favorite number is " << 42 << "." << std::endl;
    outfile.close();
    std::cout << "Data was written to the file." << std::endl;
  } else {
    std::cout << "Unable to open the file!" << std::endl;
    return 1;
  }

  return 0;
}

在上面的代码中，我们使用 ofstream 将数据写入名为 example.txt 的文件中。首先打开文件并判断是否成功打开，然后使用 << 运算符将字符和数字写入文件，将输出流关闭并输出 “Data was written to the file.”。

下面是一个使用 ifstream 读取文件的示例：

#include <iostream>
#include <fstream>
#include <string>

int main() {
  std::ifstream infile("example.txt");
  std::string line;

  if (infile.is_open()) {
    while (getline(infile, line)) {
      std::cout << line << std::endl;
    }
    infile.close();
    std::cout << "Data was read from the file." << std::endl;
  } else {
    std::cout << "Unable to open the file!" << std::endl;
    return 1;
  }

  return 0;
}

在上面的代码中，我们使用 ifstream 从名为 example.txt 的文件中读取数据。首先打开文件并判断是否成功打开，然后使用 getline 函数逐行读取文本内容并输出，最后关闭文件并输出 “Data was read from the file.”。需要注意的是，getline 函数返回的字符串不包含行结束符，因此在输出时要手动添加。

6.8.1、文本I/O和文本文件

在 C++ 中，我们可以使用流（stream）对象进行文本输入/输出（text I/O）操作。流是 C++ 标准库中的一个重要概念，它可以把数据源和数据目标包装成一个可操作的对象，使得输入/输出操作更加方便和统一。

文本文件通常包含纯文本，数据以字符的形式存储。我们可以使用流对象来进行文本文件的读取和写入操作。在涉及文件操作时，必须要确保文件打开成功，否则操作会失败。在文件操作完成后，需要关闭文件以释放资源。

下面是一个使用 fstream 头文件进行文本文件读写的示例：

#include <fstream>
#include <iostream>
#include <string>

using namespace std;

int main() {
  // 打开文本文件
  ifstream infile("input.txt");
  ofstream outfile("output.txt");

  // 判断文件是否打开成功
  if (!infile.is_open() || !outfile.is_open()) {
    cout << "Failed to open file!" << endl;
    return 1;
  }

  // 读取文件内容并写入到另一个文件中
  string line;
  while (getline(infile, line)) {
    outfile << line << endl;
  }

  // 关闭文件
  infile.close();
  outfile.close();
  cout << "File operation completed successfully." << endl;

  return 0;
}

在上面的代码中，我们打开文件 input.txt 和 output.txt，通过 getline 函数逐行读取 input.txt 文件中的内容，并将每一行内容写入到 output.txt 文件中。在文件操作完成后，我们使用 close 函数关闭文件。

需要注意的是，C++ 中的文件 I/O 操作和 UNIX 系统中的文件 I/O 操作有一定的差异。在 UNIX 系统中，每个文件都被看作是一个字节流（byte stream），而在 C++ 标准库中，文件被看作是一系列字符（character）。因此，在 C++ 中，我们需要使用 fstream 类型的对象来进行文本输入/输出操作。

6.8.2、写入到文本文件中

在 C++ 中，我们可以使用 ofstream 类型的对象向文本文件写入数据。在使用 ofstream 向文件写入数据时，我们需要先打开文件，然后将数据写入文件，最后关闭文件。

下面是一个将数据写入到文本文件中的示例代码：

#include <fstream>
#include <iostream>

using namespace std;

int main() {
  // 创建并打开文本文件
  ofstream outfile("example.txt");

  // 判断文件是否打开成功
  if (!outfile.is_open()) {
    cout << "Failed to open file!" << endl;
    return 1;
  }

  // 向文件中写入数据
  outfile << "Hello, world!" << endl;
  outfile << "This is a sample text file." << endl;
  outfile << "Here is some more data." << endl;

  // 关闭文件
  outfile.close();

  cout << "Data has been written to the file." << endl;

  return 0;
}

在上面的示例代码中，我们创建一个名为 example.txt 的文本文件，并将三行文本数据写入到文件中。在文件写入完成后，我们使用 close 函数关闭文件。

需要注意的是，在进行文件 I/O 操作时，我们需要确保文件能够被成功打开。如果打开失败，我们需要返回错误信息并退出程序。此外，我们还应该在每次操作结束后及时关闭文件，以释放资源。

6.8.3、读取文本文件

在 C++ 中，我们可以使用 ifstream 类型的对象从文本文件中读取数据。在使用 ifstream 读取文件时，我们需要先打开文件，然后使用 getline 函数逐行读取文件内容，最后关闭文件。

下面是一个从文本文件中读取数据的示例代码：

#include <fstream>
#include <iostream>
#include <string>

using namespace std;

int main() {
  // 打开文本文件
  ifstream infile("example.txt");

  // 判断文件是否打开成功
  if (!infile.is_open()) {
    cout << "Failed to open file!" << endl;
    return 1;
  }

  // 读取文件内容
  string line;
  while (getline(infile, line)) {
    cout << line << endl;
  }

  // 关闭文件
  infile.close();

  cout << "Data has been read from the file." << endl;

  return 0;
}

在上面的示例代码中，我们打开名为 example.txt 的文本文件，并使用 getline 逐行读取文件内容并输出到控制台上。在读取操作完成后，我们使用 close 函数关闭文件。

需要注意的是，在每次操作结束后及时关闭文件，以释放资源。如果文件打开失败，我们需要返回错误信息并退出程序。在读取文件时，我们可以使用 getline 函数逐行读取文本文件的内容，或者使用 >> 运算符逐个读取不包含空格的单词。如果要读取包含空格的单词或一整行的文本，建议使用 getline 函数。

颖风船

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ primer plus学习笔记 --- 第6章、分支语句和逻辑运算符

if 语句是 C++ 中最基本的控制流语句之一。其中condition是一个返回 bool 类型的表达式。当condition的值为 true 时，if 语句后面的代码块将会被执行；否则，if 语句后面的代码块将被跳过。在上面的代码中，定义了变量x并将其初始化为 10。if 语句中的条件为x > 5，因此 if 语句后的代码块被执行，并将 “x is greater than 5” 输出到标准输出流中。在 if 语句中，如果只有一条语句需要执行，那么可以省略代码块的大括号。
复制链接

扫一扫