4

是否存在任何语言：

  • 是静态（强）类型的
  • 支持泛型（模板）
  • 支持特征/多重继承/接口委托
  • 允许函数重载（也允许继承成员）

基本上，在伪代码中，我想要这个：

class Template<SomeType> { void function(SomeType i) {} }
class Composed extends Template<int>, Template<double> { };
Composed composed;
composed.function(3); //calls function(int)
composed.function(2.5); //calls function(double)

从 wiki 列表http://en.wikipedia.org/wiki/Multiple_inheritance#Implementations我尝试用以下编程语言编写代码（我还包括最新的尚未发布的 1.0 版本（2013）语言，如 Kotlin、锡兰）：

  • C++几乎是可能的，但无法解析组合变量的重载函数
  • Scala编译错误：trait 继承了两次；即使被间接继承欺骗，它仍然会产生错误；另请参阅其他人关于 Scala 中的多个泛型 mixin 继承的问题
  • Eiffel编译错误：没有函数重载
  • Ceylon trait 不能有变量（并且没有受保护的成员，因此在派生类中存储数据没有技巧，Ceylon 中的特征是无用的）
  • Fantom没有泛型/模板
  • Kotlin编译错误：超类型出现两次；委托看起来很独特，但它没有用，因为既不能访问受保护的成员，也不能访问委托给的变量
  • Rust没有函数重载；trait 不能存储数据；特征不能有定义的方法（带有主体） - 正在处理的问题；
  • OCaml编译错误：没有函数重载；它也没有检查我的函数的参数类型，那么它到底有多“静态类型”？！
  • curl编译错误：没有函数重载；它也不会检查函数体，除非它被调用，那么它到底是如何“静态类型化”的呢？它是完全编译的还是解释的？！
  • Gosu是一个糟糕的笑话，它根本不可用：不能用一种方法编写和实现简单的接口（错误：ClassFormatError: Illegal field modifiers）。谁真正使用这种语言？！

顺便说一句：当我尝试将 Java 对侦听器的支持放入单独的类时，我想到了这个问题（在许多类中有： List<ListenerType> ... addListener(...) ... removeListener(...) )

C++几乎可以工作：

template <typename T>
class Template { public: void function(T i) {} };
class Composed : public Template<int>, public Template<double> { };

Composed composed;
composed.Template<int>::function(3); //i want: composed.function(3);
((Template<double>&)composed).function(2.5); //i want: composed.function(2.5);

编辑：在 C++ 中，问题是继承函数隐藏。另请参阅 派生类中具有相同名称但签名不同的函数 和 为什么派生类中的重写函数会隐藏基类的其他重载？

编辑 2：在 C++ 中，使用模板和部分专业化，有可能使用肮脏的技巧来更简单地使用特征：

#include <iostream>
#include <typeinfo>

class Void { };
template <class A, class B> class CleverTrait;
template <class A, class B> class CleverTrait;
template <class A> class CleverTrait<A, Void>
{
public:
    void function(A arg) { std::cout << "Hello for type " << typeid(A).name() << std::endl; }
};
template <class A, class B> class CleverTrait<A, CleverTrait<B, Void> > : public CleverTrait<B, Void>
{
public:
    using CleverTrait<B, Void>::function;
    void function(A arg) { std::cout << "Hello for type " << typeid(A).name() << std::endl; }
};

class ComposedByClever : public CleverTrait<double, CleverTrait<int, Void> > { };

int main()
{
    ComposedByClever composedByClever;
    composedByClever.function(5);
    composedByClever.function(2.3);
    return 0;
}

这意味着C++ 中的这个特定示例有效，但是如果不相关的特征共享函数名，则无法在 C++ 中继承和使用所有函数。

编辑 3：我还应该检查任何支持 mixins 的编程语言：http ://en.wikipedia.org/wiki/Mixins#Programming_languages_that_use_mixins

  • D可以工作，但只能通过字符串操作 mixin，因此在这种情况下会破坏重构：mixin(GenerateSomething!("IfClassNameHereManualRenaming"));

编辑 4：添加“Gosu”语言注释。

编辑 5：Gosu 编程语言已更新 0.10.2，修复了接口损坏问题。然而，即使他们声称已经具体化了泛型和委托，委托+具体化的泛型也不起作用。

4

1 回答 1

2

C++：类似于 CRTP 的奇怪想法（请参阅对 OP 的评论）我的意思是更像：

#include <typeinfo>
#include <iostream>

struct Dummy
{
private:
  // dummy type to prevent overload resolution from ever choosing this overload
    struct ParamDummy { explicit ParamDummy(); };
public:
    void function(ParamDummy);
};

template<typename T, typename Base = Dummy>
struct Template
    : Base
{
    using Base::function;
    void function(T i) { std::cout << typeid(T).name() << std::endl; }
};

struct SecondBaseClass
{
    void function2() { std::cout << "function2" << std::endl; }
};

struct Composed
    : Template<int, Template<double>>, SecondBaseClass
{};

int main()
{
    Composed c;
    c.function(5.0);
    c.function(5);
    c.function2();
}

对于 中的每个不同的成员函数名称Template，您需要一个using指令。因此，数量仅取决于当前类中成员函数的数量，而不取决于基类。

它在某些方面与多重继承不同，但它允许简单的函数重载。

如果基类只共享一些但不是所有的成员函数，那就更棘手了。

于 2013-07-26T10:31:03.533 回答