什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

Slug 使用建议#

1. 使用英文和连字符：my-awesome-post 而不是 my awesome post
2. 保持简洁：避免过长的 slug
3. 具有描述性：让 URL 能够反映文章内容
4. 避免特殊字符：只使用字母、数字和连字符
5. 保持一致性：在整个博客中使用相似的命名模式

注意事项#

• Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
• 如果多个文章使用相同的 slug，后面的文章会覆盖前面的
• Slug 会自动转换为小写

写在开始之前：语法的基础框架#

众所周知，编程语言代码格式分为两派：括号派和缩进派。前者以传统语言（c/c++, java…) 为代表，后者以python为代表。

两派之间的争斗也由来已久：前者括号一多起来就确定不清层数，后者更是被戏称为’拿着游标卡尺写代码’.

Dart的语法规范属于前者，使用大括号确认基本框架，每行后需要加分号。不过需要注意的是，Android Studio中，Dart代码文件的tab缩进默认为2空格而非4空格，初次学习需要一定时间适应。

从变量开始#

1
var a = 1;
2
int b = 2;

1
void main(List<String> args) {
2
  String text = '现在是${Datetime.now()}';
3
  print(text);
4
}

1
bool I_am_mtf = false;

1
List students = ['Alice','Bob'];

1
students.forEach((item) { // 迭代打印每个元素
2
  print(item);
3
})
4

5
print(students.every((item) { // 检测每个元素是否都以'A'开头
6
  return item.toString().startsWith("A");
7
}))
8

9
print(students.where((item) { // 筛选出所有以 "A" 开头的元素并组成新列表打印
10
  return item.toString().startsWith("A");
11
}).toList())

1
for item in students: # 第一种
2
  if item[0] == 'A':
3
    print(item)
4

5
# 第二种：似乎最标准的写法就是一行流
6
print(all(str(item).startswith("A") for item in students))
7

8
# 第三种
9
result = []
10
for item in students:
11
    if str(item).startswith("A"):
12
        result.append(item)
13
print(result)
14

15
# 也可以一行流
16
print([item for item in students if str(item).startswith("A")])

1
Map a = {"breakfast":"1","lunch":"2"};

1
dynamic freedom = 1;
2
free = '';
3
free = false;
4
free = [1];
5
free = {}; // 以上操作均为合法

运算符#

和其他编程语言一样，dart的常用运算符分为以下几类；算数运算符、赋值运算符、比较运算符、逻辑运算符。

需要注意的是，dart语言中，整除符号是 ~/ .毕竟 // 被拿来用作注释标记了

赋值、比较、逻辑运算符与其他语言保持一致。

流程控制#

Dart中的逻辑控制（if分支语句、三元运算符、switch/case、while循环、for循环）和c++保持一致。

函数#

1
void main(List<Strings> args) {
2
  onTest(test);
3
}
4

5
Function callback = () {
6
  print("test");
7
}
8

9
void onTest(Function callback) {
10
  callback();
11
}

1
int add(int a,int b) => a + b;

指数位#

指数位的8个bit可视作无符号整型。存储范围为0-255.
指数位采用偏移码：实际表示的数为 E - 127 .
部分指数位具有特殊用途：

• E=0 : 非规格化数（次正规数），用于表示无限接近于0的极小数
• 1 <= E <= 254 : 规格化数（一般情况）
• E= 255 : 无穷大 或 NaN

尾数位#

尾数位用于存储小数部分。实际尾数为1.M （规格化数）或 0.M （非规格化数）.

具体表示形式#

十进制浮点数转换为bit表示方式的过程#

1. 先将十进制数字转换为二进制数字；
2. 将转换后的数字用科学计数法表示；
3. 分别得到S、E、M；
4. 组合得到bit表示方式.

bit表示转换为十进制浮点数只需逆向运算即可.

一些注意事项#

