为什么需要泛型编程?

想象一下,我们在超市买东西,每次排队结账的时候,如果每种商品都要去不同的柜台排队,是不是很麻烦?泛型编程就像是一个“万能收银台”,让不同类型的商品(在这里指的是数据类型)都可以在一个地方处理,大大提高了效率。

一文搞懂泛型编程的方法和原理_Java

在静态语言中,比如C++或Java,我们经常需要对不同类型的数据执行相同的操作。如果为每一种数据类型都编写一遍处理逻辑,比如集合、字典、排序等,不仅会导致代码量大增,而且也不经济。泛型编程的出现,就是为了解决这一问题。

在编程语言的发展历程中,不同语言对范型编程做了各种各样的支持和尝试,下面我们就做个总结介绍。

C语言中的泛型编程尝试

使用void*指针

在C语言中,我们可以用void*指针来实现对不同数据类型的通用处理。就像一把万能钥匙,它可以打开任何锁,但是万能钥匙也有它的问题:

  • 没有类型检查:你不会知道这把钥匙究竟打开了哪个锁。
  • 处理数组困难:就像万能钥匙难以区分哪些锁是连在一起的。
  • 内存操作复杂:需要自己控制内存拷贝和比较,就像万能钥匙需要自己调整形状一样,非常容易出错。

使用宏

宏是C语言中的一种功能,可以让你写一些看起来像是通用代码的东西。它就像是一张能写任何内容的空白支票。但是,宏也有它的缺点:

  • 无法做类型检查:这张支票上可以写任何数字,但是并不知道这些数字是否合法。
  • 参数为表达式或函数时,宏替换会导致重复执行:就像你不小心在支票上写了两遍数字,钱就会被取走两次。
  • 无法调试:当支票出了问题,你也不容易找到问题所在。

数据结构适配问题

在C语言中,想要让泛型编程适配各种数据结构非常复杂,因为每种数据结构在内存分配和释放、对象复制方式上都有所不同。这就像试图制作一个能适应所有人脚型的鞋子,几乎是不可能的。

C语言的例子

这里我提供一个简单的例子,使用void*指针来创建一个泛型的数组排序函数。

首先,我们需要一个比较函数的原型,这个比较函数需要能够比较两个任意类型的元素:

// 返回值为正数、零或负数,分别表示第一个参数大于、等于或小于第二个参数
int compare(const void* a, const void* b);

接下来,我们定义一个冒泡排序函数:

// 泛型冒泡排序函数
void genericBubbleSort(void* array, size_t length, size_t size, int (*compare)(const void*, const void*)) {
    char temp[size]; // 临时存储元素的空间,大小等于数组元素的大小
    for (size_t i = 0; i < length - 1; ++i) {
        for (size_t j = 0; j < length - i - 1; ++j) {
            void* a = (char*)array + j * size;
            void* b = (char*)array + (j + 1) * size;
            if (compare(a, b) > 0) {
                // 如果a > b,则交换两个元素
                memcpy(temp, a, size);
                memcpy(a, b, size);
                memcpy(b, temp, size);
            }
        }
    }
}

如果我们要排序一个整数数组,还要定义一个整数比较函数:

int intCompare(const void* a, const void* b) {
    int arg1 = *(const int*)a;
    int arg2 = *(const int*)b;
    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
}

最后,我们可以使用这个泛型排序函数来排序任何类型的数组:

int main() {
    int intArray[] = {42, 23, 4, 16, 8, 15};
    size_t intLength = sizeof(intArray) / sizeof(intArray[0]);
    
    // 使用泛型排序函数和整数比较函数对整数数组进行排序
    genericBubbleSort(intArray, intLength, sizeof(intArray[0]), intCompare);
    
    // 打印排序后的数组
    for (size_t i = 0; i < intLength; i++) {
        printf("%d ", intArray[i]);
    }
    
    return 0;
}

C++中泛型编程的实现

一文搞懂泛型编程的方法和原理_排序算法_02

泛型编程的典范:STL

C++的标准模板库(STL)是泛型编程的最早实现之一,它提供了算法的泛型、类型的泛型和数据结构的泛型。STL就像是一个工具箱,里面有各种工具,可以处理各种类型的“修理”工作。

类和模板

在C++中,类和模板是实现泛型编程的两大工具:

  • 类:通过构造函数、析构函数、拷贝构造函数等标准化内存的分配、释放和复制。类似于给每个数据类型定制了一套“操作手册”。
  • 模板:模板允许你编写类型无关的代码,就像填写一份“任何类型都适用”的表格。编译器会根据使用的类型来“填充”这份表格,生成专属代码。

另外C++中还引入了一种迭代器机制,让程序能够以统一的方式遍历各种数据容器,就像是一个通用的“遥控器”,可以控制所有类型的“电视”。

空间换时间

在C++中,泛型编程符合“不要重复自己”(DRY)原则。你只需要写一遍代码,就可以用于多种数据类型。但是编译时,编译器会将这些代码展开,为不同的数据类型生成特定的代码,所以使用范性时编译出的文件可能会增大不少,但是这样执行效率更高。这是一种空间换时间的策略。

