CPP-Week2

Lesson27 函数进阶

27.1 函数的默认参数

在 C++ 中，函数的参数表中的形参是可以有默认值的。比如：

1

int func(int a, int b = 10);

在使用默认参数 (Default Argument) 时，我们需要注意以下几点：

• 调用函数时，任何明确提供的参数必须按参数表顺序（从左往右）输入（不能跳过具有默认值的参数）。对于有默认值的参数，用户调用时未提供数据则按默认值传入；有提供数据则按用户输入传入。

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

  void print(int a = 20, double d = 10.0){ printf("%d\n", a); printf("%f\n", b); } int main(void) { print(); // okay: both arguments defaulted print(60); // okay: d defaults to 10.0 print(10.0); // error: does not match above function (cannot skip argument for a) return 0; }

• 如果一个参数被赋予默认参数，那么所有后续的参数（右侧的）也必须是默认参数。因此，建议在函数末尾定义默认参数。

  1 2	//void print(int x=10, int y); // not allowed void print(int x = 10, int y = 10);// right

• 一旦声明，默认参数就不能在同一源文件中重新声明。这意味着对于同时具有声明和函数定义的函数，默认参数可以在声明或函数定义中声明，但不能同时声明。

  1 2 3 4 5 6 7 8 9

  #include <cstdio> void print(int x, int y=4); // forward declaration void print(int x, int y=4) // compile error: redefinition of default argument { printf("%d\n", x); printf("%d\n", y); }

  默认参数必须在源文件中开头声明后才能使用：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  #include <cstdio> void print(int x, int y); // forward declaration, no default argument int main() { print(3); // compile error: default argument for y hasn't been defined yet return 0; } void print(int x, int y=4) { printf("%d\n", x); printf("%d\n", y); }

  Tip

  我们建议在函数声明而非定义时设置默认参数。

  ——11.5 — Default arguments – Learn C++

• 建议：如果有多个默认参数，则最左侧的参数应该是用户最可能明确设置的参数。

27.2 函数的占位参数

在 C++ 中，函数的参数列表可以有占位参数 (Placeholder Argument)，只使用类型名而不提供变量名，用以占位。比如：

1

int func(int a, int);//后一个参数就是占位参数

调用函数时，未指定数据的情况下，占位参数必须提供。一般情况下，在函数体内部无法使用占位参数，因为没有可以访问其位置的事物（变量名）。

1
2
3
4
5
6
7
8
9
10
11

#include <cstdio>

int print(int a, int){
    printf("%d", a);
    //printf("%d", ?); //WTF?
}

int main(void){
    //print(10); //Intellisense: 函数调用中的参数太少
    print(10, 10);
}

占位参数也有默认值。此时可按照默认参数规则，不提供占位参数：

1
2
3
4
5
6
7
8

int print(int a, int = 10){
    printf("%d", a);
    //printf("%d", ?); //WTF?
}

int main(void){
    print(10);// okay
}

占位参数常见的用途包括：

1. 与旧代码兼容：当修改函数签名时，为了保持与旧代码的兼容性，可以保留不再使用的参数。
2. 占位：为将来可能增加的参数预留位置。
3. 匹配特定函数签名：在某些情况下，可能需要一个特定的函数签名，比如使用回调函数时。此时可以通过占位参数来满足签名的要求。

（C 函数占位参数介绍_c 占位参数 - CSDN 博客）

27.3 函数重载

27.3.1 函数重载的概念

11.1 — Introduction to function overloading – Learn C++

考虑这个函数：

1
2
3

int add(int x, int y){
    return x + y;
}

add 这个函数用来计算两个整数的和。但如果我们需要计算两个浮点数的和呢？我们不可能直接使用 add，因为参数表的类型根本不匹配！于是我们又写了一个函数：

1
2
3

double addDouble(double x, double y){
    return x + y;
}

挺好的，只要你能在写了成百上千行代码再放了几天假期后继续工作时还能记起来整数加法用 add、浮点数加法用 addDouble 就行。

所以，既然都是加法，为什么还要分成整数加法和浮点数加法呢？能不能统一成一个加法函数呢？

C++ 提供了一种解决方法，我们称为函数重载 (Function Overloading)。函数重载允许我们创建多个名称相同的函数，只要每个同名函数具有不同的参数类型（或者函数可以通过其他方式区分）。在相同的作用域中共享名称的每个函数都称为重载函数（有时简称为重载）。

重载函数有如下条件：

• 同一作用域
• 函数名称相同
• 函数参数表不同：类型不同、数量不同、(类型) 顺序不同

1
2

int getRandomValue();
double getRandomValue();

1

getRandomValue();

1
2

int getRandomInt();
double getRandomDouble();

下面进行演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

int add(int x, int y) // integer version
{
    return x + y;
}

/*
// not an overloading
int add(int a, int b)
{
	return a + b;
}
*/

double add(double x, double y) // floating point version
{
    return x + y;
}

double add(double x, int y)// hybrid version
{
	return x + y;
}

double add(int x, double y)// the overloading of hybrid version above
{
    return x + y;
}

1
2
3
4
5
6
7
8
9

int operate (int a, int b)
{
  return (a*b);
}

double operate (double a, double b)
{
  return (a/b);
}

为了编译一个重载函数的调用，编译器需要进行重载解析 (Overload resolution) 以确定调用的是哪个重载函数。简单来说，与调用时函数参数表最为接近的重载将被调用：

1
2
3
4
5

void f(long);
void f(float);

f(0L); // calls f(long)
f(0); // error: ambiguous overload. The complier cannot tell which is better

（Overload resolution - cppreference.com）

对于有多个参数的重载，编译器会选择与函数调用时提供的参数表匹配得最好的那个重载：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <cstdio>

void print(char, int)
{
	printf("a\n");
}

void print(char, double)
{
	printf("b\n");
}

void print(char, float)
{
	printf("c\n");
}

int main()
{
	print('x', 'a');
	return 0;
}

main 函数中调用的 print 将匹配到 void print(char, int)。因为函数调用时，第一个参数'x' 均可以匹配到三个重载的第一个参数 char；对于第二个参数'a'，由于字符类型是一个特殊的整数，所以它和 int 的匹配度是最好的，剩余两个需要转换。所以编译器选择调用匹配度相对最好的 void print(char, int)

27.3.2 引用作为重载参数

使用引用作为参数的函数也可以重载，但有几个注意事项需要注意：

• 编译器无法区分变量及其引用。

  1 2 3 4 5 6 7 8 9 10

  int add(int a, int b){ return a + b; } /* // error: same argument list int add(int& a, int& b){ return a + b; } */

  Overloaded functions differentiate between argument types that take different initializers. Therefore, an argument of a given type and a reference to that type are considered the same for the purposes of overloading. They’re considered the same because they take the same initializers. For example, max( double, double ) is considered the same as max( double &, double & ). Declaring two such functions causes an error.

  ——Function Overloading | Microsoft Learn

• 编译器可以区分一般引用和由 const 修饰的引用。

  1 2 3 4 5 6 7 8

  int add(int& a, int& b){ return a + b; } // okay: the two have different argument list int add(const int& a, const int& b){ return a + b; }

27.3.3 默认参数能不能用于重载？

我们先不去调用函数：

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

#include <cstdio>

void print(int a, int = 10) {
	printf("%d\n", a);
}

void print(int a) {
	printf("%d\n", a);
}

int main(void) {
	//print(10);
	return 0;
}

编译通过！在编译器看来，这两个函数属于重载。

那么我们调用一下函数试试？

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

#include <cstdio>

void print(int a, int = 10) {
	printf("%d\n", a);
}

void print(int a) {
	printf("%d\n", a);
}

int main(void) {
	print(10);
	return 0;
}

好了，VS2022 的 Intellisense 很快啊，输出了一个错误信息：

1

错误(活动)	E0308	有多个重载函数 "print" 实例与参数列表匹配	12

编译器也提示：

1
2
3
4

error C2668: “print”: 对重载函数的调用不明确
可能是“void print(int)”
或“void print(int,int)”
尝试匹配参数列表“(int)”时

当要重载的函数出现默认参数时，可能造成二义性，导致报错，需要避免。

Lesson28 类与对象 - Part1

“类” 是 C++ 一个重要的概念，以至于 C++ 的原型就是 “C with class”(带类的 C)。

The central language feature of C++ is the class.

——A Tour of C++, third edition

28.0 面向对象编程

C++ 是一个面向对象 (Object-oriented) 的语言。它遵循面向对象编程 (Object-oriented programming, OOP) 的编程范式，以对象为中心设计编程语言。我们主要关注三个最重要的概念：封装 (Encapsulation)、继承 (Inheritance) 和多态 (Polymorphism)

有些文章会有其他的表述，例如 Microsoft 认为 OOP 还有一个抽象 (Abstraction) 特征。

与 C++ 不同的是，C 语言是一个典型的过程式 (Procedural) 语言。它关注的是过程，是 “What should the program do next?”(MIT 6.096)，造成了复杂性和不可维护性。OOP 就是解决这种复杂性的一种方案。

在面向对象编程中，所有的实例都是对象，拥有其属性和行为。具有相同性质的对象，可以抽象为类 (Class)。

28.1 封装

28.1.1 封装的意义

宽泛地讲，封装就是把一些数据和信息打包进一个单元里面。在 C++ 中，封装特征的体现就是类。类是一组属性和行为的整合。

（来源：Encapsulation in C++ - GeeksforGeeks）

我们先来写一个类吧。

如果需要定义一个类，我们需要：

1
2
3
4
5

class name {
    access specifier: // 访问权限
    	variables; // 属性
    	methods; // 行为
}; // 注意最后还有一个‘;’

例如，我们希望设计一个 “圆” 类，属性为半径，行为为求该圆周长，则：

1
2
3
4
5
6
7
8

class circle {
    public:
    	int m_r;
    	const double pi = 3.14;
    	double calcCC(){
            return 2 * pi * m_r;
        }
};

我们现在已经创建了一个类，对应一个抽象的 “圆”。但我们还需要一个具体的实例来运用这些类，所以接下来我们创建一个类对象，并赋予属性：

1
2

circle r1;
r1.m_r = 5;

然后输出这个圆的周长：

1

printf("%.2f\n", r1.calcCC());

运行一下：

1

31.40

学生类设计展示：

1
2
3
4
5
6
7
8

class student {
    public:
    	string name;
    	int id;
    	void show_info(){
            printf("%s %d\n", name, id);
        }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>
#include <string>

using namespace std;// 命名空间

class student
{
public:
    string name;// C++支持string类型
    int id;
    void show_info()
    {
        cout << name << ' ' << id << '\n' << endl;// C++的流式输出。注意string类型用流式输出
    }
};

int main(void)
{
    student s1, s2;
    s1.name = "张三";
    s1.id = 114514;
    s2.name = "李四";
    s2.id = 191981;
    s1.show_info();
    s2.show_info();
    getchar();
}

这里有一些 C++ 的新语法没有介绍，可以参考：5.10 — Introduction to std::string – Learn C++；<iostream> | Microsoft Learn

我们可以也可以利用类中的函数为类中的属性赋值：

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

class student {
    public:
    	string N_name;
    	void SetName (string name){
            N_name = name;
        }
};

int main(void){
    student s1;
    s1.SetName("张三");
}

类中的函数可以在类外定义，定义时需要附上该函数的命名空间（可以理解为是类的作用域）：

1
2
3
4
5
6
7

class student {
    public:
    	string N_name;
};
void student::SetName (string name){
    N_name = name;
}

类中的属性和行为统称为成员 (Member)。其中，属性称为 “成员属性” 或 “成员变量”；行为称为 “成员函数” 或 “成员方法”。

考虑命名数据成员时以 “m_” 前缀开头，从而与局部变量、函数参数和成员函数的名称形成区别。

——14.5 — Public and private members and access specifiers – Learn C++

28.1.2 类的访问权限

公园是公共场所，而住宅是私人的。你和其他人可以合法自由地进出公共场所，但只有住宅的成员以及被明确允许进入的人才能进入私人住宅。

——14.5 — Public and private members and access specifiers – Learn C++

类的一大特色就在于它的 “数据保护” 属性。通过为类成员设置不同的访问权限，我们得以保证数据操作是受控且安全的。

C++ 提供了三级访问权限：

• public：类内成员可以访问，类外也可以访问。
• protected：类内成员可以访问，类外不能访问。该类的派生类也可以访问 protected 成员
• private：类内成员可以访问，类外不能访问。派生类不能访问 private 成员

每次访问成员时，编译器都会检查该成员的访问级别。如果访问行为不被允许，编译器将生成编译错误。

1
2
3
4
5
6
7
8

class info {
  public:
    srting m_name;
  protected:
    string m_car;
  private:
    int m_card;
};

不指定访问权限时，类内成员默认为 **private 成员 **。

我们建议，将成员变量的访问权限设为 private（或 protected），成员函数的访问权限设为 public。这被称为信息隐藏 (Information Hiding)。

这样做有以下好处：

• 自主可控的读写权限管理。

  对于可读可写的成员变量，外界可以通过成员函数来写入与读取；对于只读的成员变量，我们可以不提供写入的成员函数；对于只写的成员变量，我们可以不提供读取的成员函数。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  // r:read w:write class info { private: string m_name;// rw int m_card = 3586286477362;// r string m_Idol;// w public: // rw void SetName(string name){ m_name = name; } string GetName(){ cout << m_name << '\n' << endl; } // r int GetCard(){ cout << m_card << '\n' <<endl; } // w void SetIdol(string idol){ m_Idol = idol; } };

• 写入数据前的有效性检查。

  如果对输入的数据有要求，可以在写入时进行检查。

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

  class info{ private: int m_age; public: void SetAge(int age){ if (age < 0 || age > 150){ cout << "Invalid input, please retry.\n" << endl; return;//to end the function } m_age = age; } };

28.1.3 类和结构体的区别

学到这里是不是有一种既视感？我们在 C++ 写的类和在 C 语言写的结构体有十分甚至九分的相像，甚至共用一些名词！

从技术角度来看，结构体和类几乎相同。

——14.2 — Introduction to classes – Learn C++

在 C++ 中，类和结构体唯一的不同就在于其成员默认的访问权限不同。

类内成员的访问权限默认为 private，而结构体内成员的访问权限默认为 public。

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

struct st {
    int a;
};

class cl {
    int b;
};

int main(void){
    st s1;
    s1.a = 10;
    cl c1;
    //c1.b = 10; // error: 无法访问
}

28.1.SP 类设计练习

SP.1 设计立方体类

设计目标：

• 设计一个立方体 (Cube) 类，求出立方体的面积和体积
• 分别用全局函数和成员函数判断两个立方体是否相等

样例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class cube {
    // 属性
    private:
    	int m_L, m_W, m_H; // 立方体的三大属性：长、宽、高
    // 行为
    public:
    	void set_pro (int L, int W, int H) {
            m_L = L;
            m_W = W;
            m_H = H;
        }
    	int calc_s () {
            return 2 * (m_L * m_W + m_L * m_H + m_W * m_H);
        }
    	int calc_v () {
            return m_L * m_W * m_H;
        }
    	bool cmp_cube (cube& c) {
            return (m_L == c.m_L) && (m_W == c.m_W) && (m_H == c.m_H);
        }
    	// 为了使用全局函数，需要再次输出 cube 类对象的属性，还需要写：
    	int get_L () {
    		return m_L;
    	}
    	int get_W () {
    		return m_W;
    	}
    	int get_H () {
    		return m_H;
    	}
};

用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
using namespace std;

void cmp(cube &c1, cube &c2)
{
    if ((c1.get_L() == c2.get_L()) && (c1.get_W() == c2.get_W()) && (c1.get_H() == c2.get_H()))
    {
        cout << "两个立方体相同" << "\n";
    }
    else
    {
        cout << "两个立方体不同" << "\n";
    }
}

int main(void)
{
    cube c1, c2;
    c1.set_pro(1, 2, 3);
    c2.set_pro(2, 3, 4);
    cout << "c1的面积是" << c1.calc_s() << '\n';
    cout << "c1的体积是" << c1.calc_v() << '\n';
    cmp(c1, c2);
    if (c1.cmp_cube(c2))
    {
        cout << "两个立方体相同"
             << endl;
    }
    else
    {
        cout << "两个立方体不同"
             << endl;
    }
}

SP.2 设计点圆类

设计目标：

• 设计一个圆 (crircle) 类和一个点 (point) 类

• 判断圆和点的几何关系

  点 $P$ 和 $⊙A$ 的位置关系有三种：$P$ 在 $⊙A$ 外；$P$ 在 $⊙A$ 内；$P$ 在 $⊙A$ 上。

  设 $P$ 到圆心 $A$ 的距离为 $d$，$⊙A$ 的半径为 $r$，则：

  • $P$ 在 $⊙A$ 外 $\Leftrightarrow$ $d>r$.
  • $P$ 在 $⊙A$ 内 $\Leftrightarrow$ $d<r$.
  • $P$ 在 $⊙A$ 上 $\Leftrightarrow$ $d=r$.

  （来源：圆中的位置关系 | whk wiki）

样例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class circle {
    //属性
    private:
    	int m_x, m_y, m_r;//圆的属性：圆心坐标(x,y)，半径r
    //行为
    public:
    	void set_x (int x) {
            m_x = x;
        }
    	void set_y (int y) {
            m_y = y;
        }
    	void set_r (int r) {
            m_r = r;
        }
    	int get_r () {
            return m_r;
        }
    	int calc_cpd (point& p) {
            return sqrt(pow(m_x-p.m_x, 2)+pow(m_y-p.m_y, 2));
        }
};
class point {
    // 属性
    private:
    	int m_x, m_y; // 圆的属性：坐标(x,y)
    // 行为
    public:
    	void set_x (int x) {
            m_x = x;
        }
    	void set_y (int y) {
            m_y = y;
        }
}

用法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
#include <cmath>
using namespace std;

int main(void) {
    circle c1;
    point p1;
    c1.set_x(1);
    c1.set_y(2);
    c1.set_r(4);
    p1.set_x(6);
    p1.set_y(3);
    if (c1.calc_cpd(p1) == c1.get_r()) {
        cout << "点在圆上" << "\n";
    }
    else if (c1.calc_cpd(p1) > c1.get_r()) {
        cout << "点在圆外" << "\n";
    }
    else {
        cout << "点在圆内" << "\n";
    }
}