|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
编程范型 |
| --- |
|  |
| 指令式 | 
* 过程式
* 块结构
* 例外处理
* 结构化
* 模块化

 |
|  |
| 函数式 | 
* 头等函数
* 纯函数式
* 隐式
* 模式匹配
* 推导式

 |
|  |
| 面向对象 | 
* 基于类
* 基于原型
* 契约式
* 面向方面
* 面向代理

 |
|  |
| 数据流程 | 
* 同步式
* 响应式
	+ 函数式响应式
* 串流处理
* 基于流程

 |
|  |
| 宣告式 | 
* 逻辑式
	+ 回答集
* 约束式
* 数据查询
* 框架本体

 |
|  |
|  | 
* 协程
* 演员模型
* 通信顺序进程
* future/promise
* 分叉会合
* 整体同步
* 映射归约

 |
|  |
| 其他 | 
* 递归
* 阵列式
* 多态
	+ 运算符重载
	+ 泛型
	+ 多分派
* 面向堆栈
* 非确定性
* 数据驱动
* 事件驱动
* 自动机
* 可微分
* 概率式

 |
|  |
| 按语言比较（英语：） |

 |

在面向对象程序设计中，**元类**（英語：）是一种实例是类的类。普通的类定义的是特定对象的行为，元类定义的则是特定的类及其实例的行为。不是所有面向对象编程语言都支持元类。在它能做的事情之中，元类可以覆写任何给定方面类行为的程度是不同的。元类可以通过使类成为头等对象来实现，在这种情况下元类简单的就是构造类的一个对象。每个语言都有它自己的元对象协议，给出对象、类和元类如何交互的规则。

Smalltalk-80元类
--------------

在Smalltalk中，所有东西都是对象。此外，Smalltalk是基于类的系统，这意味着所有对象都有一个类，它定义这个对象的结构（比如说这个类拥有实例变量），和这个对象所理解的消息。二者在一起蕴含了，在Smalltalk中，类是一个对象，因此类也需要是它的元类的实例。

元类在Smalltalk-80系统中的主要角色，是提供协议来初始化类变量，和建立元类的唯一实例（也就是其对应的类）的初始化实例。

### 实例联系

为了允许类拥有它们自己的方法，和叫作类实例变量它们自己的实例变量（英语：），Smalltalk-80为每个类`C`介入了它们自己的元类`C class`。就像实例方法实际上属于类一样，类方法实际上属于元类。在类中定义实例变量（英语：）和类变量（英语：），而在元类中定义类实例变量。

每个元类在效果上都是单例类。就像连体双胞胎，类和元类是共生的。元类有一个实例变量`thisClass`，它指向它结合的类。平常的Smalltalk类浏览器（英语：），不将元类展示为单独的类，转而允许一起同时编辑类和它的元类。

要得到一个实例的类，需要向它发送消息调用`class`方法。类和元类继承了其超类的`name`方法，它返回接收者名字的字符串。例如，轿车对象`c`是类`Car`的实例，则`c class`返回`Car`类对象，而`c class name`返回`'Car'`；依次类推，`Car class`返回`Car`的元类对象，而`Car class name`返回依赖于实现，有的是`nil`，即没有名字，有的是`'Car class'`，即用空格分隔的类名字和`'class'`。

在早期的Smalltalk-76中，创建新类的方式是向`Class`类发送`new`消息。在Smalltalk-80中，`Class`是元类的基础类，它是类而不是元类。所有元类都是一个`Metaclass`类的实例。`Metaclass`类是`Metaclass class`的实例，而`Metaclass class`作为元类，也是`Metaclass`类的实例。

### 继承联系

在Smalltalk-80中，终端对象是一个整数、一个组件、或一台车等，而类是像`Integer`、或`Widget`或`Car`等这样的东西，除了`Object`之外，所有的类都有一个超类。元类所继承的元类，就是元类对应的类所继承的类的元类。

在一个消息被发送到对象的时候，方法的查找开始于它的类。如果没有找到则在上行超类链，停止于`Object`而不管找到与否。在一个消息被发送到一个类的时候，类方法查找开始于它的元类，并上行超类链至`Object class`。直至`Object class`，元类的超类层级并行于类的超类层级。在Smalltalk-80中，`Object class`是`Class`的子类：

```
Object class superclass == Class.

```

类方法的查找在元类链之后仍可继续下去，所有元类都是`Class`的在继承层级中的子类，它是所有元类的抽象超类，它描述这些类的一般性质，继而最终可上溯至`Object`。

