Language agnostic 还有哪些其他语言支持；部分专业化；？ 部分模板特化是C++中泛型编程的重要概念之一。例如：要实现通用交换功能： template <typename T> void swap(T &x, T &y) { const T tmp = x; y = x; x = tmp; } template <typename T> void bar(T x) { // stuff... foo(x); // more stuff... } 模板 无效掉期（T&x、T&y）{ 常数T tmp=x； y=x； x=tmp； }

要将其专门化为支持O（1）交换的向量，请执行以下操作：

模板
无效交换（向量&x，向量&y）{x.swap（y）；}

因此，在泛型函数中调用swap（x，y）时，始终可以获得最佳性能

非常感谢，如果您可以在其他语言中发布等价的（或者如果语言不支持交换概念，则发布语言部分专门化的规范示例）

编辑：看来许多回答/评论的人真的不知道什么是部分专门化，而通用交换示例似乎妨碍了一些人的理解。一个更一般的例子是：

template <typename T>
void foo(T x) { generic_foo(x); }

template <typename T>
void foo(vector<T> x) { partially_specialized_algo_for_vector(x); }

void foo(vector<bool> bitmap) { special_algo_for_bitmap(bitmap); }

swap :: a -> b -> (b,a)
swap a b = (b, a)

模板
void foo（tx）{generic_foo（x）；}

部分专业化将是：

template <typename T>
void foo(T x) { generic_foo(x); }

template <typename T>
void foo(vector<T> x) { partially_specialized_algo_for_vector(x); }

void foo(vector<bool> bitmap) { special_algo_for_bitmap(bitmap); }

swap :: a -> b -> (b,a)
swap a b = (b, a)

模板
void foo（向量x）{u向量（x）的部分算法}

完整的专业化将是：

template <typename T>
void foo(T x) { generic_foo(x); }

template <typename T>
void foo(vector<T> x) { partially_specialized_algo_for_vector(x); }

void foo(vector<bool> bitmap) { special_algo_for_bitmap(bitmap); }

swap :: a -> b -> (b,a)
swap a b = (b, a)

void foo（矢量位图）{u位图（位图）的特殊算法}

为什么这很重要？因为您可以在泛型函数中调用foo（任何内容）：

template <typename T>
void swap(T &x, T &y) {
  const T tmp = x;
  y = x;
  x = tmp;
}

template <typename T>
void bar(T x) {
  // stuff...
  foo(x);
  // more stuff...
}

模板
空心钢筋（T x）{
//东西。。。
foo（x）；
//更多的东西。。。
}

并在编译时获得最合适的实现。这是C++实现抽象W/最小性能惩罚的一种方法。

---

希望这有助于澄清“部分专业化”的概念。在某种程度上，这是C++如何在不需要显式模式匹配语法的情况下（例如OcAML/Fα中的匹配关键字）来进行模式匹配，这有时会妨碍泛型编程。p> Java有泛型，它允许您做类似的事情。

C\

恐怕C#不支持部分模板专门化

部分模板专门化意味着：

您有一个具有两个或多个模板（泛型/类型参数）的基类。 类型参数将是

在派生（专用）类中，指示其中一个类型参数的类型。 类型参数可以如下所示

---

因此，当有人使用（实例化）最后一个类型参数为int的类时，将使用派生类。

Haskell将重叠实例作为扩展：

class Sizable a where
  size :: a -> Int

instance Collection c => Sizable c where
  size = length . toList

是一个查找任何集合大小的函数，该集合可以有更具体的实例：

instance Sizable (Seq a) where
  size = Seq.length

另请参见。

实际上，您可以（不完全可以；请参见下文）使用扩展方法在C#中完成此操作：

public Count (this IEnumerable<T> seq) {
    int n = 0;
    foreach (T t in seq)
        n++;
    return n;
}

public Count (this T[] arr) {
    return arr.Length;
}

支持部分专门化：

• （用C++ 98和0x）.

（在上面的链接中扫描“部分”）

<>第二个链接特别会给你一个非常详细的细分，你可以用模板特化来做，不仅在D中，而且在C++中。 下面是一个特定于D的

交换的示例。它应该为
对象
类的专用交换打印消息

import std.stdio;    // for writefln

// Class with swap method

class Thing(T)
{
public:

    this(T thing)
    {
        this.thing = thing;
    }

    // Implementation is the same as generic swap, but it will be called instead.
    void swap(Thing that)
    {
       const T tmp = this.thing;
       this.thing = that.thing;
       that.thing = tmp;
    }

public:

    T thing;
}


// Swap generic function

void swap(T)(ref T lhs, ref T rhs)
{
    writefln("Generic swap.");

    const T tmp = lhs;
    lhs = rhs;
    rhs = tmp;
}

void swap(T : Thing!(U))(ref T lhs, ref T rhs)
{
    writefln("Specialized swap method for Things.");

    lhs.swap(rhs);
}

// Test case

int main()
{
    auto v1 = new Thing!(int)(10);
    auto v2 = new Thing!(int)(20);

    assert (v1.thing == 10);
    assert (v2.thing == 20);
    swap(v1, v2);
    assert (v1.thing == 20);
    assert (v2.thing == 10);

    return 0;
}

很抱歉，Java泛型已经瘫痪，甚至无法完成类似的工作。在Java中，任何泛型类都可以在O（1）时间内实现swap。但是这里没有部分专门化。swap在Haskell中没有意义，因为变量是不可变的。你能再举一个在其他语言中有意义的例子吗？Lisp中的通用交换将使用宏：（defmacro swap（xy）`（let（（z，x））（setf，x，y）（setf，y，z）））不能通过指定S:int的位置来约束派生类中的S吗？否；您需要这样做，以便任何时间基类都可以用
S==int
实例化，而派生类则被实例化；C++版本在编译时也被解析，所以这并不太遥远。当您从泛型类中调用Count，而编译器不知道您在调用它的类型时，问题就开始了。C++在那里做得更好，因为它延迟了决定，直到它知道所有的类型。谢谢你的例子。顺便说一句，你不认为swap（t:Thing！（U），U）（…）真的应该是swap（t:Thing！（U））（…）。附加的“U”似乎不合适。是的，你是对的。在编译完成之前，我从一个源文件中剪切并粘贴了它（真实世界的竞赛条件：P）。修正了。我担心您列出的所有内容都不符合部分专门化的条件，因为您不能部分专门化模板函数，只能对类进行专门化。公平地说，只有在考虑为用户定义的模板化类型扩展名称空间std时，才会出现这种情况。（允许您专门从事，但不超载于STD）见有效的C++项目25或这篇文章。放下它，这只是一个关于函数重载和查找规则的问题。