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

import Foundation

// 泛型函数 + 协议约束
func largest<T: Comparable>(_ xs: [T]) -> T {
    var max = xs[0]
    for x in xs where x > max { max = x }
    return max
}
// where 子句约束多个参数
func pair<A, B>(_ a: A, _ b: B) -> String
    where A: CustomStringConvertible, B: CustomStringConvertible { "\(a)/\(b)" }
// some：不透明返回类型，具体类型由实现决定、对外隐藏
func evens() -> some Sequence<Int> { [2, 4, 6] }
// any：existential，运行时装箱，每个元素都带元数据
func total(_ s: any Sequence<Int>) -> Int { s.reduce(0, +) }

struct Stack<Element> {
    private var storage: [Element] = []
    mutating func push(_ e: Element) { storage.append(e) }
    var top: Element? { storage.last }
}
// 主要关联类型（Swift 5.7+）：Collection<Int> 直接写出元素类型
func countInts<C: Collection<Int>>(_ c: C) -> Int { c.count }

print(largest([3, 7, 2]))                    // 7
print(pair(1, "a"))                          // 1/a
print(Array(evens()))                        // [2, 4, 6]
print(total([1, 2, 3]))                      // 6
var st = Stack<Int>(); st.push(9)
print(st.top!)                               // 9
print(countInts([1, 2, 3]))                  // 3
let boxed: any Collection = [1, 2]
print(boxed.count)                           // 2

 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

package main

import "fmt"

// 1.18+：类型参数写在方括号里，约束是一个接口
func Sum[T int | float64](xs []T) T {
	var total T
	for _, x := range xs { total += x }
	return total
}

// 约束接口可以复用：union 只允许出现在约束位置
type Number interface{ ~int | ~int64 | ~float64 } // ~ 表示"底层类型是"

// 约束也可以带方法，方法是类型集与调用能力同时具备
type Stringer interface {
	~string
	fmt.Stringer
}

// Go 1.27：具体类型的方法可以声明自己的类型参数
type Box[T any] struct{ v T }

func (b Box[T]) Map[R any](f func(T) R) Box[R] { return Box[R]{f(b.v)} }

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))       // 6
	fmt.Println(Sum([]float64{1.5, 2.5}))  // 4
	fmt.Println(Box[int]{3}.Map(func(i int) string { return fmt.Sprint(i * 2) })) // {6}
	var s fmt.Stringer = nil
	_ = s
}

 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

from typing import Protocol, TypeVar, Callable

T = TypeVar("T")                       # 传统写法：TypeVar + 上界用 bound=
TNum = TypeVar("TNum", bound=int)      # 约束上界

# Protocol：结构化约束（鸭子类型的静态版）
class Sized(Protocol):
    def __len__(self) -> int: ...

# PEP 695（3.12+）：类型参数写在名字后面
class Stack[T]:
    def __init__(self) -> None:
        self._items: list[T] = []
    def push(self, item: T) -> None: self._items.append(item)
    def pop(self) -> T: return self._items.pop()

def first[T](xs: list[T]) -> T: return xs[0]

type Pair[T] = tuple[T, T]             # 3.12+ 泛型类型别名

print(first([1, 2, 3]))                # 1
s: Stack[int] = Stack()
s.push(1); s.push(2)
print(s.pop())                         # 2
print(Stack.__type_params__)           # (T,)
print(Stack[int])                      # __main__.Stack[int]
print(first(["a", "b"]))               # a

 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

// 声明处协变：Producer<Dog> 可以当 Producer<Animal> 用
interface Producer<out T> { fun produce(): T }
// 声明处逆变：Consumer<Animal> 可以当 Consumer<Dog> 用
interface Consumer<in T> { fun consume(item: T) }

// 多个上界用 where，且只能有一个类上界
fun <T> render(item: T): String where T : CharSequence, T : Comparable<T> = item.toString()

// reified：必须 inline，才能在运行时使用 T
inline fun <reified T> isOf(value: Any): Boolean = value is T
inline fun <reified T> typeName(): String = T::class.qualifiedName ?: "?"

class Stack<T : Any> {                       // 非空上界
    private val items = mutableListOf<T>()
    fun push(item: T) { items.add(item) }
    fun pop(): T = items.removeAt(items.size - 1)
}

