教程标签: Cplus小白

👏🏻 你好！欢迎访问IT教程网，0门教程，教程全部原创，计算机教程大全，全免费！

🔥 新增教程

2024-08-10发表2024-08-24更新编程 / Cplus小白5 分钟读完 (大约812个字)

C++完整教程

在之前的内容中，我们学习了 常量 和 变量。常量是不可变的值，而变量则是可以改变的存储位置。接下来，我们将讨论 算术运算符，它们用于进行基本的数学运算，包括加法、减法、乘法、除法和取模。这些运算符在 C++ 编程中是基础且常用的。

算术运算符概述

C++ 提供了以下基本的算术运算符：

运算符	描述	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`
`%`	取模（求余）	`a % b`

在讲解运算符时，我们将使用具体的代码示例来演示其工作原理。

加法运算符 `+`

在 C++ 中，加法运算符 + 用于将两个操作数相加。以下是一个简单的示例代码：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int b = 5;
    int sum = a + b; // 使用加法运算符
    cout << "加法结果: " << sum << endl;
    return 0;
}

运行上面的程序，将输出：

加法结果: 15

减法运算符 `-`

减法运算符 - 用于计算两个数的差。以下是示例代码：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int b = 5;
    int difference = a - b; // 使用减法运算符
    cout << "减法结果: " << difference << endl;
    return 0;
}

输出结果将是：

减法结果: 5

乘法运算符 `*`

乘法运算符 * 用于计算两个数的乘积。示例代码如下：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int b = 5;
    int product = a * b; // 使用乘法运算符
    cout << "乘法结果: " << product << endl;
    return 0;
}

输出结果为：

乘法结果: 50

除法运算符 `/`

除法运算符 / 用于计算两个数的商。需要注意的是，若两个操作数都是 整数，则结果将会是 整数，而小数部分将会被截断。参考以下示例：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int b = 4;
    int quotient = a / b; // 使用除法运算符
    cout << "除法结果: " << quotient << endl;
    return 0;
}

输出结果为：

除法结果: 2

浮点数除法

为了获得更精确的结果，可以使用浮点数。例如：

#include <iostream>
using namespace std;

int main() {
    double a = 10.0;
    double b = 4.0;
    double quotient = a / b; // 使用浮点数进行除法
    cout << "浮点数除法结果: " << quotient << endl;
    return 0;
}

将输出：

1	浮点数除法结果: 2.5

取模运算符 `%`

取模运算符 % 用于计算两个数相除的余数。例如：

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int b = 3;
    int remainder = a % b; // 使用取模运算符
    cout << "取模结果: " << remainder << endl;
    return 0;
}

输出结果为：

取模结果: 1

总结

在本节中，我们学习了 C++ 中的 算术运算符：加法、减法、乘法、除法 和 取模。它们都是基本的数学操作，任何程序员在编写程序时都需要熟练掌握。随着对 C++ 的深入学习，您将会运用这些运算符处理更复杂的数据和逻辑。

在下一篇中，我们将继续学习 关系运算符，这将帮助我们比较不同的值并进行条件判断。希望您保持关注！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白7 分钟读完 (大约995个字)

14 运算符之关系运算符

C++完整教程

在上一篇中，我们学习了运算符之算术运算符，这些运算符帮助我们进行基本的数学计算。而今天，我们将深入探讨“关系运算符”。关系运算符用于比较两个值，并返回一个布尔值（true 或 false）。这对于控制程序的流动非常重要，特别是在条件语句和循环中。

何为关系运算符

关系运算符主要用于比较值的大小或相等性。C++中常用的关系运算符包括：

==：等于
!=：不等于
>：大于
<：小于
>=：大于等于
<=：小于等于

1. 等于运算符 `==`

==运算符用于判断两个值是否相等。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int a = 5;
    int b = 5;
    if (a == b) {
        cout << "a 和 b 相等。" << endl; // 输出：a 和 b 相等。
    }
    return 0;
}

在上述代码中，a 和 b 相等，因此输出了相应的信息。

2. 不等于运算符 `!=`

!=运算符用于判断两个值是否不相等。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int x = 10;
    int y = 20;
    if (x != y) {
        cout << "x 和 y 不相等。" << endl; // 输出：x 和 y 不相等。
    }
    return 0;
}

在此示例中，x 与 y 不相等，因此条件为真，代码正常执行。

3. 大于运算符 `>`

>运算符用于判断左侧的值是否大于右侧的值。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int m = 15;
    int n = 10;
    if (m > n) {
        cout << "m 大于 n。" << endl; // 输出：m 大于 n。
    }
    return 0;
}

这里，m 确实大于 n，条件判断为真。

4. 小于运算符 `<`

<运算符用于判断左侧的值是否小于右侧的值。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int p = 5;
    int q = 20;
    if (p < q) {
        cout << "p 小于 q。" << endl; // 输出：p 小于 q。
    }
    return 0;
}

在这个示例中，p 小于 q，因此输出了对应的结果。

5. 大于等于运算符 `>=`

>=运算符用于判断左侧的值是否大于或等于右侧的值。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int a = 25;
    int b = 25;
    if (a >= b) {
        cout << "a 大于或等于 b。" << endl; // 输出：a 大于或等于 b。
    }
    return 0;
}

此例中，由于 a 与 b 相等，条件仍然成立。

6. 小于等于运算符 `<=`

<=运算符用于判断左侧的值是否小于或等于右侧的值。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int x = 15;
    int y = 30;
    if (x <= y) {
        cout << "x 小于或等于 y。" << endl; // 输出：x 小于或等于 y。
    }
    return 0;
}

在这个例子中，x 小于 y，条件同样成立。

关系运算符的应用

关系运算符不仅用于单独的比较，还可与条件语句结合使用，以控制程序的执行流程。比如，与 if 语句结合，可以根据条件的判断来决定是否执行某段代码。

示例：综合运用关系运算符

#include <iostream>
using namespace std;

int main() {
    int age;
    cout << "请输入您的年龄：";
    cin >> age;

    if (age < 18) {
        cout << "您是未成年人。" << endl;
    } else if (age >= 18 && age < 65) {
        cout << "您是成年人。" << endl;
    } else {
        cout << "您是老年人。" << endl;
    }
    
    return 0;
}

在这个例子中，根据输入的年龄，程序会判断并输出相应的年龄段。

总结

本篇教程中，我们学习了C++中的关系运算符，通过多个示例具体了解了每个运算符的功能及其用法。掌握这些运算符是理解控制结构的重要基础，特别是在条件判断时。

在下一篇中，我们将继续探索“运算符之逻辑运算符”，通过学习逻辑运算符来更加灵活地控制程序的流进展。

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约859个字)

15 运算符之逻辑运算符

C++完整教程

在C++中，逻辑运算符用于处理布尔值（即 true 和 false），常用于控制程序流以及条件判断。这一篇教程将专注于C++中的逻辑运算符，帮助初学者理解其用法。

逻辑运算符概述

C++中的逻辑运算符主要有三种，分别是：

逻辑与（&&）
逻辑或（||）
逻辑非（!）

逻辑与（`&&`）

&& 运算符用于判断两个条件是否同时为真。只有在两个操作数都为 true 时，结果才为 true，否则为 false。

示例

#include <iostream>
using namespace std;

int main() {
    bool a = true;
    bool b = false;

    if (a && b) {
        cout << "条件都为真" << endl;
    } else {
        cout << "至少有一个条件为假" << endl;
    }
    return 0;
}

在上述代码中，由于 b 为 false，所以输出将是“至少有一个条件为假”。

逻辑或（`||`）

|| 运算符用于判断至少一个条件是否为真。只要其中一个操作数为 true，结果就是 true。只有当两个操作数均为 false 时，结果才为 false。

示例

#include <iostream>
using namespace std;

int main() {
    bool a = true;
    bool b = false;

    if (a || b) {
        cout << "至少有一个条件为真" << endl;
    } else {
        cout << "两个条件都为假" << endl;
    }
    return 0;
}

在这段代码中，由于 a 为 true，所以输出将是“至少有一个条件为真”。

逻辑非（`!`）

! 运算符用于反转一个布尔值。若操作数为 true，则结果为 false；若操作数为 false，则结果为 true。

示例

#include <iostream>
using namespace std;

int main() {
    bool a = true;

    if (!a) {
        cout << "条件为假" << endl;
    } else {
        cout << "条件为真" << endl;
    }
    return 0;
}

在例子中，由于 a 为 true，因此 !a 为 false，所以输出将是“条件为真”。

逻辑运算符的优先级

在表达式中，逻辑运算符的优先级较低，通常执行顺序为：

逻辑非（!）
逻辑与（&&）
逻辑或（||）

在复杂的布尔表达式中，建议使用括号来明确计算顺序，增强代码的可读性。例如：

1	bool result = (a && b) \|\| (!c);

在这个示例中，使用了括号来确保首先计算 a && b，然后将结果与 !c 进行逻辑或运算。

使用逻辑运算符的案例

可以通过逻辑运算符来控制程序的流程，例如判断一个数字是否在指定范围内。

#include <iostream>
using namespace std;

int main() {
    int number;
    cout << "请输入一个数字: ";
    cin >> number;

    // 判断number是否在1到10的范围内
    if (number >= 1 && number <= 10) {
        cout << "数字在范围内" << endl;
    } else {
        cout << "数字不在范围内" << endl;
    }

    return 0;
}

在这个案例中，我们使用了逻辑与运算符来同时检查 number 是否大于等于 1 且小于等于 10，从而决定输出的结果。

小结

本篇教程介绍了C++中的逻辑运算符，包括逻辑与、逻辑或和逻辑非。我们通过简单的示例展示了它们的用法和优先级。在编写条件语句和控制程序流时，逻辑运算符是非常重要的工具。

在下一篇，我们将讨论运算符之位运算符，进一步扩展我们对C++运算符的理解。

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白5 分钟读完 (大约790个字)

16 运算符之位运算符

C++完整教程

在上篇中，我们讨论了逻辑运算符，包括逻辑与（&&）、逻辑或（||）和逻辑非（!）。这些运算符通常用于条件判断，而在本篇中，我们将深入探索 C++ 的位运算符（bitwise operators）。位运算符对二进制位进行操作，非常适合需要直接操作数据底层的场景。

位运算符的种类

C++ 提供了以下几种常用的位运算符：

按位与（&）
按位或（|）
按位异或（^）
按位取反（~）
左移（<<）
右移（>>）

接下来，我们将逐个介绍这些运算符及其使用案例。

1. 按位与（`&`）

按位与运算符会对对应的每一位进行与操作，只有当两个操作数的相应位都为1时，结果才为1。

示例:

#include <iostream>
using namespace std;

int main() {
    int a = 12; // 二进制：1100
    int b = 5;  // 二进制：0101
    int result = a & b; // 结果：0100，即 4
    cout << "按位与: " << result << endl;
    return 0;
}

2. 按位或（`|`）

按位或运算符对两个操作数的相应位进行或操作，只要任一位为1，结果就为1。

示例:

#include <iostream>
using namespace std;

int main() {
    int a = 12; // 二进制：1100
    int b = 5;  // 二进制：0101
    int result = a | b; // 结果：1101，即 13
    cout << "按位或: " << result << endl;
    return 0;
}

3. 按位异或（`^`）

按位异或运算符会对两个操作数的相应位进行异或操作，当且仅当一位为1而另一位为0时，结果为1。

示例:

#include <iostream>
using namespace std;

int main() {
    int a = 12; // 二进制：1100
    int b = 5;  // 二进制：0101
    int result = a ^ b; // 结果：1001，即 9
    cout << "按位异或: " << result << endl;
    return 0;
}

4. 按位取反（`~`）

按位取反运算符会对操作数的每一位进行取反，0 变成 1，1 变成 0。

示例:

#include <iostream>
using namespace std;

int main() {
    int a = 12; // 二进制：1100
    int result = ~a; // 结果：...11110011 (补码表示)
    cout << "按位取反: " << result << endl; // 输出：-13
    return 0;
}

5. 左移（`<<`）

左移运算符将操作数的二进制位向左移动指定的位数，右侧补零。

示例:

#include <iostream>
using namespace std;

int main() {
    int a = 3; // 二进制：0011
    int result = a << 2; // 结果：1100，即 12
    cout << "左移: " << result << endl;
    return 0;
}

6. 右移（`>>`）

右移运算符将操作数的二进制位向右移动指定的位数，左侧根据操作数的符号位进行填充。

示例:

#include <iostream>
using namespace std;

int main() {
    int a = 12; // 二进制：1100
    int result = a >> 2; // 结果：0011，即 3
    cout << "右移: " << result << endl;
    return 0;
}

小结

位运算符是 C++ 提供的非常强大的工具。它们被广泛应用于底层编程，例如操作硬件、编码和解码数据等。了解这些运算符的使用，可以帮助你更深入地理解计算机的工作原理。

在下篇中，我们将继续探讨控制结构中的 if 条件语句，这将为你提供更强大的编程思维和能力。希望这篇关于位运算符的教程能为你的 C++ 学习带来帮助！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约899个字)

17 if条件语句

C++完整教程

在上一篇中，我们探讨了运算符之位运算符。现在，我们将深入了解控制结构中的if条件语句，这是 C++ 程序设计中最基本、最常用的控制结构之一。通过学习和使用 if 语句，我们可以根据条件的真假来决定程序的不同执行路径。

1. 基本结构

if 语句的基本语法如下：

1
2
3

if (条件) {
    // 条件为 true 时执行的代码
}

其中，条件 是一个布尔表达式，返回值为 true 或 false。如果条件为 true，则执行 {} 内的代码块；否则，跳过这个代码块。

示例：

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入您的分数：";
    cin >> score;

    if (score >= 60) {
        cout << "恭喜你，已通过考试！" << endl;
    }
    return 0;
}

在这个示例中，用户输入的分数存储在变量 score 中。如果 score 大于等于 60，程序将输出“恭喜你，已通过考试！”

2. if-else 结构

有时我们希望在条件为 false 时也执行某些操作，这时候就可以使用 if-else 结构，其语法如下：

if (条件) {
    // 条件为 true 时执行的代码
} else {
    // 条件为 false 时执行的代码
}

示例：

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入您的分数：";
    cin >> score;

    if (score >= 60) {
        cout << "恭喜你，已通过考试！" << endl;
    } else {
        cout << "很遗憾，你未通过考试，请再接再厉。" << endl;
    }
    return 0;
}

在上述代码中，如果用户输入的分数低于 60，程序将提示“很遗憾，你未通过考试，请再接再厉。”

3. else-if 结构

当有多个条件需要判断时，可以使用 else-if 结构，语法如下：

if (条件1) {
    // 条件1为 true 时执行的代码
} else if (条件2) {
    // 条件2为 true 时执行的代码
} else {
    // 所有条件均为 false 时执行的代码
}

示例：

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入您的分数：";
    cin >> score;

    if (score >= 90) {
        cout << "优秀！" << endl;
    } else if (score >= 80) {
        cout << "良好！" << endl;
    } else if (score >= 60) {
        cout << "及格！" << endl;
    } else {
        cout << "不及格，请努力！" << endl;
    }
    return 0;
}

在这个例子中，程序将根据用户的分数，输出相应的评价。可以看到，通过 else-if 可以灵活地判断多个条件。

4. 嵌套 if 语句

if 语句可以嵌套，也就是说可以在一个 if 语句的代码块内部再使用 if 语句。这在处理复杂条件时非常有用。

示例：

#include <iostream>
using namespace std;

int main() {
    int score;
    cout << "请输入您的分数：";
    cin >> score;

    if (score >= 60) {
        cout << "已通过考试！" << endl;
        if (score >= 90) {
            cout << "优秀！" << endl;
        }
    } else {
        cout << "很遗憾，未通过考试。" << endl;
    }
    return 0;
}

在这个示例中，如果用户通过了考试，程序会进一步检查是否获得了优秀的分数。

5. 总结

if 语句是 C++ 中最基本的控制结构之一，通过它可以实现条件判断和程序流程的控制。在我们的日常编程中，if、else 和 else-if 结构都是非常常用的。掌握这部分知识将为后续更复杂的控制结构打下基础。

在下一篇中，我们将继续学习控制结构之 switch 语句，探索如何处理多个条件判断的另一种方式。请继续关注！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约866个字)

18 控制结构之switch语句

C++完整教程

在上一篇中，我们讨论了if条件语句，学习了如何根据条件执行不同的代码块。今天，我们将介绍switch语句，这是C++中一种用于多条件判断的控制结构。switch语句可以使代码更加清晰和易读，尤其是在需要比较多个常量值时。

switch语句的基本语法

switch语句的基本结构如下：

switch (expression) {
    case constant1:
        // 当 expression 等于 constant1 时执行的代码
        break;
    case constant2:
        // 当 expression 等于 constant2 时执行的代码
        break;
    // 可以有任意数量的 case
    default:
        // 当 expression 不等于任何 case 时执行的代码
}

关键要素

表达式: switch的表达式通常是整数类型（int、char等），它的值将与每个case的常量进行比较。
case: 每个case后面跟随一个常量值和要执行的代码块。
break: break语句用于结束switch语句，防止继续执行后续的case。
default: 可选的default语句在没有任何case匹配时执行。

使用示例

让我们来看一个简单的示例，假设我们根据星期几的数字（1到7）输出相应的星期名称：

#include <iostream>
using namespace std;

int main() {
    int day;
    cout << "请输入星期几的数字 (1-7): ";
    cin >> day;

    switch (day) {
        case 1:
            cout << "星期一" << endl;
            break;
        case 2:
            cout << "星期二" << endl;
            break;
        case 3:
            cout << "星期三" << endl;
            break;
        case 4:
            cout << "星期四" << endl;
            break;
        case 5:
            cout << "星期五" << endl;
            break;
        case 6:
            cout << "星期六" << endl;
            break;
        case 7:
            cout << "星期日" << endl;
            break;
        default:
            cout << "无效的输入，请输入 1 到 7 之间的数字。" << endl;
            break;
    }

    return 0;
}

程序解读

在这个例子中，我们首先提示用户输入一个数字，表示星期几。然后，switch语句检查这个数字：

如果输入的数字是1，程序输出“星期一”。
如果输入的数字是2，程序输出“星期二”，以此类推。
如果输入的数字不是1到7之间的值，则执行default部分，输出提示信息。

注意事项

不必须包含break: 如果忘记在某个case后面添加break，将会导致“fall-through”现象，程序会继续执行后面的case代码，直到遇到break或switch结束。
支持的类型: C++的switch语句支持int，char，和其它整型（如enum）。不支持浮点数和字符串。
多个case: 可以将多个case合并在一起，如果它们需要执行相同的代码。例如：

switch (day) {
    case 1:
    case 2:
    case 3:
        cout << "工作日" << endl;
        break;
    case 6:
    case 7:
        cout << "周末" << endl;
        break;
    default:
        cout << "无效的输入，请输入 1 到 7 之间的数字。" << endl;
        break;
}

在这个修改后的例子中，输入1、2或3时，都会输出“工作日”。

总结

今天我们介绍了switch语句以及如何在C++中使用它来简化多条件判断。通过简单易懂的案例，我们可以看到switch如何提高了代码的可读性和维护性。下一篇中，我们将重点讨论控制结构中的循环语句。本篇中所讲解的内容将为你理解更复杂的控制结构打下良好的基础。期待在下篇中与大家再次见面！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约837个字)

19 控制结构之循环语句

C++完整教程

在 C++ 中，循环语句是一种常见的控制结构，它允许我们重复执行某段代码，直到满足特定条件为止。通过使用循环语句，我们可以有效地处理需要多次执行相同操作的任务如遍历数组、计算累积和等。本文将介绍 C++ 中的几种循环语句，包括 for 循环、while 循环和 do while 循环。

1. `for` 循环

for 循环是最常用的循环控制结构之一。它通常用于已知循环次数的情况下。for 循环的基本语法如下：

1
2
3

for (初始表达式; 循环条件; 循环后操作) {
    // 循环体
}

示例

以下是一个使用 for 循环打印从 1 到 10 的数字的简单例子：

#include <iostream>

int main() {
    for (int i = 1; i <= 10; i++) {
        std::cout << "数字: " << i << std::endl;
    }
    return 0;
}

在上面的代码中，int i = 1 是初始化表达式，i <= 10 是循环条件，而 i++ 是每次循环后 i 的更新操作。当 i 达到 11 时，循环条件不再满足，循环结束。

2. `while` 循环

while 循环用于在不确定循环次数的情况下进行循环。它只要条件为 true 就会继续执行。基本语法如下：

1
2
3

while (循环条件) {
    // 循环体
}

示例

以下是一个使用 while 循环计算 1 到 10 的和的示例：

#include <iostream>

int main() {
    int sum = 0;
    int i = 1;
    
    while (i <= 10) {
        sum += i;
        i++; // 更新 i 的值
    }
    
    std::cout << "1 到 10 的和为: " << sum << std::endl;
    return 0;
}

在上面的例子中，我们使用 while 循环来累加从 1 到 10 的数字，直到 i 的值大于 10 时，循环结束。

3. `do while` 循环

do while 循环与 while 循环相似，唯一的不同之处在于 do while 循环至少执行一次循环体。这是因为循环条件在循环体执行后才进行检查。基本语法如下：

1
2
3

do {
    // 循环体
} while (循环条件);

示例

下面是一个使用 do while 循环的例子，用于计算用户输入的数字之和，直到用户输入 0 为止：

#include <iostream>

int main() {
    int number;
    int sum = 0;

    do {
        std::cout << "请输入一个数字（输入 0 结束）: ";
        std::cin >> number;
        sum += number; // 累加用户输入的数字
    } while (number != 0);
    
    std::cout << "输入的数字总和为: " << sum << std::endl;
    return 0;
}

在这个例子中，用户会被要求输入数字，输入的数字将被累加。循环将在用户输入 0 时结束。这是 do while 循环的一个应用场景。

小结

本文介绍了 C++ 中的三种主要循环控制结构：for 循环、while 循环和 do while 循环。每种循环都有其特定的应用场景：

使用 for 循环时，当你知道确切的循环次数时最为合适。
使用 while 循环时，当条件判断决定是否继续执行循环时是最常用的方式。
使用 do while 循环时，当你至少希望执行一次循环体的情况很适合。

在下篇文章中，我们将进入一个新的主题——函数的定义与声明，进一步探索 C++ 的深入特性。

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约857个字)

20 C++函数的定义与声明

C++完整教程

在前一篇中，我们讨论了控制结构之循环语句。循环语句使得我们能够重复执行某段代码，提高了程序的灵活性和效率。本篇将专注于函数的定义与声明。函数是组织代码的基本单位，能够帮助我们将复杂的任务分解为更小、更易管理的部分。

什么是函数？

在C++中，函数是一段可以重复使用的代码，它执行特定的任务。函数帮助我们组织代码，提高可读性和可维护性。每个函数都有一个名称，通过名称可以调用这个函数。

函数的声明

在使用函数之前，必须先对其进行声明。函数声明通常位于程序的开头或头文件中，告诉编译器函数的名称、返回类型和参数类型。基本的函数声明形式如下：

1	返回类型函数名(参数类型1 参数名1, 参数类型2 参数名2, ...);

例如，我们可以声明一个函数，它接收两个整数并返回它们的和：

1	int add(int a, int b);

这个声明告诉编译器有一个名为 add 的函数，它接收两个整数并返回一个整数。

函数的定义

函数的定义包含了函数体，即函数具体执行的代码。函数定义应该包含函数声明的所有信息，就像下面这样：

1
2
3

int add(int a, int b) {
    return a + b;
}

在这个例子中，我们使用 add 函数来返回两个参数 a 和 b 的和。

声明与定义的区别

声明（Declaration）：告诉编译器函数的名称、返回类型和参数类型，并不包括函数体。通常在代码的开头进行。
定义（Definition）：包含了函数体，实现了函数的具体功能。

您可以在程序中先声明函数，然后在后面定义它：

#include <iostream>

// 函数声明
int add(int a, int b);

// 主函数
int main() {
    int result = add(5, 10);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

// 函数定义
int add(int a, int b) {
    return a + b;
}

在这个完整的例子中，函数 add 被声明在 main 函数之前，然后在 main 函数中被调用，最后在程序的底部被定义。

函数参数传递

在下一篇文章中，我们将讨论《函数之参数传递》。在这里，您将了解到如何将数据传递给函数，以及不同的传递方式（值传递与引用传递）如何影响函数的行为。

小结

在学习C++的过程中，函数的定义与声明是一个重要的基础。通过合理地使用函数，您可以提高代码的模块化程度，降低重复代码的量，从而让您的程序更清晰易懂。希望通过本篇文章的学习，您对C++函数的定义与声明有了更深的理解。

请在下一篇中继续关注函数的参数传递，让我们一起深入探索C++的魅力！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白5 分钟读完 (大约801个字)

21 C++函数参数传递

C++完整教程

在上一篇中，我们探讨了函数的定义与声明。了解了如何定义一个函数以及如何声明一个函数是非常重要的，而在本篇中，我们将深入讨论函数的参数传递方式。参数传递是函数外部与内部进行数据交换的桥梁，合理的参数传递可以大大提高程序的可读性与可维护性。

参数传递的基本方式

C++中的函数参数传递主要有以下几种方式：

值传递
引用传递
指针传递

1. 值传递

在值传递中，函数参数的值会被复制到函数内部，因此在函数内部对参数的修改不会影响外部变量。使用这种方式时，函数的参数是以一个副本的形式存在的。

示例代码

#include <iostream>

void modifyValue(int val) {
    val = 20; // 修改的是副本
    std::cout << "Inside function: " << val << std::endl;
}

int main() {
    int number = 10;
    std::cout << "Before function: " << number << std::endl;
    modifyValue(number);
    std::cout << "After function: " << number << std::endl; // number 仍然是 10
    return 0;
}

输出：

1
2
3

Before function: 10
Inside function: 20
After function: 10

在这个例子中，number的值在进入modifyValue函数时被复制，因此函数内部对val的修改不会影响到number。

2. 引用传递

在引用传递中，实际参数的地址被传递给函数，函数内部对参数的任何修改都会反映到实际参数上。这种方式能够提高效率，因为避免了数据的复制。

示例代码

#include <iostream>

void modifyReference(int& ref) {
    ref = 30; // 修改的是原始数据
    std::cout << "Inside function: " << ref << std::endl;
}

int main() {
    int number = 10;
    std::cout << "Before function: " << number << std::endl;
    modifyReference(number);
    std::cout << "After function: " << number << std::endl; // number 变为 30
    return 0;
}

输出：

1
2
3

Before function: 10
Inside function: 30
After function: 30

在这里，我们使用了int& ref来进行引用传递，这使得modifyReference函数直接操作number的引用，从而修改了其值。

3. 指针传递

指针传递与引用传递类似，同样可以直接修改实际参数。不同的是，使用指针时需要对指针进行解引用才能访问或修改值。

示例代码

#include <iostream>

void modifyPointer(int* ptr) {
    *ptr = 40; // 修改指针指向的值
    std::cout << "Inside function: " << *ptr << std::endl;
}

int main() {
    int number = 10;
    std::cout << "Before function: " << number << std::endl;
    modifyPointer(&number); // 传递number的地址
    std::cout << "After function: " << number << std::endl; // number 变为 40
    return 0;
}

输出：

1
2
3

Before function: 10
Inside function: 40
After function: 40

在这个例子中，使用int* ptr作为参数接收一个指向number的指针，并通过*ptr直接修改指针指向的值。

小结

在本篇中，我们探讨了C++中函数的参数传递方式，包括值传递、引用传递与指针传递。选择合适的参数传递方式可以提升程序的性能及可读性，尤其是在处理大型数据时，使用引用或指针能够避免不必要的数据复制。

在下一篇中，我们将深入讨论函数的返回值与重载，欢迎继续关注！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约912个字)

22 函数之返回值与重载

C++完整教程

在上一篇中，我们讨论了函数的参数传递，现在我们将深入探讨函数的返回值以及函数的重载。理解这两个概念对于编写灵活且可维护的代码至关重要。

函数的返回值

函数的返回值是指函数执行完毕后返回给调用者的结果。C++中的函数可以返回多种类型的值，包括基本数据类型（如int、float、char等）和自定义数据类型（如结构体和类）。

返回值类型

首先，让我们看一下如何定义一个有返回值的函数。假设我们希望编写一个函数来计算两个整数的和并返回结果：

#include <iostream>
using namespace std;

// 定义一个返回整数的函数
int add(int a, int b) {
    return a + b;  // 返回两数之和
}

int main() {
    int result = add(5, 3);  // 调用函数并接收返回值
    cout << "The sum is: " << result << endl;  // 输出结果
    return 0;
}

在上面的代码中，函数add接受两个int类型的参数，并返回它们的和。使用return语句返回结果。

返回值的类型推导

C++还允许使用auto关键字进行类型推导。当函数的返回值类型比较复杂时，使用auto可以使代码更简洁。

#include <iostream>
using namespace std;

// 定义一个使用 auto 返回类型的函数
auto multiply(double a, double b) {
    return a * b;  // 返回乘积
}

int main() {
    auto result = multiply(4.5, 2.0);  // 调用函数
    cout << "The product is: " << result << endl;  // 输出结果
    return 0;
}

在这里，multiply函数自动推导返回值为double类型。

函数重载

函数重载是指允许在同一作用域中定义多个同名但参数列表不同的函数。由此可以根据不同的参数类型或参数数量来调用相应的函数。

重载规则

参数个数不同：同名函数可以有不同数量的参数。
参数类型不同：同名函数可以有不同类型的参数。
参数顺序不同：同名函数可以有不同顺序的参数类型。

示例

让我们通过一个简单的示例来阐明这个概念，我们将定义一个名为print的重载函数，用于打印不同数据类型的信息：

#include <iostream>
using namespace std;

// 重载函数，打印整型
void print(int value) {
    cout << "Integer: " << value << endl;
}

// 重载函数，打印浮点型
void print(double value) {
    cout << "Double: " << value << endl;
}

// 重载函数，打印字符串
void print(const string& value) {
    cout << "String: " << value << endl;
}

int main() {
    print(5);                // 调用整型版本
    print(3.14);            // 调用浮点型版本
    print("Hello, World");  // 调用字符串版本
    return 0;
}

在这个示例中，我们定义了三个不同的print函数，分别处理int、double和string类型的参数。当我们调用print时，C++会根据参数的类型自动选择合适的重载函数。

总结

在本篇中，我们探讨了函数的返回值和重载。返回值是函数执行后的结果，而重载允许我们根据不同参数来定义同名函数，使代码更加灵活与可读。通过实际案例的介绍，我们希望你能对这两个概念有一个更清晰的理解，为接下来的学习奠定基础。

在下一篇，我们将讨论数组与字符串之一维数组，敬请期待！

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白6 分钟读完 (大约928个字)

23 数组与字符串之—一维数组

C++完整教程

在本篇教程中，我们将深入探讨 一维数组 和 字符串 的基本概念和用法。这一部分将为你建立坚实的基础，以便在后续的二维数组讲解中更加顺利。

什么是一维数组？

一维数组是由一组相同类型的数据构成的集合，数据在内存中是连续存储的。通过数组的索引可以快速访问其中的元素。

数组的定义与初始化

在 C++ 中，你可以使用以下语法定义和初始化一个一维数组：

1	type arrayName[arraySize] = {value1, value2, ..., valueN};

type：数据类型，如 int、float、char 等。
arrayName：数组的名称。
arraySize：数组大小，指定存储元素的数量。
value1, value2, ..., valueN：可选的数组初始化值。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int scores[5] = {90, 85, 78, 92, 88}; // 定义一个整型数组
    cout << "第一门课的分数是：" << scores[0] << endl; // 输出 90
    return 0;
}

访问和遍历数组元素

你可以通过数组的索引访问其元素，数组的索引从 0 开始。要遍历数组的所有元素，可以使用循环。

示例代码：

#include <iostream>
using namespace std;

int main() {
    int scores[5] = {90, 85, 78, 92, 88};

    cout << "所有课程的分数如下：" << endl;
    for (int i = 0; i < 5; i++) {
        cout << "第 " << i + 1 << " 门课的分数是：" << scores[i] << endl;
    }
    return 0;
}

字符串与字符数组

在 C++ 中，字符串 是字符数组的一个重要应用。可以使用字符数组存储字符串，但 C++ 标准库中的 string 类型提供了更便利的操作。

字符数组的定义与初始化

你可以通过以下语法定义和初始化一个字符数组：

1	char stringName[arraySize] = "yourString";

请注意，字符数组的最后一个元素是 \0（空字符），用于标识字符串的结束。

示例代码：

#include <iostream>
using namespace std;

int main() {
    char name[20] = "Alice"; // 定义字符数组并初始化

    cout << "你好，" << name << "!" << endl; // 输出：你好，Alice!
    return 0;
}

字符串的输入与输出

cin 和 cout 可以方便地处理字符串输入与输出。在读取字符串时，注意不能直接用 cin 读取带空格的字符串，因为它会在空格处停止。

示例代码：

#include <iostream>
using namespace std;

int main() {
    char name[20];
    cout << "请输入你的姓名：";
    cin >> name; // 读取字符串

    cout << "你好，" << name << "!" << endl;
    return 0;
}

要读取带空格的字符串，可以使用 cin.getline() 方法。

示例代码：

#include <iostream>
using namespace std;

int main() {
    char fullName[50];
    cout << "请输入你的全名：";
    cin.getline(fullName, 50); // 读取带空格的字符串

    cout << "你好，" << fullName << "!" << endl;
    return 0;
}

注意事项

一维数组的大小在编译时必须是一个常量表达式，而 std::vector 是动态数组，方便使用。
对字符串的处理尽量使用 std::string 类型，以避免字符数组中的许多潜在错误。
数组越界访问是常见错误，应当小心处理。

小结

本篇教程介绍了 一维数组 和 字符串 的基本知识，包括定义、初始化、访问与遍历等。掌握这些内容后，你将能够直接在 C++ 中处理一维数据结构，打下稳固基础。

在下一篇中，我们将向你展示 二维数组 的相关内容，这将进一步拓展你对数组的理解与应用。准备好一起进入更复杂的数据结构的世界了吗？

分享转发

2024-08-10发表2024-08-24更新编程 / Cplus小白5 分钟读完 (大约729个字)

24 数组与字符串之二维数组

C++完整教程

在上一篇中，我们探讨了一维数组的基本概念与用法。这一篇我们将深入到二维数组的世界。二维数组是数组的数组，适合用于表示矩阵、表格等结构。在接下来的内容中，我们将通过详细的阐述和实例来帮助你理解和使用二维数组。

一、什么是二维数组

在C++中，二维数组可以被视为一个矩阵，其中每个元素都可以通过两个索引来访问，例如array[i][j]表示第i行第j列的元素。创建一个二维数组的基本语法如下：

1	data_type array_name[row_size][column_size];

示例

#include <iostream>
using namespace std;

int main() {
    // 定义一个 3x4 的整型二维数组
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // 输出数组的元素
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            cout << arr[i][j] << " ";
        }
        cout << endl;  // 换行
    }

    return 0;
}

运行上面的代码，你会看到以下输出：

1
2
3

1 2 3 4 
5 6 7 8 
9 10 11 12

二、二维数组的初始化

在定义二维数组时，可以在定义时直接初始化，这就是以上代码中的例子。也可以先声明再赋值：

1
2
3

int arr[3][4]; // 声明
arr[0][0] = 1; arr[0][1] = 2; // 逐个赋值
// ...

符号与长度

如上所述，arr[i][j]的i代表行，j代表列。无论是用于存储数字、字符还是其他数据，每个元素的大小由声明时的data_type决定。

三、访问和遍历二维数组

访问二维数组中的元素和遍历其所有元素是学习的重要内容。

示例：遍历二维数组

下面的例子展示了如何通过两层循环访问二维数组：

#include <iostream>
using namespace std;

int main() {
    int arr[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    // 遍历数组
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            cout << "元素 [" << i << "][" << j << "] 的值是: " << arr[i][j] << endl;
        }
    }

    return 0;
}

四、二维数组作为函数参数

在C++中，你可以将二维数组作为函数参数来进行处理，以下是一个示例：

#include <iostream>
using namespace std;

void printArray(int arr[][3], int rows) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < 3; ++j) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int arr[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };

    printArray(arr, 2); // 调用函数

    return 0;
}

在这里，printArray 函数接收一个二维数组和数组的行数作为参数，并打印出数组的内容。

五、结论

到此为止，我们已经介绍了二维数组的定义、初始化、访问、遍历及如何将其作为函数参数。理解二维数组的基本操作对后续的字符串处理将大有裨益。在下一篇中，我们将深入探讨如何处理字符串，包括字符串的基本操作与应用，敬请期待！

🔥 新增教程

算术运算符概述

加法运算符 +

减法运算符 -

乘法运算符 *

除法运算符 /

浮点数除法

取模运算符 %

总结

分享转发

何为关系运算符

1. 等于运算符 ==

示例代码：

2. 不等于运算符 !=

示例代码：

3. 大于运算符 >

示例代码：

4. 小于运算符 <

示例代码：

5. 大于等于运算符 >=

示例代码：

6. 小于等于运算符 <=

示例代码：

关系运算符的应用

示例：综合运用关系运算符

总结

分享转发

逻辑运算符概述

逻辑与（&&）

示例

逻辑或（||）

示例

逻辑非（!）

示例

逻辑运算符的优先级

使用逻辑运算符的案例

小结

分享转发

位运算符的种类

1. 按位与（&）

2. 按位或（|）

3. 按位异或（^）

4. 按位取反（~）

5. 左移（<<）

6. 右移（>>）

小结

分享转发

1. 基本结构

示例：

2. if-else 结构

示例：

3. else-if 结构

示例：

4. 嵌套 if 语句

示例：

5. 总结

分享转发

switch语句的基本语法

关键要素

使用示例

程序解读

注意事项

总结

分享转发

1. for 循环

示例

2. while 循环

示例

3. do while 循环

示例

小结

分享转发

什么是函数？

函数的声明

函数的定义

声明与定义的区别

函数参数传递

小结

分享转发

参数传递的基本方式

加法运算符 `+`

减法运算符 `-`

乘法运算符 `*`

除法运算符 `/`

取模运算符 `%`

1. 等于运算符 `==`

2. 不等于运算符 `!=`

3. 大于运算符 `>`

4. 小于运算符 `<`

5. 大于等于运算符 `>=`

6. 小于等于运算符 `<=`

逻辑与（`&&`）

逻辑或（`||`）

逻辑非（`!`）

1. 按位与（`&`）

2. 按位或（`|`）

3. 按位异或（`^`）

4. 按位取反（`~`）

5. 左移（`<<`）

6. 右移（`>>`）

1. `for` 循环

2. `while` 循环

3. `do while` 循环