1. 非均匀精度!! 越接近0精度越高!!!
2. 符号对称：正负范围对称（除NaN）
3. 零有正负：+0和-0，但比较时相等
4. 精度限制：约6-9位有效十进制数字
5. 舍入规则：默认向最近偶数舍入
6. float类型可以表示的最大数字是3.4*10e28.

这也就是为什么：

• 浮点数的等值比较并不可靠，甚至极小误差的大小比较也不可靠；
• 大数字加上小数字可能导致精度损失.
• 存在溢出可能性.

程序运行起来的内部过程#

变量 (Variable) 声明要求#

• 由字母、数字、下划线组成。
• 不能以数字开头。
• 不能是保留字。
• 长度不限，但最好控制在31字符以内。

变量声明#

1
int a = 1;
2
double b = .1e2;
3
char c = 'A';

最基础的输入/输出：cin / cout#

使用<iostream> 头文件。

1
#include <iostream>
2
using namespace std;
3
int main(){
4
  char a[10];
5
  cin >> a ; // 假设输入 "Hello"
6
  cout << a << " world" << endl; //输出 "Hello world"
7
  return 0;
8
}

数学方法（使用<cmath>头文件）#

数字类数据类型以及占用字节数#

上面的各种占用空间根据系统和编译器的不同存在差异，比如 long 在 64 位 Unix/Linux 系统中通常为 8 字节，而在32位系统和所有Windows系统中为4字节。不必记忆，仅供参考。

long double 可精确到小数点后19位。

基本声明方式#

一般声明：

const datatype CONSTANTNAME = VALUE;

直接替换：

#define identifier value

溢出#

上溢（overflow） ： 超过数据类型的上限。

short a = 32767 + 1 ==> -32768

下溢（underflow） ： 低于数据类型的下限。

short a = -32768 - 1 ==> 32767

算术运算符（Numeric Operator）#

输出结果格式化（小数点位数）#

使用 <iomanip> 头文件。

1
double amount = 12618.98;
2
double interestRate = 0.0013;
3
double interest = amount * interestRate;
4

5
cout << "Interest is:"<<interest<<endl;
6
Interest is: 16.4047
7

8
cout << "Interest is:" <<fixed<<setprecision(2)<<interest<<endl;
9
Interest is: 16.40

setprecision() 设置的是小数点位数，而非保留有效数字位数。如果没有 fixed，setprecision(n) 默认设置的才是总的有效数字位数。

计算时的隐式类型转换规则#

当两个不同类型的变量进行运算时，c++会自动按照一定的优先级规律转换为一致类型。

简化后的转换规律如下：

• 如果其中一个为浮点（long double / double / float），则优先转换为一致浮点。
• 如果两个都为浮点且不同，则按照 long double > double > float 的规则，将低等级变量转换为高等级变量。
• 如果两个都为定点（unsigned long / long / unsigned int / int）且不同，则按照 unsigned long > long > unsigned int > int 的规则，将低等级变量转换为高等级变量。

一般情况下的类型转换#

隐式转换：

1
double d = 3; // int被自动提升为float；仅适用于低等级转换为高等级

显式转换：

1
int i = static_cast<int>(3.0); // (type narrowing) (类型缩窄)
2
int i = (int)3.9; // (Fraction part is truncated) (小数点后被丢弃)

这种类型转换并不会改变原变量的类型。

1
double d = 4.5;
2
int i = static_cast<int>(d);  // d is not changed

增强型赋值运算符 （Augmented Assignment Operators）#

自增/自减运算符 （Increment and Decrement Operators）#

简单来说： ++var 和 —var 先对自己的值+1 / -1 ，然后将运算后的值提交给表达式。 var++ 和 var— 先将自己的值提交给表达式，然后自己的值+1 / -1 。

数据类型#

ASCII码字符集#

ASCII码表是unicode表从 \u0000 到 \u007f 的子集。（可能你不需要知道这些，仅供补充）

快速记忆： 0对应48，A对应65，a对应97. 小写字母的编号比其对应的大写字母大32. 0-9对应48-57，A-Z对应65-90，a-z对应97-122.