这就像是有一个自动化的工厂,输入原材料(类型),然后生产出各种产品(专用代码)。

C++的范性排序例子

这个例子使用模板函数来实现一个简单的插入排序算法。

// 模板函数,实现插入排序
template <typename T>
void insertionSort(std::vector<T>& vec) {
    for (size_t i = 1; i < vec.size(); ++i) {
        T key = vec[i];
        int j = i - 1;

        // 将vec[i]插入到已排序的序列vec[0..i-1]中
        while (j >= 0 && vec[j] > key) {
            vec[j + 1] = vec[j];
            --j;
        }
        vec[j + 1] = key;
    }
}

// 辅助函数,用于打印vector中的元素
template <typename T>
void printVector(const std::vector<T>& vec) {
    for (const T& val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> intVector = {42, 23, 4, 16, 8, 15};
    std::vector<float> floatVector = {3.14, 1.59, 2.65, 3.58};

    // 对整数vector进行排序
    insertionSort(intVector);
    printVector(intVector);

    // 对浮点数vector进行排序
    insertionSort(floatVector);
    printVector(floatVector);

    return 0;
}

在这个例子中,我们定义了一个insertionSort函数模板,它接受一个类型为std::vector;的引用,其中T是一个占位符,可以是任何类型。当你调用insertionSort函数时,编译器会根据传入的实际类型自动生成对应的函数实例,一个处理int,另一个处理float。

模板提供了类型安全和代码重用的优势,这是C语言中泛型编程所不具备的。

虚拟机语言中的泛型实现

Java中的泛型

一文搞懂泛型编程的方法和原理_Java_03

Java对泛型的支持在语言、类型系统和编译器方面有了较大的发展。在Java中,开发者可以使用类型参数化的方式定义类、接口和方法。这让代码更加可读、灵活,并增加了类型安全性,减少了运行时的类型错误。

此外,Java还提供了类型推断的功能,使得在声明变量或方法参数时可以省略类型参数,编译器会自动推断类型参数。

看个例子:

import java.util.Arrays;
import java.util.List;
public class QuickSort {
    public static <T extends Comparable<T>> void quickSort(List<T> list) {
        quickSort(list, 0, list.size() - 1);
    }
    private static <T extends Comparable<T>> void quickSort(List<T> list, int left, int right) {
        if (left < right) {
            int pivotIndex = partition(list, left, right);
            quickSort(list, left, pivotIndex - 1);
            quickSort(list, pivotIndex + 1, right);
        }
    }
    private static <T extends Comparable<T>> int partition(List<T> list, int left, int right) {
        T pivot = list.get(left);
        int i = left;
        int j = right;
        while (i < j) {
            while (i < j && list.get(j).compareTo(pivot) >= 0) {
                j--;
            }
            list.set(i, list.get(j));
            while (i < j && list.get(i).compareTo(pivot) <= 0) {
                i++;
            }
            list.set(j, list.get(i));
        }
        list.set(i, pivot);
        return i;
    }
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 9, 1);
        List<String> words = Arrays.asList("Java", "Python", "C++", "JavaScript");
        // 对整数列表进行快速排序
        quickSort(numbers);
        System.out.println(numbers);
        // 对字符串列表进行快速排序
        quickSort(words);
        System.out.println(words);
    }
}

Java泛型的局限性

Java 泛型的默认实现方式仍然是类型擦除,也就是说,泛型信息不会被保留到运行时。这种做法就像是在编写脚本时使用了某种特效,但是实际上演时并不会出现这种特效,它只是为了编写时的方便。

实际擦除时,编译器泛型类型参数会被替换为它们的上边界(如果没有指定上边界,则替换为 Object),举个例子:

// 泛型类
public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

擦除后,Box会变成:

public class Box {
    private Object content;

    public void setContent(Object content) {
        this.content = content;
    }

    public Object getContent() {
        return content;
    }
}

类型擦除导致Java泛型有一些局限性,比如:

  • 性能不会提升:因为实际上并没有为不同的基本数据类型生成专用代码。
  • 通过反射可以绕过编译器限制:这就像是在舞台背后悄悄改变了道具,观众并不知情。
  • 泛型数组的问题:你不能创建泛型数组,因为类型信息在运行时是不可用的,这就像是你不能在没有模具的情况下制作形状各异的糖果。

C#中的泛型

相比Java的语法糖,C#语言在开发、编译、运行时都支持泛型,它提供了真正的泛型支持。

上边Java的代码用C#实现:

using System;
using System.Collections.Generic;
public class QuickSort
{
    public static <T> void QuickSort<T>(List<T> list) where T : IComparable<T>
    {
        QuickSort(list, 0, list.Count - 1);
    }

    private static <T> void QuickSort<T>(List<T> list, int left, int right) where T : IComparable<T>
    {
        if (left < right)
        {
            int pivotIndex = Partition(list, left, right);
            QuickSort(list, left, pivotIndex - 1);
            QuickSort(list, pivotIndex + 1, right);
        }
    }