fun main() {
    val p: Producer<Any> = object : Producer<String> { override fun produce() = "s" }
    println(p.produce())        // s
    println(isOf<String>("a"))  // true
    println(isOf<Int>("a"))     // false
    println(typeName<List<Int>>())  // kotlin.collections.List
    println(Stack<Int>().apply { push(1) }.pop())  // 1
}

 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

import java.util.List;
import java.util.ArrayList;

// 上界用 extends，多个上界用 &（类必须在最前）
class Repo<T extends Number & Comparable<T>> {
    private final List<T> items = new ArrayList<>();
    void add(T t) { items.add(t); }
    // 静态方法不能使用类的类型参数，必须自己声明
    static <U> U first(List<U> xs) { return xs.get(0); }
    // 通配符：? extends 只读（Producer）
    static double sum(List<? extends Number> src) {
        double s = 0;
        for (Number n : src) s += n.doubleValue();
        return s;
    }
    // 通配符：? super 只写（Consumer）
    static void fill(List<? super Integer> dst) { dst.add(1); }
}

// Java 25+ 紧凑源文件：实例 main 不需要类外壳
void main() {
    Repo<Integer> r = new Repo<>();
    r.add(3);
    System.out.println(Repo.first(List.of(1, 2, 3)));      // 1
    System.out.println(Repo.sum(List.of(1, 2, 3)));        // 6.0
    List<Number> dst = new ArrayList<>();
    Repo.fill(dst);
    System.out.println(dst.size());                        // 1
    // src.add(1) 与 Integer x = dst.get(0) 都不合法，见下方说明

    // 类型参数推断：菱形运算符 + 目标类型
    List<String> empty = new ArrayList<>();
    System.out.println(empty.size());                      // 0
}

 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 <concepts>
#include <cstdio>
#include <string>
#include <vector>

// 类型参数 + concept 约束
template <std::integral T>
T twice(T v) { return v + v; }

// requires 子句表达复合要求
template <class T>
    requires requires(T a, T b) { a + b; }
auto add(T a, T b) { return a + b; }

// 非类型模板参数（C++20 起支持浮点与类类型）
template <std::size_t N>
struct Fixed { int data[N]; };

// 可变参数模板：递归展开的经典写法
template <class... Ts>
std::size_t countArgs(Ts... ) { return sizeof...(Ts); }

// 偏特化：只为指针类型换一套实现
template <class T> struct Describe { static const char* name() { return "value"; } };
template <class T> struct Describe<T*> { static const char* name() { return "pointer"; } };

int main() {
    std::printf("%d\n", twice(21));                       // 42
    std::printf("%d\n", add(1, 2));                       // 3
    std::printf("%zu\n", sizeof(Fixed<4>));               // 16
    std::printf("%zu\n", countArgs(1, 2.0, "x"));         // 3
    std::printf("%s\n", Describe<int>::name());           // value
    std::printf("%s\n", Describe<int*>::name());          // pointer
}

 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

#include <stdio.h>
#include <stdlib.h>

/* _Generic：编译期按类型选表达式，等价于"宏版重载" */
#define type_name(x) _Generic((x),      \
    int: "int", long: "long",           \
    double: "double", char *: "char *", \
    default: "other")

/* 参数化宏：把类型名当参数传进去，文本展开出一堆同名函数 */
#define DECLARE_SUM(name, type) type name(type x, type y) { return x + y; }
DECLARE_SUM(sum_i, int)
DECLARE_SUM(sum_d, double)

/* void*：容器能装任何东西，但类型标签得自己带 */
typedef struct { void *data; size_t elem; size_t len; } AnyVec;

static int cmp_int(const void *a, const void *b) {
    return (*(const int *)a) - (*(const int *)b);
}

int main(void) {
    printf("%s %s %s\n", type_name(1), type_name(1.0), type_name("x"));
    /* int double char * */
    printf("%d %.1f\n", sum_i(1, 2), sum_d(1.5, 2.5));   /* 3 4.0 */
    int xs[5] = {3, 1, 4, 1, 5};
    qsort(xs, 5, sizeof xs[0], cmp_int);   /* 泛型算法靠函数指针补回类型 */
    AnyVec v = { xs, sizeof(int), 5 };
    printf("%zu %d\n", v.len, ((int *)v.data)[4]);        /* 5 5 */
    return 0;
}

 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

abstract type Animal end
struct Dog <: Animal end
struct Cat <: Animal end

# 参数化类型：字段类型由参数决定
struct Box{T}
    value::T
end

