Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

596 lines (481 sloc) 12.258 kB
Ddoc
$(COMMUNITY $(B D) vs Other Languages,
$(BLOCKQUOTE William Nerdspeare,
To D, or not to D.
)
$(P This table is a quick and rough list of various features of
$(B D)
that can be used to compare with other languages.
While many capabilities are available with standard libraries, this
table is for features built in to the core language itself.
$(LINK2 builtin.html, Rationale).
)
<table border=2 cellpadding=4 cellspacing=0 class="comp">
<caption>D Language Feature Comparison Table</caption>
<thead>
$(TR
<th>Feature</th>
<th align="center"><a href="index.html" title="D Programming Language" target="_top">$(B D)</a></th>
)
</thead>
<tbody>
$(TR
$(TD <a href="#GarbageCollection">Garbage Collection</a>)
$(YES1 garbage.html)
)
$(TR
<th colspan="6" align="left"> Functions</th>
)
$(TR
$(TD Function delegates)
$(YES1 type.html#delegates)
)
$(TR
$(TD Function overloading)
$(YES1 function.html#function-overloading)
)
$(TR
$(TD Out function parameters)
$(YES1 function.html#parameters)
)
$(TR
$(TD Nested functions)
$(YES1 function.html#nested)
)
$(TR
$(TD Function literals)
$(YES1 expression.html#FunctionLiteral)
)
$(TR
$(V1 $(TD Dynamic closures))
$(V2 $(TD Closures))
$(YES1 function.html#closures)
)
$(TR
$(TD Typesafe variadic arguments)
$(YES1 function.html#variadic)
)
$(TR
$(TD Lazy function argument evaluation)
$(YES1 lazy-evaluation.html)
)
$(TR
$(TD Compile time function evaluation)
$(YES1 function.html#interpretation)
)
$(TR
<th colspan="6" align="left"> Arrays</th>
)
$(TR
$(TD Lightweight arrays)
$(YES1 arrays.html)
)
$(TR
$(TD <a href="#ResizeableArrays">Resizeable arrays</a>)
$(YES1 arrays.html#resize)
)
$(TR
$(TD <a href="#BuiltinStrings">Built-in strings</a>)
$(YES1 arrays.html#strings)
)
$(TR
$(TD Array slicing)
$(YES1 arrays.html#slicing)
)
$(TR
$(TD Array bounds checking)
$(YES1 arrays.html#bounds)
)
$(TR
$(TD Array literals)
$(YES1 expression.html#ArrayLiteral)
)
$(TR
$(TD Associative arrays)
$(YES1 arrays.html#associative)
)
$(TR
$(TD <a href="#StrongTypedefs">Strong typedefs</a>)
$(YES1 declaration.html#typedef)
)
$(TR
$(TD String switches)
$(YES1 statement.html#SwitchStatement)
)
$(TR
$(TD Aliases)
$(YES1 declaration.html#alias)
)
$(TR
<th colspan="6" align="left"> OOP</th>
)
$(TR
$(TD <a href="#ObjectOriented">Object Oriented</a>)
$(YES)
)
$(TR
$(TD Multiple Inheritance)
$(NO)
)
$(TR
$(TD <a href="#Interfaces">Interfaces</a>)
$(YES1 interface.html)
)
$(TR
$(TD Operator overloading)
$(YES1 operatoroverloading.html)
)
$(TR
$(TD <a href="#Modules">Modules</a>)
$(YES1 module.html)
)
$(TR
$(TD Dynamic class loading)
$(NO)
)
$(TR
$(TD Nested classes</a>)
$(YES1 class.html#nested)
)
$(TR
$(TD <a href="#innerclasses">Inner (adaptor) classes</a>)
$(YES1 class.html#nested)
)
$(TR
$(TD Covariant return types)
$(YES1 function.html)
)
$(TR
$(TD Properties)
$(YES1 property.html#classproperties)
)
$(TR
<th colspan="6" align="left"> Performance</th>
)
$(TR
$(TD <a href="#InlineAssembler">Inline assembler</a>)
$(YES1 iasm.html)
)
$(TR
$(TD Direct access to hardware)
$(YES)
)
$(TR
$(TD Lightweight objects)
$(YES1 struct.html)
)
$(TR
$(TD Explicit memory allocation control)
$(YES1 memory.html)
)
$(TR
$(TD Independent of VM)
$(YES)
)
$(TR
$(TD Direct native code gen)
$(YES)
)
$(TR
<th colspan="6" align="left"> Generic Programming</th>
)
$(TR
$(TD Class Templates)
$(YES1 template.html)
)
$(TR
$(TD Function Templates)
$(YES1 template.html)
)
$(TR
$(TD Implicit Function Template Instantiation)
$(YES1 template.html)
)
$(TR
$(TD Partial and Explicit Specialization)
$(YES1 template.html)
)
$(TR
$(TD Value Template Parameters)
$(YES1 template.html)
)
$(TR
$(TD Template Template Parameters)
$(YES1 template.html)
)
$(TR
$(TD Variadic Template Parameters)
$(YES1 template.html)
)
$(V2
$(TR
$(TD Template Constraints)
$(YES1 concepts.html)
)
)
$(TR
$(TD <a href="#mixins">Mixins</a>)
$(YES1 template-mixin.html)
)
$(TR
$(TD <a href="#staticif">static if</a>)
$(YES1 version.html#staticif)
)
$(TR
$(TD <a href="#isexpression">is expressions</a>)
$(YES1 expression.html#IsExpression)
)
$(TR
$(TD typeof)
$(YES1 declaration.html#Typeof)
)
$(TR
$(TD foreach)
$(YES1 statement.html#ForeachStatement)
)
$(TR
$(TD <a href="#ImplicitTypeInference">Implicit Type Inference</a>)
$(YES1 declaration.html#AutoDeclaration)
)
$(TR
<th colspan="6" align="left"> Reliability</th>
)
$(TR
$(TD <a href="#Contracts">Contract Programming</a>)
$(YES1 dbc.html)
)
$(TR
$(TD Unit testing)
$(YES1 unittest.html)
)
$(TR
$(TD Static construction order)
$(YES1 module.html#staticorder)
)
$(TR
$(TD Guaranteed initialization)
$(YES1 statement.html#DeclarationStatement)
)
$(TR
$(TD RAII (automatic destructors))
$(YES1 memory.html#raii)
)
$(TR
$(TD Exception handling)
$(YES1 statement.html#TryStatement)
)
$(TR
$(TD <a href="exception-safe.html">Scope guards</a>)
$(YES1 statement.html#ScopeGuardStatement)
)
$(TR
$(TD try-catch-finally blocks)
$(YES1 statement.html#TryStatement)
)
$(TR
$(TD Thread synchronization primitives)
$(YES1 statement.html#SynchronizedStatement)
)
$(TR
<th colspan="6" align="left"> Compatibility</th>
)
$(TR
$(TD C-style syntax)
$(YES)
)
$(TR
$(TD Enumerated types)
$(YES1 enum.html)
)
$(TR
$(TD <a href="#Ctypes">Support all C types</a>)
$(YES1 type.html)
)
$(TR
$(TD <a href="#LongDouble">80 bit floating point</a>)
$(YES1 type.html)
)
$(TR
$(TD Complex and Imaginary)
$(YES1 type.html)
)
$(TR
$(TD Direct access to C)
$(YES1 attribute.html#linkage)
)
$(TR
$(TD <a href="#debuggers">Use existing debuggers</a>)
$(YES)
)
$(TR
$(TD <a href="#StructMemberAlignmentControl">Struct member alignment control</a>)
$(YES1 attribute.html#align)
)
$(TR
$(TD Generates standard object files)
$(YES)
)
$(TR
$(TD Macro text preprocessor)
$(NO1 pretod.html)
)
$(TR
<th colspan="6" align="left"> Other</th>
)
$(TR
$(TD Conditional compilation)
$(YES1 version.html)
)
$(TR
$(TD Unicode source text)
$(YES1 lex.html)
)
$(TR
$(TD <a href="#DocComments">Documentation comments</a>)
$(YES1 ddoc.html)
)
</tbody>
</table>
$(SECTION2 Notes,
<dl>
<dt><a name="ObjectOriented">Object Oriented</a>
<dd>This means support for classes, member functions,
inheritance, and virtual function dispatch.
<p>
<dt><a name="InlineAssembler">Inline assembler</a>
<dd> Many C and C++ compilers support an inline assembler, but
this is not a standard part of the language, and implementations
vary widely in syntax and quality.
<p>
<dt><a name="Interfaces">Interfaces</a>
<dd> Support in C++ for interfaces is weak enough that an
IDL (Interface Description Language) was invented to compensate.
<p>
<dt><a name="Modules">Modules</a>
<dd> Many correctly argue that C++ doesn't really have modules.
But C++ namespaces coupled with header files share many features
with modules.
<p>
<dt><a name="GarbageCollection">Garbage Collection</a>
<dd> The Hans-Boehm garbage collector can be successfully used
with C and C++, but it is not a standard part of the language.
<p>
<dt><a name="ImplicitTypeInference">Implicit Type Inference</a>
<dd> This refers to the ability to pick up the type of a
declaration from its initializer.
<p>
<dt><a name="Contracts">Contract Programming</a>
<dd>The Digital Mars C++ compiler supports
<a href="http://www.digitalmars.com/ctg/contract.html">Contract Programming</a>
as an extension.
Compare some <a href="cppdbc.html">C++ techniques</a> for
doing Contract Programming with D.
<p>
<dt><a name="ResizeableArrays">Resizeable arrays</a>
<dd>Part of the standard library for C++ implements resizeable
arrays, however, they are not part of the core language.
A conforming freestanding implementation of C++ (C++98 17.4.1.3) does
not need to provide these libraries.
<p>
<dt><a name="BuiltinStrings">Built-in Strings</a>
<dd>Part of the standard library for C++ implements strings,
however, they are not part of the core language.
A conforming freestanding implementation of C++ (C++98 17.4.1.3) does
not need to provide these libraries.
$(REDO Here's a <a href="cppstrings.html">comparison</a> of C++ strings
and D built-in strings.)
<p>
<dt><a name="StrongTypedefs">Strong typedefs</a>
<dd>Strong typedefs can be emulated in C/C++ by wrapping a type
in a struct. Getting this to work right requires much tedious
programming, and so is considered as not supported.
<p>
<dt><a name="debuggers">Use existing debuggers</a>
<dd>By this is meant using common debuggers that can operate
using debug data in common formats embedded in the executable.
A specialized debugger useful only with that language is not required.
<p>
<dt><a name="StructMemberAlignmentControl">Struct member alignment control</a>
<dd>Although many C/C++ compilers contain pragmas to specify
struct alignment, these are nonstandard and incompatible from
compiler to compiler.<br>
The C# standard ECMA-334 25.5.8 says only this about struct member
alignment:
$(I "The order in which members are packed
into a struct is unspecified. For alignment purposes, there may be
unnamed padding at the beginning of a struct, within a struct, and at
the end of the struct. The contents of the bits used as padding are
indeterminate.")
Therefore, although Microsoft may
have extensions to support specific member alignment, they are not an
official part of standard C#.
<p>
<dt><a name="Ctypes">Support all C types</a>
<dd>C99 adds many new types not supported by C++.
<p>
<dt><a name="LongDouble">80 bit floating point</a>
<dd>While the standards for C and C++ specify long doubles, few
compilers (besides Digital Mars C/C++) actually implement
80 bit (or longer) floating point types.
<p>
<dt><a name="mixins">Mixins</a>
<dd>Mixins have many different meanings in different programming
languages. <a href="template-mixin.html">D mixins</a> mean taking an arbitrary
sequence of declarations
and inserting (mixing) them into the current scope. Mixins can be done
at the global, class, struct, or local level.
<p>
<dt><a name="cppmixins">C++ Mixins</a>
<dd>C++ mixins refer to a couple different techniques. The first
is analogous to D's interface classes. The second is to create
a template of the form:
$(CPPCODE
template &lt;class Base&gt; class Mixin : public Base
{
... mixin body ...
}
)
D mixins are different.
<p>
<dt><a name="staticif">Static If</a>
<dd>The C and C++ preprocessor directive #if would appear to
be equivalent to the D static if. But there are major and crucial
differences - the #if does not have access to any of the constants,
types, or symbols of the program. It can only access preprocessor
macros.
See <a href="cpptod.html#metatemplates">this example</a>.
<p>
<dt><a name="isexpression">Is Expressions</a>
<dd>$(I Is expressions) enable conditional compilation based
on the characteristics of a type. This is done after a fashion in
C++ using template parameter pattern matching.
See <a href="cpptod.html#typetraits">this example</a>
for a comparison of the different approaches.
<p>
<dt><a name="innerclasses">Inner (adaptor) classes</a>
<dd>A $(I nested class) is one whose definition is within the scope
of another class. An $(I inner class) is a nested class that
can also reference the members and fields of the lexically
enclosing class; one can think of it as if it contained a 'this'
pointer to the enclosing class.
<p>
<dt><a name="DocComments">Documentation comments</a>
<dd>Documentation comments refer to a standardized way to produce
documentation from the source code file using specialized
comments.
</dl>
)
$(SECTION2 Errors,
$(P If I've made any errors in this table, please contact me so
I can correct them.
)
)
)
Macros:
TITLE=Comparison
WIKI=Comparison
CATEGORY_FEATURES=$0
NO=<td class="compNo">No</td>
NO1=<td class="compNo"><a href="$1">No</a></td>
YES=<td class="compYes">Yes</td>
YES1=<td class="compYes"><a href="$1">Yes</a></td>
Jump to Line
Something went wrong with that request. Please try again.