PRF&PUB

@mengxinayan
https://linux.cn/article-13498-1.html

published/20210222 A friendly guide to the syntax of C-- method pointers.md

@@ -1,35 +1,36 @@
 [#]: collector: (lujun9972)
 [#]: translator: (mengxinayan)
-[#]: reviewer: ( )
-[#]: publisher: ( )
-[#]: url: ( )
+[#]: reviewer: (wxy)
+[#]: publisher: (wxy)
+[#]: url: (https://linux.cn/article-13498-1.html)
 [#]: subject: (A friendly guide to the syntax of C++ method pointers)
 [#]: via: (https://opensource.com/article/21/2/ccc-method-pointers)
 [#]: author: (Stephan Avenwedde https://opensource.com/users/hansic99)
 
 C++ 类成员函数指针语法的友好指南
 ======
-一旦您理解了一般原则，C++ 类成员函数指针不再那么令人生畏。
 
-![Person drinking a hot drink at the computer][1]
+> 一旦你理解了一般原则，C++ 类成员函数指针不再那么令人生畏。
 
-如果您正在寻找性能、复杂性或许多可能的解决方法来解决问题，那么 [C++][2] 总是一个很好的选择。当然，功能通常伴随着复杂性，但是一些 C++ 的特性几乎难以分辨。根据我的观点，C++ 的 [类成员函数指针](3) 也许是我接触过的最复杂的表达式，但是我会先从一些较简单的开始。
+![](https://img.linux.net.cn/data/attachment/album/202106/18/104200rm48h22eghehg2p3.jpg)
+
+如果你正在寻找性能、复杂性或许多可能的解决方法来解决问题，那么在涉及到极端的情况下，[C++][2] 总是一个很好的选择。当然，功能通常伴随着复杂性，但是一些 C++ 的特性几乎难以分辨。根据我的观点，C++ 的 [类成员函数指针][3] 也许是我接触过的最复杂的表达式，但是我会先从一些较简单的开始。
 
 文章中的例子可以在我的 [Github 仓库][4] 里找到。
 
 ### C 语言：函数指针
 
-让我们先从一些基础开始：假设您有一个函数接收两个整数作为参数返回一个整数：
+让我们先从一些基础开始：假设你有一个函数接收两个整数作为参数返回一个整数：
 
-```c
+```
 int sum(int a, int b) {
     return a+b;
 }
 ```
 
-在纯 C 语言中，您可以创建一个指向这个函数的指针，将其分配给您的 `sum(...)` 函数，通过解引用来调用它。函数的签名（参数、返回类型）必须符合指针的签名。除此之外，一个函数指针表现和普通的指针相同：
+在纯 C 语言中，你可以创建一个指向这个函数的指针，将其分配给你的 `sum(...)` 函数，通过解引用来调用它。函数的签名（参数、返回类型）必须符合指针的签名。除此之外，一个函数指针表现和普通的指针相同：
 
-```c
+```
 int (*funcPtrOne)(int, int);
 
 funcPtrOne = ∑
@@ -37,9 +38,9 @@ funcPtrOne = ∑
 int resultOne = funcPtrOne(2, 5);
 ```
 
-如果您使用指针作为参数并返回一个指针，这会显得很丑陋：
+如果你使用指针作为参数并返回一个指针，这会显得很丑陋：
 
-```c
+```
 int *next(int *arrayOfInt){
     return ++arrayOfInt;
 }
@@ -55,9 +56,9 @@ C 语言中的函数指针存储着子程序的地址。
 
 ### 指向类成员函数的指针
 
-让我们来进入 C++：好消息是您也许不需要使用类成员函数指针，除非在一个特别罕见的情况下，像接下来的例子。首先，您已经知道定义一个类和其中一个成员函数：
+让我们来进入 C++：好消息是你也许不需要使用类成员函数指针，除非在一个特别罕见的情况下，比如说接下来的例子。首先，你已经知道定义一个类和其中一个成员函数：
 
-```cpp
+```
 class MyClass
 {
 public:
@@ -69,42 +70,42 @@ public:
 };
 ```
 
-#### 1\. 定义一个指针指向某一个类中一个成员函数
+#### 1、定义一个指针指向某一个类中一个成员函数
 
-声明一个指针指向 `MyClass` 类成员函数。在此时，您并不知道想调用的具体函数。您仅仅声明了一个指向 `MyClass` 类中任意成员函数的指针。当然，签名（参数、返回值类型）需要匹配您接下想要调用的 `sum(...)` 函数：
+声明一个指针指向 `MyClass` 类成员函数。在此时，你并不知道想调用的具体函数。你仅仅声明了一个指向 `MyClass` 类中任意成员函数的指针。当然，签名（参数、返回值类型）需要匹配你接下想要调用的 `sum(...)` 函数：
 
-```cpp
+```
 int (MyClass::*methodPtrOne)(int, int);
 ```
 
-#### 2\. 赋值给一个具体的函数
+#### 2、赋值给一个具体的函数
 
 为了和 C 语言（或者 [静态成员函数][5]）对比，类成员函数指针不需要指向绝对地址。在 C++ 中，每一个类中都有一个虚拟函数表（vtable）用来储存每个成员函数的地址偏移量。一个类成员函数指针指向 vtable 中的某个条目，因此它也只存储偏移值。这样的原则使得 [多态][6] 变得可行。
 
-因为 `sum(...)` 函数的签名和您的指针声明匹配，您可以赋值签名给它：
+因为 `sum(...)` 函数的签名和你的指针声明匹配，你可以赋值签名给它：
 
-```cpp
+```
 methodPtrOne = &MyClass::sum;
 ```
 
-#### 3\. 调用成员函数
+#### 3、调用成员函数
 
-如果您想使用指针调用一个类成员函，您必须提供一个类的实例：
+如果你想使用指针调用一个类成员函，你必须提供一个类的实例：
 
-```cpp
+```
 MyClass clsInstance;
 int result = (clsInstance.*methodPtrOne)(2,3);
 ```
 
-您可以使用 `.` 操作符来访问，使用 `*` 对指针解引用，通过提供两个整数作为调用函数时的参数。这是丑陋的，对吧？但是您可以进一步应用。
+你可以使用 `.` 操作符来访问，使用 `*` 对指针解引用，通过提供两个整数作为调用函数时的参数。这是丑陋的，对吧？但是你可以进一步应用。
 
 ### 在类内使用类成员函数指针
 
-假设您正在创建一个带有后端和前端的 [客户端/服务器][7] 原理架构的应用程序。您现在并不需要关心后端，相反的，您将基于 C++ 类的前端。前端依赖于后端提供的数据完成初始化，所以您需要一个额外的初始化机制。同时，您希望通用地实现此机制，以便将来可以使用其他初始化函数（可能是动态的）来拓展您的前端。
+假设你正在创建一个带有后端和前端的 [客户端/服务器][7] 原理架构的应用程序。你现在并不需要关心后端，相反的，你将基于 C++ 类的前端。前端依赖于后端提供的数据完成初始化，所以你需要一个额外的初始化机制。同时，你希望通用地实现此机制，以便将来可以使用其他初始化函数（可能是动态的）来拓展你的前端。
 
 首先定义一个数据类型用来存储初始化函数（`init`）的指针，同时描述何时应调用此函数的信息（`ticks`）：
 
-```cpp
+```
 template<typename T>
 struct DynamicInitCommand {
     void (T::*init)();     // 指向额外的初始化函数
@@ -114,7 +115,7 @@ struct DynamicInitCommand {
 
 下面一个 `Frontend` 类示例代码：
 
-```cpp
+```
 class  Frontend
 {
 public:
@@ -131,8 +132,6 @@ public:
         m_dynamicInit.push_back(init3);
     }
    
-   
-
     void  tick(){
         std::cout << "tick: " << ++m_ticks << std::endl;
        
@@ -174,9 +173,9 @@ private:
 };
 ```
 
-在 `Frontend` 完成实例化后，`tick()` 函数会被后端以固定的时间时间调用。例如，您可以每 200 毫秒调用一次：
+在 `Frontend` 完成实例化后，`tick()` 函数会被后端以固定的时间时间调用。例如，你可以每 200 毫秒调用一次：
 
-```cpp
+```
 int  main(int  argc, char*  argv[]){
     Frontend frontendInstance;
 
@@ -187,7 +186,7 @@ int  main(int  argc, char*  argv[]){
 }
 ```
 
-`Fronted` 有三个额外的初始化函数，它们必须根据 `m_ticks` 的值来选择调用哪个。在 tick 等于何值调用哪个初始化函数的信息存储在数组 `m_dynamicInit` 中。在构造函数（`Frontend()`）中，将此信息附加到数组中，以便在 5、10 和 15 个 tick 后调用其他初始化函数。当后端调用 `tick()` 函数时，`m_ticks` 值会递增，同时遍历数组 `m_dynamicInit` 以检查是否必须调用初始化函数。
+`Fronted` 有三个额外的初始化函数，它们必须根据 `m_ticks` 的值来选择调用哪个。在 ticks 等于何值调用哪个初始化函数的信息存储在数组 `m_dynamicInit` 中。在构造函数（`Frontend()`）中，将此信息附加到数组中，以便在 5、10 和 15 个 tick 后调用其他初始化函数。当后端调用 `tick()` 函数时，`m_ticks` 值会递增，同时遍历数组 `m_dynamicInit` 以检查是否必须调用初始化函数。
 
 如果是这种情况，则必须通过引用 `this` 指针来取消引用成员函数指针：
 
@@ -197,9 +196,9 @@ int  main(int  argc, char*  argv[]){
 
 ### 总结
 
-如果您并不熟悉类成员函数指针，它们可能会显得有些复杂。我做了很多尝试和经历了很多错误，花了一些时间来找到正确的语法。然而，一旦你理解了一般原理后，方法指针就变得不那么可怕了。
+如果你并不熟悉类成员函数指针，它们可能会显得有些复杂。我做了很多尝试和经历了很多错误，花了一些时间来找到正确的语法。然而，一旦你理解了一般原理后，方法指针就变得不那么可怕了。
 
-这是迄今为止我在 C++ 中发现的最复杂的语法。 您还知道更糟糕的吗？ 在评论中发布您的观点！
+这是迄今为止我在 C++ 中发现的最复杂的语法。 你还知道更糟糕的吗？ 在评论中发布你的观点！
 
 --------------------------------------------------------------------------------
 
@@ -208,7 +207,7 @@ via: https://opensource.com/article/21/2/ccc-method-pointers
 作者：[Stephan Avenwedde][a]
 选题：[lujun9972][b]
 译者：[萌新阿岩](https://github.com/mengxinayan)
-校对：[校对者ID](https://github.com/校对者ID)
+校对：[wxy](https://github.com/wxy)
 
 本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出