### 继承层级

四个类提供描述新类的设施，下面是它们的继承层级（起自`Object`），和它们提供的主要设施：

* `Object`，对象类是所有类的基础类，它为所有对象提供公共的方法，即公共的缺省行为。至少包括了：测试对象的功能比如`class`方法，比较对象，对象复制，访问对象的各部份，打印和存储对象，错误处理。
	+ `Behavior`，行为类定义了拥有实例的对象所需要的最小状态（英语：），它提供建立一个类的实例的`new`方法。特别是，它定义了Smalltalk-80解释器所用到的状态，并为编译方法源代码提供到编译器的基本接口，如`compile:`等方法。`Behavior`描述的这个状态，包括了一个类层级连接（`superclass:`），一个方法字典（`methodDictionary:`、`addSelector:withMethod:`），和对实例的描述（依据数目和对它们的变量的表示）。尽管一个类的多数设施都规定在`Behavior`中，但很多消息不能于此实现，对类的完全描述转而在它的子类之中提供。
		- `ClassDescription`，类描述类为`Class`和`Metactass`提供了共同的超类。它表现类命名（`name`）、类注释（`comment:`）、和命名实例变量（`addlnstVarName:`）。特别是，它增加了组织在方法字典中方法（`compile:classified:`）和类自身（`category:`）的结构。它还提供了在外部串流（文件）上存储完全的类描述的机制，和记述对类描述的变更的机制。
			* `Class`，类类是所有元类的基础类，从而为所有类提供公共的方法，它定义了初始化类变量的`initialize`方法。`Class`的实例描述对象的表现和行为，它提供比`ClassDescription`更具描述性的设施，特别是，它增加了对类变量名字（`addClassVarName:`）和共享的池变量（`addSharedPool:`）的表示。它还提供比`Behavior`更综合性的编程支持设施，比如创建一个类的子类的消息：`subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:`。
			* `Metaclass`，元类类是创建元类的类，它为所有元类提供公共的方法。`Metaclass`的关键性的消息，是自身初始化消息，这在GNU Smalltalk中依旧保留；一个是发送到`Metaclass`自身的消息`subclassOf: superMeta`，用来创建元类`superMeta`的一个子类；一个是发送到`Metaclass`的一个实例的消息，用来建立这个元类的唯一实例，对于建立完全初始化的类，它的每个参数都是需要的：`name:environment:subclassOf:instanceVariableNames:shape:classVariableNames:poolDictionaries:category:`。

### 方法查找次序

下面是方法查找次序的辨析：

* 每个终端对象，在查找方法时，都首先查找自己的类；然后按类继承链上溯，最后不经过`Class`（类类）和`Metaclass`（元类类），最终上至`Object`（对象类）。
* 每个类，包括`Class`和`Metaclass`，在查找查找方法时，首先查找自己的元类；然后按元类继承链上溯，最终经过`Object class`（对象元类）而上至`Class`；接着按类继承链上溯，不经过与其并列的`Metaclass`，最终上至`Object`。
* 每个元类，包括`Class class`和`Metaclass class`，在查找方法时，因为都是`Metaclass`的实例，所以首先查找`Metaclass`；然后按类继承链上溯，不经过与其并列的`Class`，最终上至`Object`。

### 示意图

下面是两个示意图，二者都是纵向连线表示实例联系，而横向连线表示继承联系。实例联系以`Metaclass`（元类类）及其元类为顶端，而继承联系以`Object`（对象类）及其元类为中心，其中`Object class`（对象元类）继承`Class`（类类）是串接元类继承链与类继承链的关键环节。前者图示采用Smalltalk-80蓝皮书的样式（但旋转了180°），将`Metaclass`及其元类放置在最上方的独立两行，使得实例联系尽量成为树状向上汇聚；后者图示将`Metaclass`及其元类放置在最左边，使得继承联系尽量都在同一行之上。

