everystep

在编写程序时，我们应该尽可能地让编译器在编译阶段就能检测出类型错误，而不是在运行时才发现。

为什么？

这种做法的主要原因有以下几点：

提前发现错误：如果在编译阶段就能发现类型错误，那么我们就可以在程序运行之前修复这些错误，避免程序在运行时崩溃。

提高代码质量：静态类型检查可以帮助我们编写更安全、更健壮的代码。因为编译器会在编译阶段检查我们的代码，确保我们没有进行不安全的类型转换或者使用错误的类型。

提高开发效率：如果在编译阶段就能发现错误，那么我们就不需要花费大量的时间在调试程序上。这可以大大提高我们的开发效率。

提高程序性能：静态类型语言通常可以生成更优化的代码，因为编译器在编译阶段就知道了所有变量的类型。这可以提高程序的运行效率。

总的来说，静态类型安全可以帮助我们提前发现错误，提高代码质量和开发效率，以及提高程序性能。

有哪些具体措施？

联合：联合（Union）是一种可以存储不同类型数据的变量，但是一次只能存储其中一种类型的数据。在C++中，使用联合可能会导致类型安全问题。例如：

union Data {
   int i;
   float f;
   char str[20];
} data;

data.i = 10;  // 此时，data中存储的是int类型的数据
data.f = 220.5;  // 现在，data中存储的是float类型的数据，之前的int类型数据被覆盖

在C++17中，我们可以使用std::variant来替代联合，它是类型安全的：

std::variant<int, float, std::string> data;
data = 10;  // 存储int类型的数据
data = 220.5f;  // 存储float类型的数据，不会覆盖之前的数据

强制转换：强制转换可能会导致类型安全问题，因为它可以将任何类型的数据转换为任何其他类型的数据。在C++中，我们应该尽量避免使用强制转换，而是使用模板来实现类型安全的转换。

数组衰减：在C++中，当数组作为函数参数时，它会自动转换（衰减）为指向数组首元素的指针，这可能会导致类型安全问题。我们可以使用gsl::span来替代原生数组，它可以保持数组的大小信息，从而避免数组衰减：

void foo(gsl::span<int> arr) {
    // 使用arr，它包含数组的大小信息
}

int arr[10];
foo(arr);  // 传递数组到函数，不会发生数组衰减

范围错误：当我们访问数组或其他容器时，如果索引超出了容器的范围，就会发生范围错误。我们可以使用gsl::span来避免范围错误，因为它会在访问超出范围的元素时抛出异常。

缩小转换：缩小转换是指将一个大范围的类型转换为小范围的类型，这可能会导致数据丢失或溢出。我们应该尽量避免使用缩小转换，如果必须使用，可以使用gsl::narrow或gsl::narrow_cast来进行安全的缩小转换：

int i = gsl::narrow<int>(1234567890L);  // 安全的缩小转换，如果数据丢失或溢出，会抛出异常

以上就是关于静态类型安全的一些具体措施，希望对你有所帮助。

有哪些只能在运行时检查的例子？

然而在编译期检查出所有错误是不可能的，有些情况只能放到运行时做检查。

例如下的例子，以数组传递为例：

    extern void f(int* p);

    void g(int n)
    {
        f(new int[n]);
    }

这段代码中，函数 g 创建了一个动态数组，并将数组的首地址传递给了函数 f。然而，这里存在一个问题，那就是 f 函数并不知道这个数组的大小。这是因为在 C++ 中，原生数组并不知道自己的大小，而且这个信息也没有被传递给 f 函数。

这种设计使得错误检测变得非常困难。静态分析可能无法确定数组的大小，因为这个信息在编译时并不可用。同时，如果 f 函数是一个应用二进制接口（ABI）的一部分，那么在运行时进行动态检查也可能非常困难，因为我们不能添加额外的信息来帮助我们跟踪这个指针。

一种可能的解决方案是将数组的大小信息嵌入到自由存储中，但这需要对系统和可能对编译器进行全局更改，这可能是不可行的。

因此，这段代码展示了一个不良的设计，它使得错误检测变得非常困难。在实际编程中，我们应该尽量避免这种设计。例如，我们可以使用标准库中的 std::vector 或 std::array，这些容器知道自己的大小，并且可以安全地传递给其他函数。

增加参数

下面这段代码中，函数 g2 创建了一个动态数组，并将数组的首地址和大小一起传递给了函数 f2。这种做法比仅传递数组的首地址要好，因为它使得 f2 函数能够知道数组的大小。

    extern void f2(int* p, int n);

    void g2(int n)
    {
        f2(new int[n], m);  
    }

然而，这里仍然存在一个问题。在调用 f2 函数时，传递的数组大小是 m，而不是 n。这是一个拼写错误，但是它可能会引入一个严重的错误。因为 m 可能并不等于 n，所以 f2 函数可能会以错误的大小来处理数组，这可能会导致数组越界等问题。

此外，这段代码还暗示了 f2 函数应该负责删除它接收的数组。这是因为数组是在 g2 函数中通过 new 创建的，但是并没有在 g2 函数中被删除。如果 f2 函数并没有删除这个数组，那么这个数组就会成为一个内存泄漏。这是一个设计问题，因为它使得内存管理的责任变得不清晰。

总的来说，这段代码展示了一种将数组的大小和首地址一起传递的做法，这种做法比仅传递数组的首地址要好。然而，它也展示了一些可能的问题，包括拼写错误和内存管理的问题。在实际编程中，我们应该尽量避免这些问题。例如，我们可以使用标准库中的 std::vector，这个容器可以自动管理内存，并且它的大小是明确的，可以安全地传递给其他函数。

使用智能指针