字符数据类型（Char）#

• 一个char在底层占据1byte空间，是一种整数类型。（不要与int混淆！）
• 它与ASCII码一一对应。

考虑到上述特点，char类型也可以参与一些算数和关系运算（arithmetic and relational operations），例如加法、减法（subtraction）、比大小。

1
char ch = 'A';
2
cout << ch << " " << int(ch) << endl;
3
ch++;
4
cout << ch << " " << int(ch) << endl;

字符和数字类型也可以在一定程度上互相转换。

1
int i = 'a'; // Same as int i = (int)'a';
2
char c = 97; // Same as char c = (char)97;

1
char c = 0xFF41;
2
cout<<c<<endl;

1
char c = 65.25;
2
cout<<c<<endl;

1
int i = ‘A’;
2
cout<<i;

特殊字符的转义序列（Escape Sequences for Special Characters）#

1
cout<<“He said \"programming is fun!\""<<endl;
2
cout<<"\\t is a tab character"<<endl;
3
cout << "A\tB\tC\n1\t2\t3\n";

可能并非全部要求记住。

关系运算符（Relation Operators）#

布尔数据类型（The bool Data Type）#

1
bool lightOn = true;

非黑即白，非真(true)即假(false)。

c++在内部使用1代表真值，0代表假值。

逻辑运算符#

&&在两侧值都为真时返回真，否则返回假；（即：两侧全都是真才是真） ||在两侧值都为假时返回假，否则返回真；（即：有一侧为真就是真）

&& 和 || 两者均存在一套短路逻辑： 对于&& ,如果左侧值为假，则直接返回0，不继续计算右侧； 对于|| ,如果左侧值为真，则直接返回1，不继续计算右侧。 这套逻辑在计算复杂的优先级时需要着重考虑。

逻辑与的优先级高于逻辑或。

运算符优先级#

(简单记忆) 在C++中，这些运算符的优先级从高到低大致如下：

1. 后缀自增/自减（i++、i—）优先级最高。
2. 前缀自增/自减（++i、—i）和引用（&）、解引用（*）都属于一元运算符，属于同一优先级，并且结合性从右到左。
3. 乘除取模（*、/、%）优先级次之。
4. 加减（+、-）优先级再次之。
5. 比较运算符（<、<=、>、>=）等。
6. 相等性运算符（==、!=）。
7. 逻辑与（&&）。
8. 逻辑或（||）。
   另外，逻辑与（&&）和逻辑或（||）具有短路特性。

1
#include <iostream>
2
int main() {
3
    int a = 5;
4
    int b = 3;
5
    int c = 2;
6
    int d = a + b * c -!a && c++ % a;
7
    std::cout << "d = " << d << std::endl;
8
    std::cout << "c after evaluation = " << c << std::endl;
9
    return 0;
10

11
}

聪明的你，能得出d的正确结果吗？

三种基本程序控制结构#

顺序结构（Sequential）、分支结构（Selection / Branching）、循环结构（Looping / Iteration）。

分支结构：if-else#

1
if (booleanExpression) {
2
  statement(s)-for-the-true-case;
3
}
4
else {
5
  statement(s)-for-the-false-case;
6
}

几类不同的分支结构（注意else if的用法）

分支结构：switch#

1
switch (status) {
2
  case 0:  compute taxes for single filers;
3
           break;
4
  case 1:  compute taxes for married file jointly;
5
           break;
6
  case 2:  compute taxes for married file separately;
7
           break;
8
  case 3:  compute taxes for head of household;
9
           break;
10
  default: cout << “Error: invalid statud!”;
11
}