* Smalltalk-80的类和元类层级，使用UML类图表示，这里从左至右，第一列是Class class（类元类）和Class（类类），第二列是ClassDescription class（类描述元类）和ClassDescription（类描述类），第三列是Behavior class（行为元类）和Behavior（行为类），第四列是Object class（对象元类）和Object（对象类），第五列是Metaclass class（元类元类）、Metaclass（元类类）、Car class（Car元类）、Car（Car类）和c:Car（Car实例）。Smalltalk-80的类和元类层级，使用UML类图表示，这里从左至右，第一列是Class class（类元类）和Class（类类），第二列是ClassDescription class（类描述元类）和ClassDescription（类描述类），第三列是Behavior class（行为元类）和Behavior（行为类），第四列是Object class（对象元类）和Object（对象类），第五列是Metaclass class（元类元类）、Metaclass（元类类）、Car class（Car元类）、Car（Car类）和c:Car（Car实例）。
* Smalltalk中在类和元类之间的继承和实例联系的示意图，这里从左至右，第一列是Metaclass元类和Metaclass（元类类），第二列是Class元类和Class（类类），第三列是ClassDescription元类与Behavior元类、和ClassDescription（类描述类）与Behavior（行为类），第四列是Object元类、Object（对象类）和Object实例，第五列是Foo元类、Foo类和Foo实例，第六列是Bar元类、Bar类和Bar实例。Smalltalk中在类和元类之间的继承和实例联系的示意图，这里从左至右，第一列是Metaclass元类和Metaclass（元类类），第二列是Class元类和Class（类类），第三列是ClassDescription元类与Behavior元类、和ClassDescription（类描述类）与Behavior（行为类），第四列是Object元类、Object（对象类）和Object实例，第五列是Foo元类、Foo类和Foo实例，第六列是Bar元类、Bar类和Bar实例。

### 例子

下列例子展示，从Smalltalk-80派生的Squeak和Pharo的样例代码的结构，它们的继承层级的根类实际上是`ProtoObject`，`ProtoObject`封装了所有对象都必须拥有的极小化的消息集合，它被设计为引发尽可能多的错误，用来支持代理（proxy）定义。例如Smalltalk-80的`Object`中，错误处理消息`doesNotUnderstand:`，和系统原始消息`become:`，就转而在`ProtoObject`中定义了。

在示意图中，纵向的绿色连接，展示继承联系的"子→父"关系（隐含的自下而上），横向的蓝色连接展示实例联系的"成员→容器"关系，从`x`出的发蓝色连接，指向`x`的最小实际容器，它是在调用在`x`上的方法时查找方法的继承链起点：


|  |  |  |
| --- | --- | --- |
|  |   |  |
| 
```
 r := ProtoObject.
 c := Class.
mc := Metaclass.
Object subclass: #A.
A      subclass: #B.
u := B new.
v := B new.

```
 |  | Implicit metaclasses in Smalltalk-80 - A sample structure |

这个结构由两个部份构成，用户部份有四个显式的对象和类及其两个隐式的元类：终端对象`u`和`v`，它们连接到的类`A`和`B`，它们两个连接到的右侧灰色节点表示的隐式的元类，其他的对象都是内建部份。

Objective-C元类
-------------

在Objective-C中的元类，几乎同于Smalltalk-80的元类，这是因为Objective-C从Smalltalk引进了很多东西。就像Smalltalk，在Objective-C中实例变量和方法是对象的类定义的。类也是对象，因此它是元类的一个实例。

* 在Objective-C中在类和元类之间的继承和实例联系的示意图。注意Objective-C有多个根类，每个根类都有独立的层级。这个示意图只展示了例子根类NSObject的层级。每个其他根类都有类似的层级。在Objective-C中在类和元类之间的继承和实例联系的示意图。注意Objective-C有多个根类，每个根类都有独立的层级。这个示意图只展示了例子根类NSObject的层级。每个其他根类都有类似的层级。

就像Smalltalk，在Objective-C中类方法，简单的是在类对象上调用的方法，因此一个类的类方法，必须定义为在它的元类中的实例方法。因为不同的类有不同的类方法集合，每个类都必须有它自己单独的元类。类和元类总是成对创建：运行时系统拥有函数`objc_allocateClassPair()`和`objc_registerClassPair()`来分别的创建和注册类-元类对。

元类没有名字，但是到任何类对象的指针，可以通过泛化类型`Class`来提及（类似于用作到任何对象的指针的类型`id`）。

元类都是相同的类即根类元类的实例，而根类元类是自身的实例。因为类方法是通过继承联系来继承的，就像Smalltalk，除了根类元类之外，元类继承联系必须并行于类继承联系（比如说如果类A的父类是类B，则A的元类的父类是B的元类）。