这段代码中，函数 g3 创建了一个动态数组，并使用 std::unique_ptr 来管理这个数组的内存。然后，它将这个 std::unique_ptr 和数组的大小一起传递给了函数 f3。

    extern void f3(unique_ptr<int[]>, int n);

    void g3(int n)
    {
        f3(make_unique<int[]>(n), m);   
    }

std::unique_ptr 是一个智能指针，它可以自动管理它所指向的内存。当 std::unique_ptr 被销毁时，它会自动删除它所指向的内存。这样可以避免内存泄漏的问题。

然而，这里仍然存在一个问题。在调用 f3 函数时，传递的数组大小是 m，而不是 n。这是一个拼写错误，但是它可能会引入一个严重的错误。因为 m 可能并不等于 n，所以 f3 函数可能会以错误的大小来处理数组，这可能会导致数组越界等问题。

此外，这段代码将数组的所有权和大小分别传递给了 f3 函数。这意味着 f3 函数需要同时管理这个数组的内存和大小。这可能会使得代码变得复杂，因为 f3 函数需要同时处理内存管理和数组大小的问题。

总的来说，这段代码展示了一种使用 std::unique_ptr 来管理动态数组的内存的做法，这种做法可以避免内存泄漏的问题。然而，它也展示了一些可能的问题，包括拼写错误和将数组的所有权和大小分别传递的问题。在实际编程中，我们应该尽量避免这些问题。例如，我们可以使用标准库中的 std::vector，这个容器可以自动管理内存，并且它的大小是明确的，可以安全地传递给其他函数。

使用 vector

这段代码中，函数 g3 创建了一个 std::vector<int> 对象 v，并将其传递给了函数 f4。std::vector 是一个动态数组，它知道自己的大小，并且可以自动管理内存。

    extern void f4(vector<int>&);   
    extern void f4(span<int>);      

    void g3(int n)
    {
        vector<int> v(n);
        f4(v);                     
        f4(span<int>{v});          
    }

在这里，f4 函数有两个重载版本。一个接受 std::vector<int>& 作为参数，另一个接受 std::span<int> 作为参数。std::span 是一个轻量级的对象，它可以视为一个数组或其他类型的连续序列的视图。它包含一个指向序列开始的指针和一个表示序列大小的值。

在 g3 函数中，首先调用了接受 std::vector<int>& 参数的 f4 函数。这个调用将 v 的引用传递给 f4，这意味着 f4 可以访问和修改 v，但是 v 的所有权仍然在 g3 函数中。

然后，调用了接受 std::span<int> 参数的 f4 函数。这个调用创建了一个 std::span 对象，它是 v 的视图，然后将这个视图传递给 f4。这意味着 f4 可以访问 v，但是不能修改 v，并且 v 的所有权仍然在 g3 函数中。

这种设计将数组的大小和首地址作为一个整体对象进行传递，这可以避免一些错误，例如拼写错误和内存管理的问题。同时，由于 std::vector 和 std::span 都知道自己的大小，所以可以在运行时进行动态检查。

参数返回值传递方式

这段代码中，函数 f5、f6 和 f7 都创建了一个大小为 n 的数组，并返回这个数组。这些函数的目的都是传递数组的所有权，但是它们的实现方式和效果是不同的。

    vector<int> f5(int n)    
    {
        vector<int> v(n);
        // ... 初始化 v ...
        return v;
    }

函数 f5 创建了一个 std::vector<int> 对象 v，并返回这个对象。std::vector 是一个动态数组，它知道自己的大小，并且可以自动管理内存。当 v 被返回时，它的所有权会被移动到调用者那里，这是通过移动语义实现的。这种做法是安全的，因为 std::vector 会自动删除它所管理的内存，所以不会出现内存泄漏的问题。同时，由于 std::vector 知道自己的大小，所以调用者可以安全地使用这个数组。

    unique_ptr<int[]> f6(int n)   
    {
        auto p = make_unique<int[]>(n);
        // ... 初始化 *p ...
        return p;
    }

函数 f6 创建了一个 std::unique_ptr<int[]> 对象 p，并返回这个对象。std::unique_ptr 是一个智能指针，它可以自动管理它所指向的内存。然而，这里存在一个问题，那就是 p 并不知道它所指向的数组的大小。这是因为在 C++ 中，原生数组并不知道自己的大小，而 std::unique_ptr 也没有提供一种方式来获取这个大小。因此，调用者需要以某种方式知道这个数组的大小，否则它可能会以错误的方式来使用这个数组。

    owner<int*> f7(int n)    
    {
        owner<int*> p = new int[n];
        // ... 初始化 *p ...
        return p;
    }

函数 f7 创建了一个原生数组，并返回这个数组的首地址。这个首地址被封装在一个 owner<int*> 对象中，这个对象的目的是表明返回的指针是一个所有权指针，也就是说，调用者需要负责删除这个数组。然而，这里存在两个问题。首先，和 f6 函数一样，返回的指针并不知道它所指向的数组的大小。其次，虽然 owner<int*> 表明了返回的指针是一个所有权指针，但是它并没有提供一种自动删除数组的机制，所以调用者可能会忘记删除这个数组，这会导致内存泄漏的问题。

总的来说，这段代码展示了三种传递数组所有权的做法。其中，f5 函数的做法是最好的，因为它可以安全地传递数组的所有权，并且可以保证调用者知道数组的大小。f6 和 f7 函数的做法存在一些问题，主要是它们丢失了数组的大小信息，而 f7 函数还可能导致内存泄漏的问题。在实际编程中，我们应该尽量避免这些问题，例如，我们可以使用 std::vector 或其他知道自己大小的容器来代替原生数组。

参考

1. C++ Core Guidelines.