• switch 表达式必须返回 char、short 或 int 类型的值 (示例伪代码中的 status )，并且必须始终用括号括起。
• case 后面必须紧跟一个常量表达式，这意味着他们不能包含变量，比如1+x.
• break 关键字在理论上是可选的，但应在每个 case 语句末尾使用，以终止 switch 语句的后续部分。若未出现 break 语句，则会执行下一个 case 语句。
• default情况可选，用于执行 status 未能满足任意一个 case 的情况。
• 每个case按照自上而下的顺序进行判断，但case的顺序无关紧要（毕竟一般不会出现重复，且case个数有限，单纯判断过程对效率几乎无影响）。然而，按照顺序排列case是一种好的代码风格。

总结#

循环结构：while#

1
while (loop-continuation-condition){
2
  // loop-body;
3
  Statement(s);
4
}

示例：

1
int count = 0;
2
while (count < 1000){
3
  cout << "Hello World!\n";
4
  count++;
5
}

注意：如果没有那行 count++ ，该循环将成为死循环。除非你确定代码逻辑需要，否则避免死循环可能带来的调试困难！

上述代码执行了1000次。如果将 < 改为 <= ，则代码将执行1001次。

循环结构：do-while#

1
do
2
{
3
  // Loop body;
4
  Statement(s);
5
} while (loop-continuation-condition);

示例：

1
int n=10000;
2
int sum=0;
3
int counter=1;
4

5
while(counter<=n)
6
{
7
   sum=sum+counter;
8
   counter++;
9
}
10

11
do
12
{
13
   sum=sum+counter;
14
   counter++;
15
} while(counter<=n); // 两种不同的语法结构

循环结构：for#

1
for (initial-action; loop-continuation-condition; action-after-each-iteration){
2
   // loop body;
3
   Statement(s);
4
}

示例：

1
int i;
2
for (i = 0; i < 100; i++){
3
  cout << "Welcome to C++!\n";
4
}

上述循环执行100次。

一般来说，上述for语句可以有更简洁的写法：for (int i = 0; i < 100; i++) 这样写可以使得代码更加简略，但是极少数编译器不支持这种写法。

数组（Array）#

• 定义：数组是一种数据结构，用于表示一组相同类型的数据集合。
• 声明：datatype arrayRefVar[arraySize];
• 示例：

1
double myList[10];

c++要求任何数组声明的长度都必须是一个常量表达式。例如，下面的代码是不合法的;

1
int size = 4;
2
double myList[size]; // Wrong

但是下面的代码合法：

1
const int size = 4;
2
double myList[size]; // Correct

1
int n;
2
cin >> n;
3
double arr[n]; // 某些编译器能通过，但这不是标准 C++!

访问数组元素#

数组元素通过下标进行访问，从零开始编号。
也就是说：假设数组a含有10个元素，则a[0] 代表a的第一个元素，a[9] 代表a的最后一个（也就是第10个）元素。
也就是说：长度为n的数组下标从0开始，到n-1结束。

数组的初始化#

当一个数组被创建（还未赋初始值）时，它的元素可能为任意值（垃圾值）。

可通过以下代码在创建数组的同时直接赋值：

1
dataType arrayName[arraySize] = {value0, value1, ..., valuek};

示例：

1
double myList[4] = {1.9, 2.9, 3.4, 3.5}; // 与下列代码等价
2

3
double myList[4];
4
myList[0] = 1.9;
5
myList[1] = 2.9;
6
myList[2] = 3.4;
7
myList[3] = 3.5;

但是使用大括号初始化时，声明和赋值必须位于同一行。例如，下面的代码是错误的；

1
double mylist[4];
2
mylist = {1.9,2.9,3.4,3,5};

1
double myList[] = {1.9, 2.9, 3.4, 3.5};

1
double myList[4] = {1.9, 2.9}; //剩下两个元素是0，0

数组示例代码#

1
// Initializing Arrays with input value
2
const int ARRAY_SIZE = 10;
3
double myList[ARRAY_SIZE];
4
cout << "Enter" << ARRAY_SIZE << " values:";
5
for (int i = 0; i<ARRAY_SIZE;i++){
6
   cin >> myList[i];
7
}