不同于Smalltalk，根类元类继承自根类自身（通常为使用Cocoa框架的`NSObject`）。这确保了所有的元类最终都是根类的子类，从而人们可以将根类的实例方法，它们通常是针对对象有用的实用方法，使用于类对象自身上。

Python元类
--------

在Python中，内建的类`type`是元类。

|  |  |  |
| --- | --- | --- |
|  |   |  |
| 
```
r = object
c = type
class M(c): pass

class A(metaclass=M): pass

class B(A): pass

b = B()

```
 |  |  |

类的定义，不包括它的实例对象的细节，如它们的字节为单位的大小，它们在内存中的二进制格局，它们是如何分配的，每次建立实例时自动调用的`__init__`方法，诸如此类。不只是在建立新实例对象的时候，而且在每次访问实例对象的任何特性的时候，这些细节都起到作用。在没有元类的语言中，这些细节是在语言规定中定义的，并且不能被覆写（override）。

在Python中，元类`type`控制着类行为的这些细节，默认定义出的类自身都是`type`的实例。新的元类可以很容易定义为`type`的子类从而覆写它，通过向类定义提供"关键字参数"`metaclass`就可以使用这个新的元类。

```
>>> type(b)
<class '\_\_main\_\_.B'>
>>> print(type(B), B.\_\_bases\_\_, [\*B.\_\_dict\_\_])
<class '\_\_main\_\_.M'> (<class '\_\_main\_\_.A'>,) ['\_\_module\_\_', '\_\_doc\_\_']
>>> print(type(A), A.\_\_bases\_\_, [\*A.\_\_dict\_\_])
<class '\_\_main\_\_.M'> (<class 'object'>,) ['\_\_module\_\_', '\_\_dict\_\_', '\_\_weakref\_\_', '\_\_doc\_\_']
>>> print(type(M), M.\_\_bases\_\_, [\*M.\_\_dict\_\_])
<class 'type'> (<class 'type'>,) ['\_\_module\_\_', '\_\_doc\_\_']
>>> print(type(c), c.\_\_bases\_\_)
<class 'type'> (<class 'object'>,)
>>> print(type(r), r.\_\_bases\_\_)
<class 'type'> ()
>>> sorted({\*r.\_\_dict\_\_} & {\*c.\_\_dict\_\_})
['\_\_delattr\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_getattribute\_\_', '\_\_init\_\_', '\_\_new\_\_', '\_\_repr\_\_', '\_\_setattr\_\_', '\_\_sizeof\_\_']
>>> sorted({\*r.\_\_dict\_\_} - {\*c.\_\_dict\_\_})
['\_\_class\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_gt\_\_', '\_\_hash\_\_', '\_\_init\_subclass\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_ne\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_']
>>> sorted({\*c.\_\_dict\_\_} - {\*r.\_\_dict\_\_})
['\_\_abstractmethods\_\_', '\_\_base\_\_', '\_\_bases\_\_', '\_\_basicsize\_\_', '\_\_call\_\_', '\_\_dict\_\_', '\_\_dictoffset\_\_', '\_\_flags\_\_', '\_\_instancecheck\_\_', '\_\_itemsize\_\_', '\_\_module\_\_', '\_\_mro\_\_', '\_\_name\_\_', '\_\_prepare\_\_', '\_\_qualname\_\_', '\_\_subclasscheck\_\_', '\_\_subclasses\_\_', '\_\_text\_signature\_\_', '\_\_weakrefoffset\_\_', 'mro']

```

### 例子

考虑下面这个最简单的Python类：

```
class Car:
    def \_\_init\_\_(self, \*args, \*\*kwargs):
        self.\_\_dict\_\_.update(kwargs)
    def \_\_call\_\_(self, \*\*kwargs):
        self.\_\_dict\_\_.update(kwargs)
    @property
    def description(self):
 """返回这辆车的描述."""
        return "".join(str(value) for value in self.\_\_dict\_\_.values())

```

```
>>> new\_car = Car(make='Toyota', model='Prius', year=2005, engine='Hybrid')
>>> new\_car(color='Green')
>>> new\_car.description
'Toyota Prius 2005 Hybrid Green'

```

上面的例子包含了一些代码来处理初始化特性，也可以使用元类来完成这种任务：