# where 子句约束类型参数
speak(x::T) where {T<:Animal} = "$(T) speaks"
# 抽象元素类型的容器：靠 Union 或抽象类型
struct Zoo{T<:Animal}
    animals::Vector{T}
end

# 抽象类型的容器可以放任意子类型
zoo = Animal[Dog(), Cat()]
println(length(zoo))              # 2
println(speak(Dog()))             # Dog speaks
b = Box(42)
println(typeof(b))                # Box{Int64}
println(b.value)                  # 42
println(Vector{Int} <: Vector{Real})   # false —— 参数化类型不变
println(Vector{Int} <: AbstractVector) # true  —— 抽象类型才有子类型关系
println(Box{Int} <: Box)               # true  —— UnionAll 是上界

 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
36
37
38
39
40
41
42
43
44
45

using System;
using System.Numerics;
using System.Collections.Generic;

// 基类 / 接口 / 构造 / 非空：约束用 where 写在类型参数后面
class Repo<T> where T : notnull, IComparable<T>, new()
{
    public T Create() => new T();          // new() 才能这样写
    public int Compare(T a, T b) => a.CompareTo(b);
}

static class Demo
{
    // 泛型数学：static abstract 成员（.NET 7 起）
    public static T Sum<T>(T[] xs) where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
    {
        T total = T.AdditiveIdentity;
        foreach (var x in xs) total += x;
        return total;
    }
    // 非托管约束：只有它才能对 T 用 sizeof
    public static int SizeOf<T>() where T : unmanaged => sizeof(T);
    // 泛型方法自己声明类型参数
    public static U Map<T, U>(T v, Func<T, U> f) => f(v);
    // 具体化的直接证据：typeof(T) 在运行时给出真实类型
    public static Type TypeOfT<T>() => typeof(T);
    public static T Zero<T>() where T : struct => default(T);
}

class Empty { }

class Program
{
    static void Main()
    {
        Console.WriteLine(Demo.Sum(new[] { 1, 2, 3 }));      // 6
        Console.WriteLine(Demo.Sum(new[] { 1.5, 2.5 }));     // 4
        Console.WriteLine(Demo.Map(3, x => x.ToString()));   // 3
        Console.WriteLine(Demo.TypeOfT<List<int>>());        // System.Collections.Generic.List`1[System.Int32]
        Console.WriteLine(Demo.Zero<int>());                 // 0
        Console.WriteLine(Demo.SizeOf<long>());              // 8
        Console.WriteLine(new Repo<string>().Compare("a", "b") < 0);   // True
        Console.WriteLine(new Repo<Empty>().Create() is Empty);        // True
    }
}

 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

// 上界用 extends；默认上界是 Object?，写 Object 表示非空
class Cache<T extends Object> {
  final _store = <String, T>{};
  void set(String k, T v) => _store[k] = v;
  T? get(String k) => _store[k];
}

// F-bounds：上界引用自己（自引用类型参数）
abstract class Comparable2<T extends Comparable2<T>> {
  int compareTo(T other);
}

// 泛型方法自己声明类型参数
T first<T>(List<T> xs) => xs.first;
Map<K, V> group<K, V>(List<V> xs, K Function(V) key) =>
    {for (final x in xs) key(x): x};

void main() {
  final c = Cache<String>();
  c.set('a', 'x');
  print(c.get('a'));                 // x
  print(first([1, 2, 3]));           // 1
  print(group([1, 2, 3], (x) => x.isEven).length);  // 2
  final xs = <String>['a'];
  print(xs is List<String>);         // true —— reified，能看到类型实参
  print(xs is List<int>);            // false
  print(<Object>[] is List<String>); // false
}

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

# S3 泛型函数：函数体只写 UseMethod，具体实现按第一个参数的 class 找
speak <- function(x, ...) UseMethod("speak")

speak.default <- function(x, ...) "unknown"
speak.dog <- function(x, ...) "woof"
speak.cat <- function(x, ...) "meow"

d <- structure(list(), class = "dog")
print(speak(d))                    # [1] "woof"

# NextMethod：沿 class 向量继续向下分派
speak.puppy <- function(x, ...) paste("small", NextMethod())
p <- structure(list(), class = c("puppy", "dog"))
print(speak(p))                    # [1] "small woof"

# 没有类型参数，用 do.call 把函数名当字符串来"参数化"
apply_fun <- function(fname, args) do.call(fname, args)
print(apply_fun("sum", list(1:3)))  # [1] 6
print(inherits(d, "dog"))           # [1] TRUE

 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