1
// Printing arrays
2
for (int i = 0; i < ARRAY_SIZE; i++){
3
      cout << myList[i] << " ";
4
}

1
// Copying Arrays
2
for (int i = 0; i < ARRAY_SIZE; i++){
3
   list[i] = myList[i];
4
}

1
// Summing All Elements
2
double total = 0;
3
for (int i = 0; i < ARRAY_SIZE; i++){
4
    total += myList[i];
5
}

1
// Finding the Largest Element
2
double max = myList[0];
3
for (int i = 1; i < ARRAY_SIZE; i++){
4
    if (myList[i] > max)  max = myList[i];
5
}

1
// Finding the smallest index of the largest element
2
double max = myList[0];
3
int indexOfMax = 0;
4
for (int i = 1; i < ARRAY_SIZE; i++){
5
  if (myList[i] > max){
6
  max = myList[i];
7
    indexOfMax = i;
8
  }
9
}

二维数组：数组的初始化#

1
elementType arrayName[rowSize][columnSize]; //注意是行在前，列在后

例如：

1
int matrix[5][5];

如果你想要像一维数组那样隐式指定数组大小，那么只需像下面这样：

1
int array[][3] = { {1,2,3}, {4,5,6} }; // 多维数组必须从右往左保证后续维度已知

当然也可以：

二维数组：示例代码#

1
// Printing Arrays
2
for (int row = 0; row < rowSize; row++){
3
  for (int column = 0; column < columnSize; column++){
4
    cout << matrix[row][column] << " ";
5
  }
6
  cout << endl;
7
}

1
// Summing Elements by Column
2
for (int row = 0; row < rowSize; row++){
3
  for (int column = 0; column < columnSize; column++){
4
    cout << matrix[row][column] << " ";
5
  }
6
  cout << endl;
7
}

多维数组#

以此类推。

1
double scores[10][5][2];