    private static <T> int Partition<T>(List<T> list, int left, int right) where T : IComparable<T>
    {
        T pivot = list[left];
        int i = left;
        int j = right;
        while (i < j)
        {
            while (i < j && list[j].CompareTo(pivot) >= 0)
            {
                j--;
            }
            list[i] = list[j];
            while (i < j && list[i].CompareTo(pivot) <= 0)
            {
                i++;
            }
            list[j] = list[i];
        }
        list[i] = pivot;
        return i;
    }

    public static void Main()
    {
        List<int> numbers = new List<int> { 5, 2, 8, 9, 1 };
        List<string> words = new List<string> { "Java", "Python", "C++", "JavaScript" };
        // 对整数列表进行快速排序
        QuickSort(numbers);
        Console.WriteLine(numbers);
        // 对字符串列表进行快速排序
        QuickSort(words);
        Console.WriteLine(words);
    }
}

看起来和Java代码差不多,但是编译时不会做泛型擦除。在C#中,泛型可以在开发、编译和运行时提供真正的类型安全,因为编译器会强制检查类型参数的一致性。

C#泛型的展开逻辑

但是我们要清楚计算机执行的机器码中可没有泛型,泛型代码最终还是要展开为具体的类型,并翻译为相应的机器码。在.NET平台,这件事是虚拟机干的。针对int、double等基本数据类型,虚拟机会为每一种类型生成具体的算法程序实例,也就是说针对使用了基本数据类型的泛型代码,用了多少种基本数据类型,就会有多少种实例,这样处理更高效,因为值类型不需要装箱和拆箱。对于引用类型,虚拟机只会生成一个统一的算法程序实例,所有的引用类型共享这个实例,这样比较节省内存空间,也减少了即时编译的开销。

Go语言中的泛型

Go是在1.18版本开始支持泛型的,在此之前一直通过 interface{} 实现类似泛型的能力,不过它需要在运行时进行断言判断,还有类型转换的开销,代码上也不够优雅。

Go语言中的泛型是通过类型参数实现的。类型参数定义在函数或类型(如结构体、接口、切片等)之上,允许在声明时不指定具体的类型,而是在使用时指定。

举个例子:

package main

import "fmt"

// 泛型函数,用于交换两个值
func Swap[T any](a, b T) (T, T) {
    return b, a
}

func main() {
    // 使用泛型函数
    a, b := 42, "Hello"
    swappedA, swappedB := Swap(a, b)

    fmt.Printf("Original: %d, %s\n", a, b)
    fmt.Printf("Swapped: %d, %s\n", swappedA, swappedB)
}

Go是完全的静态语言,虽然有垃圾回收,但是没有虚拟机。Go中的泛型实例是在编译时展开的,类似C#的泛型实例化结果,对于每个不同的值类型,编译器会生成一个独立的泛型实例,对于引用类型的泛型实例,只需要生成一次,然后在需要时进行复制或传递引用,这样可以节省内存并避免重复的实例化开销。

动态语言中的泛型

完全动态语言(如JavaScript和Python)由于其类型系统的特性,对泛型的支持与静态类型语言(如C#和Java)有所不同。在动态语言中,变量通常不需要在编译时声明其类型,因此,函数和数据结构可以更自然地处理不同类型的数据,而无需显式的泛型机制。

JavaScript本身并不支持泛型,但是它的超集TypeScript是支持泛型的,而且还支持接口。

// 定义一个泛型函数,接受一个参数并返回与参数相同类型的数组
function identity<T>(arg: T): T {
    return arg;
}

// 使用泛型函数
let resultString: string = identity("Hello, TypeScript!");
let resultNumber: number = identity(42);

console.log(resultString);  // 输出: Hello, TypeScript!
console.log(resultNumber);  // 输出: 42

Python3.5之后,引入了类型提示(Type Hints)和typing模块,可以用来指示函数预期接受和返回的类型,这为Python增加了一种类似泛型的能力。看一下Python的例子:

from typing import List, TypeVar

T = TypeVar('T')  # 声明一个类型变量

def print_list(items: List[T]) -> None:
    for item in items:
        print(item)

# 可以传入任意类型的列表
print_list([1, 2, 3])           # 输出: 1 2 3
print_list(['apple', 'banana', 'cherry']) # 输出: apple banana cherry

在这个例子中,我们使用了TypeVar来定义一个类型变量T,然后使用 List[T] 指示 print_list 接受任何类型的列表。这样的类型提示让我们的代码更可读、可维护,同时也支持类型检查器(如mypy)对代码进行静态类型检查。

总结下,在动态语言中选择性地使用泛型,可以获得更多的类型安全和可维护性。

结论

泛型编程让我们可以用一套代码来处理多种数据类型,它提高了代码的复用性,减少了重复劳动。每种语言实现泛型的方式各有特色,但都是为了让编程更加高效和简洁。不过,每种实现都有其优缺点,了解这些可以帮助我们更好地选择和使用泛型编程。

关注萤火架构,提升技术不迷路!