```
class AttributeInitType(type):
    def \_\_new\_\_(\*args, \*\*kwargs):
 """返回创建的实例类."""
        cls = type.\_\_new\_\_(\*args, \*\*kwargs)
        def call(self, \*\*kwargs):
            self.\_\_dict\_\_.update(kwargs)
        cls.\_\_call\_\_ = call    # 为实例类增加\_\_call\_\_方法
        return cls
    def \_\_call\_\_(cls, \*args, \*\*kwargs):
 """返回为实例类创建的实例对象."""
        obj = type.\_\_call\_\_(cls, \*args)    # 以正常缺省方式建立实例对象。
        obj.\_\_dict\_\_.update(\*\*kwargs)    # 在这个新对象上设置属性。
        return obj

```

这个元类只覆写实例类和对象创建部份功能。元类行为的所有其他方面仍由`type`处理。现在可以重写类`Car`使用这个新元类：

```
class Car(object, metaclass=AttributeInitType):
    def \_\_init\_\_(self, \*args): pass # 接收未预期的位置实际参数
    @property
    def description(self):
 """返回这辆车的描述."""
        return "".join(str(value) for value in self.\_\_dict\_\_.values())

```

Ruby元类
------

Ruby通过介入其自称的特征类（eigenclass），提炼了Smalltalk-80的元类概念，去除了`Metaclass`类，并重新定义了`class-of`映射。变更可以图示如下：

|  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

Smalltalk-80| 类 | **隐式元类** |
| 终端对象 |  |

 | → | 

Ruby| 类 | **类的特征类** | **特征类的特征类** |
| 终端对象 | **终端对象的特征类** |

 |

特别要注意在Smalltalk的隐含的元类和Ruby类的特征类之间的对应。Ruby的特征类模型，使得隐式元类概念完全统一：所有对象`x`，都有它自己的元对象，它叫作`x`的特征类，它比`x`高一个元层级。高阶特征类通常是纯粹概念上的存在，在大多数Ruby程序中，它们不包含任何方法也不存储任何（其他）数据。

下面的示意图展示Ruby样例代码的核心结构。这里的灰色节点表示打开`A`和`v`特征类后扩张出来的特征类。

|  |  |  |
| --- | --- | --- |
|  |   |  |
| 
```
r = BasicObject
c = Class
class A; end
class B < A; end
u = B.new
v = B.new

class << A; end
class << v; end

```
 |  | Eigenclasses in Ruby - A sample structure |

图示还展示了Ruby中特征类的惰性求值。`v`对象可以有它的特征类，作为向`v`增加"单例方法"的结果而被求值（被分配）。

在语言和工具中的支持
----------

下面是支持元类的一些最显著的编程语言。

* Common Lisp，通过CLOS
* Delphi和受它影响的其他Object Pascal版本
* Groovy
* Objective-C
* Python
* Perl，通过元类pragma，还有Moose（英语：）
* Ruby
* Smalltalk
* C++（规划用于C++23）

一些不甚广泛传播的语言支持元类，包括OpenJava（英语：）、OpenC++、OpenAda、CorbaScript（英语：）、ObjVLisp、Object-Z（英语：）、MODEL-K、XOTcl（英语：）和MELDC。其中几种语言可追溯日期至1990年代早期并具有学术价值。

Logtalk（英语：）是Prolog的面向对象扩展，它也支持元类。

资源描述框架（RDF）和统一建模语言（UML）二者都支持元类。

另见
--

* 元编程
* 元对象
* 反射式编程

引用
--

1. ↑  Ira R. Forman and Scott Danforth.. 1999. ISBN 0-201-43305-2.
2. ↑  Alan Kay..  [2022-03-12]. （原始内容存档于2011-04-29）. The most puzzling strange idea – at least to me as a new outsider – was the introduction of metaclasses (really just to make instance initialization a little easier – a very minor improvement over what Smalltalk-76 did quite reasonably already).   
Peter’s 1989 comment is typical and true: "metaclasses have proven confusing to many users, and perhaps in the balance more confusing than valuable." In fact, in their PIE system, Goldstein and Bobrow had already implemented in Smalltalk on "observer language", somewhat following the view-oriented approach Ihad been advocating and in some ways like the "perspectives" proposed in KRL [Goldstein \*].   
Once one can view an instance via multiple perspectives even "sem-metaclasses" like Class Class and Class Object are not really necessary since the object-role and instance-of-a-class-role are just different views and it is easy to deal with life-history issues includeding instantiation. This was there for the taking (along with quite a few other good ideas), but it wsn’t adopted. My guess is that Smalltalk had moved into the final phase I memntioned at the beginning of this story, in which a way of doing things finally gets canonized into an inflexible belief structure.
3. ↑  Learning Research Group.  (PDF) (报告). Xerox Palo Alto Research Center. October 1979  [2022-03-13]. （原始内容 (PDF)存档于2022-04-12）. To define a new class, select a class category in the first pane of the browse window. This selection specifies the category to which the new class will be added, and causes a template to appear in the largest pane of the browse window, the code pane. ……  
The template presented in the code pane looks as follows `Class new title: ’NameofClass’  
    subclassof: Object  
    fields: ’names of fields’  
    declare: ’names of class variables’`