1
int a[][2][3] = {
2
    { {1,2,3}, {4,5,6} },
3
    { {7,8,9}, {10,11,12} }
4
 // Right
5

6
int a[2][][3] = { { {1,2,3}, {4,5,6} } };  // Wrong
7
int a[][][3]  = { ... };                   // Wrong

字符串的常用运算#

字符串比较#

c++允许使用和数字类型相同的运算符(==,!=,<,<=,>,>=)直接对字符串进行比较。

1
string a = "apple";
2
string b = "banana";
3
if (a < b)
4
    cout << a << " comes before " << b << endl;

你也可以使用string.comparison() 成员函数进行比较。

1
string s1 = "Hello";
2
string s2 = "Hi";
3
int result = s1.compare(s2);

注意运算符返回bool类型，而成员函数返回int类型，含义如下。

大小比较规则：
1.从前往后，比较每个字符的ASCII码。
2.如果前缀相同（即比较过的每个字符都相同，但两个字符串长度不同，如cat和cats），更长的字符串更大。
3.完全相等时，字符串相等。

子串和搜索#

1
// 形式1：只指定起始位置，截取从该位置到字符串末尾的子串
2
string substr(size_t pos) const;
3
// 形式2：指定起始位置和子串长度，截取固定长度的子串
4
string substr(size_t pos, size_t count) const;
5

6
string s = "programming";
7
cout << s.substr(0, 3) << endl;   // "pro"
8
cout << s.substr(3, 4) << endl;   // "gram"
9
cout << s.substr(7) << endl;      // "ming"

1
size_t find(const string& str, size_t pos = 0) const;
2

3
string s = "Welcome to C++ programming";
4
cout << s.find("come") << endl;   // 3
5
cout << s.find('o') << endl;      // 4
6
cout << s.find("Java") << endl;   // string::npos (not found)
7
cout << s.find("o", 5)<< endl;   // search from index 5 onward
8

9
string email = "alice@tju.edu.cn";
10
int pos = email.find('@');
11
string user = email.substr(0, pos);
12
cout << "Username: " << user;

运算符总结#

定义与声明#

指针是将内存地址作为存储值的变量。

指针是一种复合数据类型。

声明方式如下：

1
dataType * pointerName;

例如：

1
int * pCount;

1
 int count=5;
2
 int *pCount = &count; // & 是取地址运算符：&count代表变量count对应的内存地址
3
 int *ptr = NULL;

指针的作用：间接引用（Indirect Reference）#

通过指针引用变量。

例如：

1
int count=5;
2
int *pCount = &count;
3

4
count++; //direct reference
5
(*pCount)++; //indirect reference

指针和变量的等价关系如下：

1
 int age;
2
 int *age_ptr = &age;
3

4
 age_ptr <=> &age
5
*age_ptr <=> age
6
*age_ptr = 50 <=> age = 50;
7
(*age_ptr)++ <=> age++;

Null 指针（空指针）#

null 指针是任何指针类型的常规指针，它具有一个特殊值，指示它不指向任何有效的引用或内存地址。此值是将整数值零类型转换为任何指针类型的结果。

1
int * p;
2
p = 0; // p has a null pointer value
3
p = NULL; or p = nullptr;//C++ 11

指针的运算#

对指针的运算操作的是指针对应的地址，而非指针指向的值。

指针具有以下运算：

• 分配（Assignment）
• 移动（Movement）
• 减法（Subtraction）
• 比较（Comparison）

指针的类型决定了运算的结果。例如：下面的加/减运算代表指针向前/向后移动n个指针类型对应的类型长度, 而同类型指针相减得到的值是他们之间间隔的该种元素的个数。

两地址相减结果为ｐ指针与ａ数组首地址之间元素的个数。

1
p±n;// move n*sizeof( pionter type)

1
  if (ptr1 == ptr2)  ...  // compares addresses
2
  if (*ptr1 == *ptr2) ... // compares contents

一些常见的注意事项#

• 对指针分配的地址指向的数据类型必须和指针本身的数据类型保持一致。

1
int area = 1;
2
double *pArea = &area; // Wrong!

• 每一个*对应一个指针。

1
int *ptr1, *ptr2; //two pointers
2
int* ptr1, ptr2; // one pointer, one integer

特殊而又容易混淆的概念：指针常量和常量指针#

1
double radius = 5;
2
double another = 10;
3
double * const pValue = &radius;
4

5
(*pValue) = 3.0; // Right
6
raidus = 4.0 // Right
7
pValue = &another; // Wrong
8
pValue ++; // Wrong

1
double radius = 5;
2
double another = 10;
3
const double * pValue = &radius;
4

5
(*pValue) = 3.0; // Wrong
6
raidus = 3.0 // Right ()
7
pValue = &another;  // Right：现在 pValue 指向 another

指针与数组名的关系#

数组名代表数组起始位置元素的地址，因此也就能和指针顺理成章扯上联系。

1
int myList[10]; // myList <=> &myList[0]

数组变量本质上是与指针非常类似。
也就是说：你可以通过myList+1这种形式对数据进行操作。

然而，他们在本质上还是存在不同：数组名是一个常量（而非变量）地址。

1
int array[10];
2
int* ptr = array;
3
for (k=0; k<5; k++){
4
  cout<< *(ptr++); // Right
5
}
6
for (k=0; k<5; k++){
7
  cout<< *(array++); // Wrong
8
}

指针和数组名相减：两地址相减结果为ｐ指针与ａ数组首地址之间元素的个数。

一些比较恶心的考点#

1
#include <iostream>
2
using namespace std;
3
int main(){
4
    int x[4] = {10,20,30,40};
5
    int *p = x; // p指向x[0]
6
    cout<<*++p<<endl;
7
    cout<<*p++<<endl;
8
    cout<<++*p<<endl;
9
    cout<<(*p)++<<endl;
10
    cout<<*p<<endl;
11
    return 0;
12
}

不会了？回去看看

多维数组与指针（暂略）#

使用指针发访问二维数组（暂略）#

定义与声明#

有别于普遍使用的string，为了向下兼容c，c++中也允许使用字符数组（a.k.a c风格字符串（C-strings） or 基于指针的字符串（pointer-based strings））来表示一串连续的字符。

有两种方法声明c风格字符串：

1
// 1.Using an array variable
2
char city[7] =  "Dallas";
3
char city[] =  {'D', 'a', 'l', 'l', 'a', 's', '\0' };
4
char city[] =  "Dallas";
5
cout << city;
6

7
//2.Declare a string variable using a pointer
8
const char *pCity = "Dallas";  //不能通过 pCity 修改它指向的字符串常量（存储在常量区）
9
cout<<pCity;

输入：cin与cin.getline()#

1
char city[10];
2
cin >>city; // Right; but only a word.stop at the first whitespace.
3

4
char *city2;
5
cin>>city2; //Wrong; No memory is allocated to store the content of city2.

1
cin.getline(char array[], int size, char delimitChar) // can read any character.
2
cin.getline(city,5,'\n') // example;

输出：cout#

1
cout << "Enter a city: ";
2
cin >> city; // read to array city
3
cout << "You entered " << city << endl

和吃饭喝水一样简单。

字符测试函数（Character Test Functions）与大小写转换函数（Case Conversion Functions）#

• 这些函数位于<cctype>头文件中，使用时记得先声明。
• 以下内容并非全部要求记忆。

字符数组函数#

• 以str开头的函数位于<cstring>头文件中，含有to 的函数位于cstdlib头文件中，使用时记得先声明。
• 以下内容并非全部要求记忆。

为什么我们需要函数？#

• 避免代码重复（Avoid code duplication）
• 使程序模块化（Make programs modular）
• 增强可读性与可维护性（Improve readability and maintenance）
• 将复杂的问题分解（Break complex problems into smaller tasks）

定义与声明#

函数是一段执行特定任务的代码块。

一个函数由四个部分组成：

• 返回值类型（Return value type）
• 函数名（Function name）
• 参数（Parameter）
• 函数体（Function body）

声明格式如下：

1
returnValueType functionName(list of parameters){
2
    //function body;
3
}

• 函数签名(Function signature) 是由函数名(functionName) 和参数列表(list of parameters) 组合而成的。
• 函数头中定义的变量称为形式参数 (formal parameters) 或形参。
• 当调用函数时，你向参数传递一个值。该值被称为实际参数 (actual parameter) 或实参 (argument)。
• 函数可以返回一个值。returnValueType 表示函数返回值的数据类型。如果函数不返回值，则 returnValueType 为关键字 void。例如，main 函数中的 returnValueType 为 int。

内存空间与函数的栈调用（Call Stacks）#

一些容易误解的地方：值传递#

当你调用带参数的函数时，参数的值会被传递给该函数。这被称为值传递（pass-by-value）。如果参数是变量而非字面值，则该变量的值会被传递给参数。无论函数内部对参数做了何种修改，该变量本身都不会受到影响。

函数重载（Overloading Functions）#

重载函数允许你定义具有相同名称的函数，只要它们的签名不同即可。

1
#include <iostream>
2
using namespace std;
3
// 返回两个整数中的较大值
4
int max(int num1, int num2){
5
    return (num1 > num2) ? num1 : num2;
6
}
7
// 返回两个双精度浮点数中的较大值
8
double max(double num1, double num2){
9
    return (num1 > num2) ? num1 : num2;
10
}
11
// 返回三个双精度浮点数中的最大值
12
double max(double num1, double num2, double num3){
13
    return max(max(num1, num2), num3);
14
}
15
int main(){
16
    // 测试
17
    cout << "max(3, 5) = " << max(3, 5) << endl;
18
    cout << "max(2.5, 3.7, 1.2) = " << max(2.5, 3.7, 1.2) << endl;
19
    return 0;
20
}