const std = @import("std");

// comptime 类型参数：T 是编译期已知的 type 值
fn twice(comptime T: type, x: T) T {
    return x + x;
}

// anytype：形参类型由调用点推断，必须在函数体内自证可用
fn show(x: anytype) void {
    const T = @TypeOf(x);
    switch (@typeInfo(T)) {
        .int, .comptime_int => std.debug.print("int {}\n", .{x}),
        .float, .comptime_float => std.debug.print("float {}\n", .{x}),
        else => std.debug.print("other {s}\n", .{@typeName(T)}),
    }
}

// 结构化"约束"：编译期检查字段是否存在，否则报错
fn firstField(x: anytype) @TypeOf(x[0]) {
    comptime {
        if (@typeInfo(@TypeOf(x)) != .array and @typeInfo(@TypeOf(x)) != .pointer)
            @compileError("need an array or slice, got " ++ @typeName(@TypeOf(x)));
    }
    return x[0];
}

pub fn main() void {
    std.debug.print("{}\n", .{twice(i32, 21)});   // 42
    show(1);                                     // int 1
    show(1.5);                                   // float 1.5
    std.debug.print("{}\n", .{firstField([_]i32{ 7, 8 })}); // 7
}

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

-- 没有类型参数，表可以装任何东西
local function push(list, v) list[#list + 1] = v end
local function map(list, f)
  local out = {}
  for i, v in ipairs(list) do out[i] = f(v) end
  return out
end

local mixed = {}
push(mixed, 1); push(mixed, "a"); push(mixed, 2.5)
print(#mixed, mixed[2], math.type(mixed[1]))   -- 3	a	integer

local doubled = map({1, 2, 3}, function(x) return x * 2 end)
print(table.concat(doubled, ","))              -- 2,4,6

-- 元表：用 __index / __add 把"类型行为"绑到值上
local Vec = {}
Vec.__index = Vec
Vec.__add = function(a, b) return setmetatable({x = a.x + b.x}, Vec) end
Vec.__tostring = function(v) return "Vec(" .. v.x .. ")" end
local v = setmetatable({x = 1}, Vec) + setmetatable({x = 2}, Vec)
print(tostring(v))                             -- Vec(3)
print(type(v), getmetatable(v) == Vec)         -- table	true

 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

// 泛型 + 约束 + 默认类型参数
function pick<T extends object, K extends keyof T = keyof T>(obj: T, keys: K[]): Pick<T, K> {
  const out: Partial<T> = {};
  for (const k of keys) out[k] = obj[k];   // Partial<T> 写入合法
  return out as Pick<T, K>;
}

// 条件类型 + infer：在类型层面做模式匹配
type ElementOf<T> = T extends readonly (infer U)[] ? U : never;
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;

// 映射类型 + 键重映射
type Getters<T> = { [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] };

// const 类型参数（TS 5.0）：字面量不被拓宽
function tuple<const T extends readonly unknown[]>(xs: T): T { return xs; }

const p = pick({ a: 1, b: "x" }, ["a"]);
console.log(p);                                   // { a: 1 }
const t = tuple([1, "a"]);                        // 类型是 readonly [1, "a"]
console.log(t);                                   // [1, 'a']
type E = ElementOf<string[]>;                     // string
type F = Flatten<number[][][]>;                   // number
type G = Getters<{ a: number }>;                  // { getA: () => number }
console.log(typeof pick);                         // function（泛型没留下任何痕迹）

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

// JSDoc 的泛型注释：编辑器/tsc --checkJs 能读，运行时是纯注释
/**
 * @template T
 * @param {T[]} xs
 * @returns {T}
 */
function first(xs) { return xs[0]; }

/**
 * @template {{ id: number }} T
 * @param {T[]} xs
 * @returns {Map<number, T>}
 */
function indexById(xs) {
  const m = new Map();
  for (const x of xs) m.set(x.id, x);
  return m;
}

console.log(first([1, 2, 3]));                       // 1
console.log(first(["a"]));                           // a
console.log(indexById([{ id: 1 }, { id: 2 }]).get(2)); // { id: 2 }
console.log(typeof first, first.length);             // function 1
console.log(first.toString().includes("@template")); // false：注释不进函数体

 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

<?php
declare(strict_types=1);

/**
 * @template T
 */
final class Stack
{
    /** @var list<T> */
    private array $items = [];

    /** @param T $item */
    public function push(mixed $item): void { $this->items[] = $item; }

    /** @return T */
    public function pop(): mixed { return array_pop($this->items); }
}

/**
 * @template T
 * @param list<T> $xs
 * @param callable(T): bool $keep
 * @return list<T>
 */
function filterList(array $xs, callable $keep): array {
    return array_values(array_filter($xs, $keep));
}

$s = new Stack();
$s->push(1);
echo $s->pop(), PHP_EOL;                       // 1
// PHPStan 会报错：Parameter #1 $item of method Stack<int>::push() expects int, string given
$s->push("oops");
echo implode(",", filterList([1, 2, 3, 4], fn(int $x): bool => $x % 2 === 0)), PHP_EOL; // 2,4
echo (new ReflectionClass(Stack::class))->getMethods()[0]->getName(), PHP_EOL; // pop

 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

# 没有类型参数：容器装什么都行，方法能不能响应由运行时决定
class Stack
  def initialize = @items = []
  def push(x) = @items.push(x)
  def pop = @items.pop
  def each(&blk) = @items.each(&blk)
  include Enumerable            # 混入 Enumerable 就白得 map/select/sum
end

s = Stack.new
s.push(1); s.push("a"); s.push(2.5)
puts s.pop                    # 2.5
puts s.map(&:class).inspect   # [Integer, String]

# 约束 = 检查方法是否存在，而不是检查类
def describe(x)
  if x.respond_to?(:each)
    "iterable(#{x.each.count})"
  else
    "scalar(#{x.class})"
  end
end
puts describe([1, 2, 3])      # iterable(3)
puts describe(42)             # scalar(Integer)

begin
  [1, "a"].sum                # 只有运行到这里才炸
rescue TypeError => e
  puts "#{e.class}: #{e.message}"   # TypeError: String can't be coerced into Integer
end

 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

class Animal { func speak() -> String { "..." } }
class Dog: Animal { override func speak() -> String { "woof" } }

// 数组元素类型是协变的（编译器特例，Int → Any 这种装箱转换也成立）
func feed(_ xs: [Animal]) -> Int { xs.count }

// 函数类型：返回位置协变 —— (Animal) -> Dog 可当 (Animal) -> Animal 用
let makeDog: (Animal) -> Dog = { _ in Dog() }
let makeAnimal: (Animal) -> Animal = makeDog
// 函数类型：参数位置逆变 —— (Animal) -> Void 可当 (Dog) -> Void 用
let handleAny: (Animal) -> Void = { _ in }
let handleDog: (Dog) -> Void = handleAny

protocol Producer {
    associatedtype Output
    func produce() -> Output
}
struct DogProducer: Producer { func produce() -> Dog { Dog() } }

let dogs: [Dog] = [Dog(), Dog()]
print(feed(dogs))                       // 2  ✅ 数组协变
print(makeAnimal(Dog()).speak())        // woof
handleDog(Dog())
let p: any Producer = DogProducer()
print(type(of: p.produce()))            // Dog

 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

package main

import "fmt"

type Animal interface{ Speak() string }
type Dog struct{}

func (Dog) Speak() string { return "woof" }

func feed(xs []Animal) int { return len(xs) }

func main() {
	dogs := []Dog{{}, {}}
	// 🛑 编译错误：cannot use dogs (variable of type []Dog) as []Animal value
	// fmt.Println(feed(dogs))

	// ✅ 唯一的办法：逐个装箱成接口值
	xs := make([]Animal, len(dogs))
	for i, d := range dogs { xs[i] = d }
	fmt.Println(feed(xs)) // 2

	// 接口之间也没有子类型传递：值满足就行，不需要声明
	var a any = 1
	fmt.Println(a) // 1
}

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

from typing import TypeVar, Generic

T_co = TypeVar("T_co", covariant=True)            # 只出现在返回位置
T_contra = TypeVar("T_contra", contravariant=True)  # 只出现在参数位置
T = TypeVar("T")                                   # 不变

class Box(Generic[T]):
    def get(self) -> T: ...
class Producer(Generic[T_co]):
    def get(self) -> T_co: ...
class Consumer(Generic[T_contra]):
    def put(self, item: T_contra) -> None: ...

# 运行时不检查型变，也不检查类型实参
box: Box[int] = Box()
box2: Box[str] = box          # ⚠️ 静态检查器报错，运行时照样通过
print(type(box).__name__, box2 is box)   # Box True

def needs_ints(xs: list[int]) -> int: return len(xs)
print(needs_ints([1, 2]))      # 2

 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

// 声明处协变：Producer<Dog> 就是 Producer<Animal> 的子类型
interface Producer<out T> { fun produce(): T }
// 声明处逆变：Consumer<Animal> 就是 Consumer<Dog> 的子类型
interface Consumer<in T> { fun consume(item: T) }

open class Animal
class Dog : Animal()

fun feedAll(animals: List<Animal>) = animals.size

fun main() {
    val dogs: List<Dog> = listOf(Dog())
    println(feedAll(dogs))                  // 1  ✅ List 是协变的

    // 使用处型变（类型投影）：把 MutableList 当只读视图传出去
    val src: MutableList<Dog> = mutableListOf(Dog())
    println(feedAll(src))                   // 1  ✅ MutableList<Dog> → List<Animal>

    // 星投影 List<*> 等价于 List<out Any?>：只能读，不能写
    val anys: List<Any?> = listOf(1, "a")
    println(anys.size)                      // 2

    // Nothing 是所有类型的子类型，可以安全地放进任何协变位置
    val empty: List<Nothing> = emptyList()
    println(feedAll(empty))                 // 0
}

 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

import java.util.ArrayList;
import java.util.List;

void main() {
    // 数组协变：编译通过，运行时报错
    Object[] objects = new String[1];
    try {
        objects[0] = 42;                 // 🛑 ArrayStoreException
    } catch (ArrayStoreException e) {
        System.out.println("ArrayStoreException");   // ArrayStoreException
    }

    // 泛型不变：List<String> 不是 List<Object>
    List<String> strs = new ArrayList<>();
    // List<Object> objs = strs;         // 🛑 编译错误

    // ? extends：读取端（Producer）
    List<? extends Number> src = List.of(1, 2, 3);
    double sum = 0;
    for (Number n : src) sum += n.doubleValue();
    System.out.println(sum);             // 6.0
    // src.add(1);                       // 🛑 编译器不知道具体元素类型

    // ? super：写入端（Consumer）
    List<? super Integer> dst = new ArrayList<Number>();
    dst.add(1);
    System.out.println(dst.size());      // 1
    // Integer x = dst.get(0);           // 🛑 取出来只有 Object
}

 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

#include <cstdio>
#include <functional>
#include <vector>

struct Base { virtual ~Base() = default; virtual const char* name() const { return "Base"; } };
struct Derived : Base { const char* name() const override { return "Derived"; } };

static void takesBase(const Base& b) { std::printf("called with %s\n", b.name()); }

int main() {
    // 1. 类层次自带协变：只有指针/引用是子类型载体
    Derived d;
    Base* p = &d;
    std::printf("%s\n", p->name());            // Derived

    // 2. 模板实例之间没有型变
    std::vector<Derived> vd(2);
    // std::vector<Base> vb = vd;   // 🛑 no viable conversion from 'vector<Derived>'
    std::vector<Base*> vp;                     // 要异构就存指针或引用
    for (auto& x : vd) vp.push_back(&x);
    std::printf("%zu\n", vp.size());           // 2

    // 3. 函数指针类型不变
    // void (*bad)(const Derived&) = takesBase;   // 🛑 type mismatch at 1st parameter

    // 4. std::function 靠可调用性检查完成转换（此处参数逆变成立）
    std::function<void(const Base&)> fb = takesBase;
    std::function<void(const Derived&)> fd = fb;
    fd(d);                                     // called with Derived
    return 0;
}

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

#include <stdio.h>

struct Base { int kind; };
struct Derived { struct Base base; int extra; };   /* 手动模拟"继承" */

int main(void) {
    int a = 7;
    void *p = &a;                /* 任何对象指针 → void*：隐式、无检查 */
    printf("%d\n", *(int *)p);   /* 7 */

    /* 指针的指针不协变：int** 不能当 void** */
    int *pa = &a;
    /* void **pp = &pa; */       /* ⚠️ 违反严格别名规则，编译器会警告 */
    void *pp = &pa;              /* 只能升一层，再往下转要显式 */
    printf("%d\n", **(int **)pp);/* 7 */

    /* 结构体嵌套是唯一的"子类型"手段 */
    struct Derived d = { { 1 }, 2 };
    struct Base *b = &d.base;    /* 首成员地址相同，是刻意的约定 */
    printf("%d %d\n", b->kind, d.extra);  /* 1 2 */
    return 0;
}