4. ↑ . .  [2021-03-29]. （原始内容存档于2021-05-06）.
5. ↑ .  [2022-01-16]. （原始内容存档于2022-03-12）.
6. ↑  IBM Metaclass programming in Python, parts 1 （页面存档备份，存于）, 2 （页面存档备份，存于） and 3 （页面存档备份，存于）
7. ↑  Artima Forum: Metaclasses in Python 3.0 (part 1 of 2) （页面存档备份，存于） (part 2 of 2) （页面存档备份，存于）
8. ↑ . .  [2021-03-29]. （原始内容存档于2021-05-06）.
9. ↑  Paolo Perrotta.  (PDF). Pragmatic Bookshelf. 2014  [2022-03-30]. ISBN 978-1-94122-212-6. （原始内容 (PDF)存档于2022-05-15）.
10. ↑ . .  [2021-03-29]. （原始内容存档于2021-05-06）.
11. ↑  Herb Sutter.  (PDF).  [2020-09-25]. （原始内容存档 (PDF)于2020-11-11）.
12. ↑   (PDF).  [2007-11-27]. （原始内容 (PDF)存档于2007-10-16）.

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
数据类型 |
| --- |
|  |
| 无解释的 | 
* 位元
* 字节
* 三进制位
* 三进制字节
* 字

 |
|  |
| 数值 | 
* 整数
	+ 符号性
	+ 有符号数
	+ 无符号数
* 定点数
* 浮点数
	+ 双精度
	+ 扩展精度（英语：）
	+ 半精度
	+ 迷你浮点数（英语：）
	+ 八倍精度（英语：）
	+ 四倍精度（英语：）
	+ 单精度
* 有理数（英语：）
* 复数（英语：）
* 任意精度算术
* 区间（英语：）

 |
|  |
| 文本 | 
* 字符
* 字符串

 |
|  |
| 指针 | 
* 記憶體位址
	+ 物理地址
	+ 虚拟地址
* 參照

 |
|  |
| 组合 | 
* 代数数据类型
	+ 广义（英语：）
* 数组
* 关联数组
* 类
* 串列
* 对象
	+ 元对象
* 可选类型
* 积类型（英语：）
* 记录
* 集合
* 联合体
	+ 标签

 |
|  |
| 其他 | 
* 布尔型
* 底层类别（英语：）
* 容器
* 枚举类型
* 异常
* 头等函数
* 不透明数据类型（英语：）
* 递归数据类型
* 信号标
* 字串流
* 顶类型（英语：）
* 类型类
* 類型系統
* 单位类型（英语：）
* Void
* 不定型別

 |
|  |
| 相关议题 | 
* 抽象資料型別
* 数据结构
* 介面
* 种类（英语：）
* 元类
* 对象类型（英语：）
* 原始型別与複合型別
* 协议
* 子类型
* C++模板
* 型別構造器
* 参数多态

 |

 |

|  |  |  |  |  |
| --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
後設 |
| --- |
|  |
| 基础领域与方法 | 
* 或統合分析
* （英语：）或元類別
	+
* 後設認知
	+ （英语：）
	+ （英语：）
* （英语：）
* （英语：）
* 或詮釋資料
* （英语：）
* 
* 後設作品
* 
* 
* 
* 
* 元語言或後設語言
	+ （英语：）
* 超材料
* 
* （英语：）
* 或後設模型
	+ （英语：）
* 元现代主义
* （英语：）
* 
* +
* 或超编程、後設编程
* （英语：）或超最佳化、後設最佳化
* （英语：）
* （英语：）
* + 
	+ 
	+ （英语：）
	+ （英语：）
	+ 形上學
		- （英语：）
* （英语：）
* 或複合族群
* （英语：）
* （英语：）或
* 
* 元搜索
* （英语：）
* 
* 
* （英语：）
* 元宇宙或後設宇宙、超感空間

 |

 |