C++编程语言:抽象机制:第27章——模板和层级结构(Bjarne Stroustrup)

C++创始人Bjarne Stroustrup简介 他在20世纪80年代早期开发了C++,并在之后的几十年中对其进行了不断发展和推进。Bjarne Stroustrup对C++的设计和发展做出了巨大贡献,并通过不断改进语言的标准,使其成为一个广泛使用的编程语言。总结起来,Bjarne Stroustrup是C++编程语言的创始人,他的工作对于现代软件开发和计算机科学领域具有重要意义。C++编程语言最初是作为C语言的扩展而诞生的,旨在提供更多的抽象和更强大的编程工具。它结合了面向过程编程和面向对象编程的特性,并引入了许多新的概念,如类、继承、多态和模板。 阅读详情

目录

27.1  引言(Introduction)

27.2  参数化和层级结构(Parameterization and Hierarchy)

27.2.1  生成类型(Generated Types)

27.2.2  模板转换(Template Conversions)

27.3  类模板层级结构(Hierarchies of Class Templates)

27.3.1  模板对比接口(Templates as Interfaces)

27.4  模板参数对比基类(Template Parameters as Base Classes)

27.4.1  组合数据结构(Composing Data Structures)

27.4.2  线性化类层级结构(Linearizing Class Hierarchies)

27.5  建议(Advice)


27.1  引言(Introduction)

         模板和派生是从现有类型构建新类型、指定接口的机制,通常用于编写利用各种形式的共性的有用代码:

• 模板类定义一个接口。可以通过该接口访问模板自身的实现及其特化的实现。实现模板的源代码(在模板定义中)对于所有参数类型都是相同的。不同特化的实现可能非常不同,但它们都应该实现为主模板指定的语义。特化可以为主模板提供的功能添加功能。

• 基类定义一个接口。可以通过该接口(使用虚函数)访问类自身的实现及其派生类的实现。不同派生类的实现可能非常不同,但它们都应该实现为基类指定的语义。派生类可以为基类提供的功能添加功能。

         从设计角度来看,这两种方法非常接近,值得拥有一个共同的名称。由于两者都允许算法表达一次并应用于多种类型,因此人们将两者都称为多态(源自希腊语“多种形状(many shapes)”)。为了区分它们,虚函数提供的功能称为运行时多态性,而模板提供的功能称为编译时多态或参数多态。

         通用方法和面向对象方法的粗略二元性可能会产生误导。面向对象程序员倾向于专注于类(类型)层级结构的设计,其中接口是单个类(第 21 章)。通用程序员倾向于专注于算法的设计,其中模板参数的概念提供了可以容纳多种类型的接口(第 24 章)。程序员的理想状态应该是掌握这两种技术,以至于可以在最合适的情况下使用其中任何一种。在许多情况下,最佳设计包含两者的元素。例如,vector<Shape∗> 是一个编译时多态(通用)容器,它保存来自运行时多态(面向对象)层级结构的元素(§3.2.4)。

    一般来说,良好的面向对象编程比良好的通用编程需要更多的远见,因为层级结构中的所有类型都必须显式共享定义为基类的接口。模板将接受符合其概念的任何类型作为参数,即使这些类型之间没有明确声明的共同点。例如,accumulate()(§3.4.2,§24.2,§40.6.1)将接受 int 型 vector和 complex<double> 型 list,即使两种元素类型之间没有声明关系,两种序列类型之间也没有声明关系。

27.2  参数化和层级结构(Parameterization and Hierarchy)

    如 §4.4.1 和 §27.2.2 所示,模板和类层级结构的组合是许多实用技术的基础。因此:

• 何时我们选择使用类模板?

• 何时我们依赖类层级结构?

从稍微简化和抽象的角度考虑这些问题:

template<typename X>

class Ct { // 根据参数描述的接口

X mem;

public:

X f();

int g();

void h(X);

};

template<>

class Ct<A> { // 特为 (为 A)

A∗ mem; // 表示可以不同于主模板

public:

A f();

int g();

void h(A);

void k(int); // 添加功能

};

Ct<A> cta; // 特化为 A

Ct<B> ctb; // 特化为 B

鉴于此,我们可以分别使用 Ct<A> 和 Ct<B> 的实现对变量 cta 和 ctb 使用 f(),g() 和 h()。我使用了显式特化(§23.5.3.4)来表明实现可以与主模板提供的内容不同,并且可以添加功能。更简单的情况(没有添加功能)是迄今为止更常见的情况。

    使用层级结构的粗略等效方法是:

class X {

// ...

};

class Cx { // 根据作用域中的类型表述的接口

X mem;

public:

virtual X& f();

virtual int g();

virtual void h(X&);

};

Class DA : public Cx { // 派生类

public:

X& f();

int g();

void h(X&);

};

Class DB : public Cx { // 派生类

DB∗p; //可以对类提供的表示进行更多扩展

public:

X& f();

int g();

void h(X&);

void k(int); // 添加功能

};

Cx& cxa {∗new DA}; // cxa 是一个指向 DA 的接口

Cx& cxb {∗new DB}; // cxb 是一个指向 DB 的接口

    鉴于此,我们可以分别使用 DA 和 DB 的实现对变量 cxa 和 cxb 使用 f(),g() 和 h()。我在分层版本中使用引用来反映我们必须通过指针或引用来操作派生类对象,以保留运行时多态行为。

    无论哪种情况,我们操作的对象都具有一组共同的操作。从这个简化和抽象的角度来看,我们可以观察到:

• 如果生成类或派生类的接口类型需要不同,则模板具有优势。要通过基类访问派生类的不同接口,我们必须使用某种形式的显式转换(§22.2)。

• 如果生成类或派生类的实现仅在一个参数上有所不同,或者仅在少数特殊情况下有所不同,则模板具有优势。不规则的实现可以通过派生类或特化来表达。

• 如果在编译时无法知道所用对象的实际类型,则类层级结构必不可少。

• 如果生成类型或派生类型之间需要层级关系,则层级结构具有优势。基类提供通用接口。模板特化之间的转换必须由程序员明确定义(§27.2.2)。

• 如果不希望明确使用自由存储(§11.2),则模板具有优势。

• 如果运行时效率非常重要,以至于操作的内联必不可少,则应使用模板(因为有效使用层级结构需要使用指针或引用,这会抑制内联)。

    保持基类最小化和类型安全可能很困难。用现有类型来表达接口可能也很困难,因为派生类无法改变现有类型。通常,结果是一种妥协,要么过度限制基类接口(例如,我们选择一个具有“丰富接口”的类 X,该接口必须由所有派生类实现,并且“永远”如此),要么限制不足(例如,我们使用 void∗ 或最小 Object∗)。

    模板和类层级结构的组合提供了设计选择和灵活性,这超出了它们单独提供的功能。例如,指向基类的指针可用作模板参数,以提供运行时多态性(§3.2.4),模板参数可用于指定基类接口,以提供类型安全性(§26.3.7,§27.3.1)。

27.2.1  生成类型(Generated Types)

    类模板可以理解为创建特定类型的规范。换言之,模板实现是一种根据规范在需要时生成类型的机制。因此,类模板有时被称为类型生成器。

    就 C++ 语言规则而言,由单个类模板生成的两个类之间没有任何关系。例如:

class Shape {

// ...

};

class Circle : public Shape {

{

// ...

};

鉴于这些声明,人们有时会认为 set<Circle> 和 set<Shape> 之间或至少 set<Circle∗> 和 set<Shape∗> 之间必须存在继承关系。这是一个基于有缺陷的论点的严重逻辑错误:“‘Circle 是 Shape,因此 Circle 的集合也是 Shape 的集合;因此,我应该能够将 Circle 的集合用作 Shape 的集合。’”这个论点的“因此”部分不成立。原因是 Circle 的集合保证集合的成员是 Circle;而 Shape 的集合不提供这种保证。例如:

class Triangle : public Shape {

// ...

};

void f(set<Shape∗>& s)

{

// ...

s.insert(new Triangle{p1,p2,p3});

}

void g(set<Circle∗>& s)

{

f(s); // 错, 类型不匹配: s 是一个 set<Circle*>, 不是一个 set<Shape*>

}

这不会编译,因为没有从 set<Circle∗>& 到 set<Shape∗>& 的内置转换。也不应该有。一个set<Circle∗> 成员的保证是,众 Circle 使我们能够安全有效地将 Circle 特定的操作(例如确定半径)应用于集合的成员。如果我们允许将 set<Circle∗> 视为 set<Shape∗>,我们就无法再维持该保证。例如,f() 将 Triangle∗ 插入其 set<Shape∗> 参数中。如果 set<Shape∗> 可以是 set<Circle∗>,则将违反 set<Circle∗> 仅包含众 Circle∗ 的基本保证。

    从逻辑上讲,我们可以将不可变集合 <Circle∗> 视为不可变集合 <Shape∗>,因为当我们无法更改集合时,不会发生将不适当元素插入集合的问题。也就是说,我们可以提供从 const set<const Circle∗> 到 const set<const Shape∗> 的转换。语言默认不这样做,但集合的设计者可以。

    数组和基类的组合尤其糟糕,因为内置数组不提供容器提供的类型安全性。例如:

void maul(Shape∗ p, int n) // 当心!

{

for (int i=0; i!=n; ++i)

p[i].draw(); //看起来优雅; 实质不是

}

void user()

{

Circle image[10]; // 由 10 个圆构成的图片

// ...

maul(image,10); // ‘‘maul’’ 10 个圆

// ...

}

    我们怎样才能用 image 调用 maul()?首先,image 的类型从 Circle[] 转换(降级)为 Circle∗ 。接下来,Circle∗ 转换为 Shape∗ 。将数组名称隐式转换为指向数组第一个元素的指针是 C 风格编程的基础。同样,将指向派生类的指针隐式转换为指向其基类的指针是面向对象编程的基础。结合起来,它们提供了灾难的机会。

    在上面的例子中,假设 Shape 是一个大小为 4 的抽象类,而 Circle 则添加了一个中心和一个半径。然后 sizeof(Circle) > sizeof(Shape),当我们查看图像的布局时,我们会发现类似以下内容:

当 maul() 尝试在 p[1] 上调用虚函数时,在预期的位置没有虚函数指针,因此调用可能会立即失败。

    请注意,不需要显式转换即可获遭遇此灾难:

• 优先使用容器而不是内置数组。

• 高度怀疑诸如 void f(T∗ p, int count) 之类的接口;当 T 可以是基类并且 count 是元素计数时,麻烦就来了。

• 考虑将 .(点)应用于应该是运行时多态的东西时,除非它显然应用于引用,否则要怀疑它。

27.2.2  模板转换(Template Conversions)

    从同一模板生成的类之间不能存在任何默认关系(§27.2.1)。但是,对于某些模板,我们想表达这种关系。例如,当我们定义指针模板时,我们希望反映指向的对象之间的继承关系。成员模板(§23.4.6)允许我们在需要的地方指定许多这样的关系。考虑:

template<typename T>

class Ptr { // pointer to T

T∗ p;

public:

Ptr(T∗);

Ptr(const Ptr&); // 复制构造函数

template<typename T2>

explicit operator Ptr<T2>(); // 将Ptr<T> 转换为 Ptr<T2>

// ...

};

我们希望定义转换运算符,为这些用户定义的 Ptr 提供我们习惯的内置指针的继承关系。例如:

void f(Ptr<Circle> pc)

{

Ptr<Shape> ps {pc}; // 应当有效

Ptr<Circle> pc2 {ps}; // 应当会出现错误

}

我们希望当且仅当 Shape 确实是 Circle 的直接或间接公共基类时才允许第一次初始化。一般来说,我们需要定义转换运算符,以便当且仅当 T∗ 可以分配给 T2∗ 时,才接受 Ptr<T> 到 Ptr<T2> 的转换。可以这样做:

template<typename T>

template<typename T2>

Ptr<T>::operator Ptr<T2>()

{

return Ptr<T2>{p};

}

当且仅当 p(T∗)可以作为 Ptr<T2>(T2∗) 构造函数的参数时,返回语句才会编译。因此,如果 T∗ 可以隐式转换为 T2∗,则 Ptr<T> 到 Ptr<T2> 的转换将起作用。例如,我们现在可以写:

void f(Ptr<Circle> pc)

{

Ptr<Shape> ps {pc}; // 正确: 可以将 Circle* 转换为 Shape*

Ptr<Circle> pc2 {ps}; // 错误:不能将 Shape* 转换至 Circle*

}

    请务必谨慎定义具有逻辑意义的转换。如有疑问,请使用命名转换函数,而不是转换运算符。命名转换函数可减少出现歧义的机会。

    模板和其模板成员之一的模板参数列表不能组合。例如:

template<typename T, typename T2> // error

Ptr<T>::operator Ptr<T2>()

{

return Ptr<T2>(p);

}

该问题的另一种解决方案是使用类型特征和 enable_if() (§28.4)。

27.3  类模板层级结构(Hierarchies of Class Templates)

    使用面向对象技术,基类通常用于为一组派生类提供通用接口。可以使用模板来参数化这样的接口,并且当这样做时,很容易用相同的模板参数来参数化派生类的整个层级结构。例如,我们可以用用于提供目标输出“设备”抽象的类型来参数化经典形状示例(§3.2.4):

template<typename Color_scheme , typename Canvas> // 值得怀疑的例子

class Shape {

// ...

};

template<typename Color_scheme , typename Canvas>

class Circle : public Shape {

// ...

};

template<typename Color_scheme , typename Canvas>

class Triangle : public Shape {

// ...

};

void user()

{

auto p = new Triangle<RGB,Bitmapped>{{0,0},{0,60},{30,sqr t(60∗60−30∗30)}};

// ...

}

习惯于面向对象编程的程序员在看到类似 vector<T> 的东西后,通常会首先想到类似的想法。但是,在混合使用面向对象和泛型技术时,建议谨慎行事。

    如上所述,这种参数化的形状层级结构对于实际使用来说过于冗长。可以使用默认模板参数(§25.2.5)解决这个问题。但是,冗长并不是主要问题。如果程序中只使用 Color_scheme 和 Canvas 的一个组合,则生成的代码量几乎与未参数化的等效代码量完全相同。之所以说“几乎”,是因为编译器将抑制类模板中未使用的非虚拟成员函数定义的代码生成。但是,如果程序中使用了 N 个 Color_scheme 和 Canvas 组合,则每个虚拟函数的代码将被复制 N 次。由于图形层级结构可能有许多派生类、许多成员函数和许多复杂函数,因此结果可能是代码膨胀。特别是,编译器无法知道是否使用了虚函数,因此它必须为所有此类函数以及此类函数调用的所有函数生成代码。使用许多虚成员函数来参数化庞大的类层级结构通常是一个糟糕的想法。

    对于此形状示例,Color_scheme 和 Canvas 参数不太可能对接口产生太大影响:大多数成员函数不会将它们作为其函数类型的一部分。这些参数是“逃逸”到接口中的“实现细节”——可能会对性能产生严重影响。实际上,并不是整个层级结构都需要这些参数;而是一些配置函数和(最有可能)一些较低级别的绘制/渲染函数。“过度参数化”(§23.4.6.3)通常不是一个好主意:尽量避免仅影响少数成员的参数。如果只有少数成员函数受参数影响,请尝试使用该参数制作这些函数模板。例如:

class Shape {

template<typename Color_scheme , typename Canvas>

void configure(const Color_scheme&, const Canvas&);

// ...

};

如何在不同的类和不同的对象之间共享配置信息是一个单独的问题。显然,我们不能简单地将 Color_scheme 和 Canvas 存储在 Shape 中,而不使用 Color_scheme 和 Canvas 参数化 Shape 本身。一种解决方案是让 configure() 将 Color_scheme 和 Canvas 中的信息“翻译”为一组标准的配置参数(例如,一组整数)。另一种解决方案是为 Shape 提供一个 Configuration∗ 成员,其中 Configuration 是一个基类,为配置信息提供通用接口。

27.3.1  模板对比接口(Templates as Interfaces)

    模板类可用于为通用实现提供灵活且类型安全的接口。§25.3 中的向量就是一个很好的例子:

template<typename T>

class Vector<T∗>

: private Vector<void∗>

{

// ...

};

一般来说,这种技术可用于提供类型安全的接口和将强制转换局部化到实现,而不是强迫用户编写它们。

27.4  模板参数对比基类(Template Parameters as Base Classes)

    在使用类层级结构的经典面向对象编程中,我们将不同类可能不同的信息放置在派生类中,并通过基类中的虚函数访问这些信息(§3.2.4,§21.2.1)。这样,我们就可以编写通用代码,而不必担心实现中的变化。但是,这种技术不允许我们改变接口中使用的类型(§27.2)。此外,与内联函数的简单操作相比,这些虚函数调用可能很昂贵。为了弥补这一点,我们可以将专门的信息和操作作为模板参数传递给基类。事实上,模板参数可以用作基类。

   以下两个小节要解决的一般问题是“我们如何将单独指定的信息组合成一个具有明确指定接口的单一紧凑对象?”这是一个基本问题,其解决方案具有普遍的重要意义。

27.4.1  组合数据结构(Composing Data Structures)

    考虑编写一个平衡二叉树库。由于我们提供了一个供许多不同用户使用的库,因此我们无法将用户(应用程序)的数据类型构建到我们的树节点中。我们有很多替代方案:

• 我们可以将用户的数据放在派生类中,并使用虚函数访问它。但是虚函数调用(或等效地,运行时解析和检查的解决方案)相对昂贵,并且我们对用户数据的接口不是以用户的类型来表示的,因此我们仍然需要使用强制类型转换来访问它。

• 我们可以在我们的节点中放置一个 void∗,并让用户使用它来引用分配在我们节点之外的数据。但这会使分配的数量增加一倍,增加许多(可能昂贵的)指针取消引用,并增加每个节点中指针的空间开销。我们还需要使用强制类型转换来使用其正确的类型访问我们的用户数据。该强制类型转换无法进行类型检查。

• 我们可以将 Data∗ 放入我们的节点中,其中 Data 是我们数据结构的“通用基类”。这将解决类型检查问题,但它结合了前两种方法的成本和不便。

    还有更多选择,但请考虑:

template<typename N>

struct Node_base { // 不知道关于 Val (用户数据)

N∗ left_child;

N∗ right_child;

Node_base();

void add_left(N∗ p)

{

if (left_child==nullptr)

left_child = p;

else

// ...

}

// ...

};

template<typename Val>

struct Node : Node_base<Node<Val>> { // 使用派生类作为其自身基类的一部分

Val v;

Node(Val vv);

// ...

};

    这里,我们将派生类 Node<Val> 作为模板参数传递给它自己的基类 (Node_base)。这样 Node_base 就可以在其接口中使用 Node<Val>,甚至无需知道其真实名称!

    请注意,Node 的布局非常紧凑。例如,Node<double> 看起来大致相当于:

struct Node_base_double {

double val;

Node_base_double∗ left_child;

Node_base_double∗ right_child;

};

遗憾的是,对于这种设计,用户必须了解 Node_base 的操作和生成的树的结构。例如:

using My_node = Node<double>;

void user(const vector<double>& v)

{

My_node root;

int i = 0;

for (auto x : v) {

auto p = new My_node{x};

if (i++%2) // 选择何处插入

root.add_left(p);

else

root.add_right(p);

}

}

然而,对于用户来说,保持树的结构合理并不容易。通常,我们希望通过实现树平衡算法让树来处理这个问题。然而,为了平衡树以便您可以有效地搜索它,平衡器(balancer)需要知道用户的值。

我们如何将平衡器添加到我们的设计中?我们可以将平衡策略硬连线到 Node_base 中,并让 Node_base “查看”用户数据。例如,平衡树实现(例如标准库映射)(默认情况下)要求值类型提供小于操作。这样,Node_base 操作就可以简单地使用 < :

template<typename N>

struct Node_base {

static_assert(Totally_ordered<N>(), "Node_base: N must have a <");

N∗ left_child;

N∗ right_child;

Balancing_info bal;

Node_base();

void insert(N& n)

{

if (n<left_child)

// ... do something ...

else

// ... do something else ...

}

// ...

};

这很有效。事实上,我们在 Node_base 中构建的节点信息越多,实现就越简单。特别是,我们可以用值类型而不是节点类型来参数化 Node_base(就像对 std::map 所做的那样),这样我们就可以将树放在一个紧凑的包中。然而,这样做并不能解决我们在这里试图解决的基本问题:如何组合来自多个单独指定的来源的信息。把所有东西都写在一个地方可以避免这个问题。

因此,让我们假设用户想要操纵节点(例如,将节点从一棵树移动到另一棵树),这样我们就不能简单地将用户数据存储到匿名节点中。让我们进一步假设我们希望能够使用各种平衡算法,因此我们需要将平衡器作为一个参数。这些假设迫使我们面对根本问题。最简单的解决方案是让 Node 将值类型与平衡器类型结合起来。但是,Node 不需要使用平衡器,因此它只是将其传递给 Node_base:

template<typename Val, typename Balance>

struct Search_node : public Node_base<Search_node<Val, Balance>, Balance>

{

Val val; // user data

search_node(Val v): val(v) {}

};

这里两次提到 Balance,因为它是节点类型的一部分,并且 Node_base 需要创建一个 Balance 类型的对象:

template<typename N, typename Balance>

struct Node_base : Balance {

N∗ left_child;

N∗ right_child;

Node_base();

void insert(N& n)

{

if (this−>compare(n,left_child)) // 使用来自 Balance 的 compare()

// ... do something ...

else

// ... do something else ...

}

// ...

};

我本可以使用 Balance 来定义成员,而不是将其用作基础。但是,一些重要的平衡器不需要每个节点的数据,因此通过将 Balance 作为基础,我可以从空基类优化中受益。该语言保证,如果基类没有非静态数据成员,则不会在派生类的对象中为其分配内存(§iso.1.8)。此外,这种设计与真正的二叉树框架在风格上略有不同 [Austern,2003]。我们可以像这样使用这些类:

struct Red_black_balance {

// 数据和操作需实现为红黑树

};

template<typename T>

using Rbnode = Search_node<T,Red_black_balance>; // 红黑树别名

Rbnode<double> my_root; // double 红黑树

using My_node = Rb_node<double>;

void user(const vector<double>& v)

{

for (auto x : v)

root.insert(∗new My_node{x});

}

    节点的布局紧凑,我们可以轻松内联所有性能关键函数。我们通过略微复杂的定义集实现了类型安全性和易于组合。与将 void∗ 引入数据结构或函数接口的每种方法相比,这种精心设计带来了性能优势。这种 void∗ 的使用禁用了有价值的基于类型的优化技术。在平衡二叉树实现的关键部分选择低级(C 风格)编程技术意味着巨大的运行时成本。

    我们将平衡器作为单独的模板参数传递:

template<typename N, typename Balance>

struct Node_base : Balance {

// ...

};

template<typename Val, typename Balance>

struct Search_node

: public Node_base<Search_node<Val, Balance>, Balance>

{

// ...

};

有些人认为这很清晰、明确且通用;其他人则认为这冗长且令人困惑。另一种方法是将平衡器设为关联类型(Search_node 的成员类型)形式的隐式参数:

template<typename N>

struct Node_base : N::balance_type { // use N’s balance_type

// ...

};

template<typename Val, typename Balance>

struct Search_node

: public Node_base<Search_node<Val,Balance>>

{

using balance_type = Balance;

// ...

};

标准库中大量使用此技术来最小化显式模板参数。

    从基类派生的技术非常古老。它在 ARM (1989) 中被提及,有时被称为 Barton-Nackman 技巧,因为它在数学软件中早期使用[Barton,1994]。Jim Coplien 将其称为奇怪的循环模板模式 (CRTP) [Coplien,1995]。

27.4.2  线性化类层级结构(Linearizing Class Hierarchies)

    §27.4.1 中的 Search_node 示例使用其模板来压缩其表示并避免使用 void∗。这些技术是通用的并且非常实用。特别是,许多处理树的程序都依赖它来实现类型安全和性能。例如,“内部程序表示”(IPR)[DosReis,2011] 是 C++ 代码作为类型抽象语法树的通用和系统表示。它广泛使用模板参数作为基类,既作为实现辅助(实现继承),也以经典的面向对象方式提供抽象接口(接口继承)。该设计解决了一组困难的标准,包括节点的紧凑性(可能有数百万个节点)、优化的内存管理、访问速度(不要引入不必要的间接或节点)、类型安全、多态接口和通用性。

    用户看到的是抽象类的层级结构,它们提供了完美的封装和干净的功能接口,代表了程序的语义。例如,变量是声明,是语句,是表达式,是节点:

Var −> Decl −> Stmt −> Expr −> Node

显然,在 IPR 的设计中已经做了一些概括,因为在 ISO C++ 中语句不能用作表达式。

    此外,还有一个并行的具体类层结结构,为接口层级结构中的类提供紧致、高效的实现:

impl::Var −> impl::Decl −> impl::Stmt −> impl::Expr −> impl::Node

    总共有大约 80 个叶类(例如 Var、If_stmt 和 Multiply)和大约 20 个泛化(例如 Decl、Unary 和 impl::Stmt)。

设计的第一次尝试是经典的多重继承“菱形”层级结构(使用实线箭头表示接口继承,使用虚线箭头表示实现继承):

这种方法虽然有效,但会导致过多的内存开销:由于需要数据来导航虚基类,因此节点太大。此外,由于需要多次间接访问每个对象中的许多虚基类,程序运行速度严重减慢(§21.3.5)。

解决方案是线性化双重层级结构,以便不使用虚基类:

对于完整的类集,派生链变为:

impl::Var −>

impl::Decl<impl::Var> −>

impl::Stmt<impl::Var> −>

impl::Expr<impl::Var> −>

impl::Node<impl::Var> −>

ipr::Var −>

ipr::Decl −>

ipr::Stmt −>

ipr::Expr −>

ipr::Node

   

它表示为一个紧致的对象,除了单个 vptr(§3.2.3,§20.3.2)之外没有内部“管理数据”。

我将展示如何做到这一点。首先描述在命名空间 ipr 中定义的接口层次结构。从底部开始,Node 保存用于优化遍历和 Node 类型识别(code_category)以及简化 IPR 图在文件中存储(node_id)的数据。这些是相当典型的“实现细节”,对用户隐藏。用户会知道的是,IPR 图中的每个节点都有一个唯一的 Node 类型基类,并且可以使用访问者模式 [Gamma,1994](§22.3)来实现操作:

struct ipr::Node {

const int node_id;

const Category_code category;

virtual void accept(Visitor&) const = 0; // 访问者类的钩子

protected:

Node(Category_code);

};

Node 仅用作基类,因此其构造函数受到保护。它还有一个纯虚函数,因此除了作为基类之外,无法实例化。

表达式(Expr)是具有以下类型的节点:

struct ipr::Expr : Node {

virtual const Type& type() const = 0;

protected:

Expr(Category_code c) : Node(c) { }

};

显然,这是对 C++ 的相当概括,因为它意味着即使语句和类型也有类型:IPR 的目标是表示所有 C++,而无需实现 C++ 的所有不规则性和局限性。

    语句 (Stmt) 是一个具有源文件位置并可以用各种信息注释的 Expr:

struct ipr::Stmt : Expr {

virtual const Unit_location& unit_location() const = 0; // 文件中的行

virtual const Source_location& source_location() const = 0; // file

virtual const Sequence<Annotation>& annotation() const = 0;

protected:

Stmt(Category_code c) : Expr(c) { }

};

声明(Decl)是引入名称的 Stmt:

struct ipr::Decl : Stmt {

enum Specifier { /* storage class, vir tual, access control, etc. */ };

virtual Specifier specifiers() const = 0;

virtual const Linkage& lang_linkage() const = 0;

virtual const Name& name() const = 0;

virtual const Region& home_region() const = 0;

virtual const Region& lexical_region() const = 0;

virtual bool has_initializer() const = 0;

virtual const Expr& initializer() const = 0;

// ...

protected:

Decl(Category_code c) : Stmt(c) { }

};

正如您所料,Decl 是表示 C++ 代码的核心概念之一。在这里您可以找到范围信息、存储类、访问说明符、初始化器等。

最后,我们可以定义一个类来表示变量(Var),作为接口层级结构的叶类(最后的派生类):

struct ipr::Var : Category<var_cat, Decl> { };

基本上,Category 是一种符号辅助工具,其作用是从 Decl 派生 Var 并提供用于优化 Node 类型识别的 Category_code:

template<Category_code Cat, typename T = Expr>

struct Category : T {

protected:

Category() : T(Cat) { }

};

每个数据成员都是一个变量。其中包括全局变量、命名空间变量、局部变量和类静态变量及常量。

与编译器中的表示相比,此接口非常小。除了 Node 中用于优化的一些数据外,这只是一组具有纯虚函数的类。请注意,它是一个没有虚基类的单一层次结构。这是一种简单的面向对象设计。但是,要简单、高效且可维护地实现这一点并不容易,而且 IPR 的解决方案肯定不是经验丰富的面向对象设计师首先想到的。

对于每个 IPR 接口类(在 ipr 中),都有一个对应的实现类(在 impl 中)。例如:

template<typename T>

struct impl::Node : T {

using Interface = T; // 使用户可获得模板参数

void accept(ipr::Visitor& v) const override { v.visit(∗this); }

};

“技巧”在于建立 ipr 节点和 impl 节点之间的对应关系。具体来说,impl 节点必须提供必要的数据成员并覆盖 ipr 节点中的抽象虚函数。对于 impl::Node,我们可以看到,如果 T 是 ipr:​​:Node 或任何从 ipr:​​:Node 派生的类,则 accept() 函数被正确覆盖。

    现在,我们可以继续为其余的 ipr 接口类提供实现类:

template<typename Interface>

struct impl::Expr : impl::Node<Interface> {

const ipr::Type∗ constraint; // constraint 是表达式的类型

Expr() : constraint(0) { }

const ipr::Type& type() const override { return ∗util::check(constraint); }

};

如果接口参数是 ipr:​​:Expr 或任何从 ipr:​​:Expr 派生的类,则 impl::Expr 是 ipr:​​:Expr 的实现。我们可以确定这一点。由于 ipr:​​:Expr 是从 ipr:​​:Node 派生的,这意味着 impl::Node 获得了它所需的 ipr:​​:Node 基类。

换句话说,我们成功地为两个(不同的)接口类提供了实现。我们可以按以下方式进行:

template<typename S>

struct impl::Stmt : S {

ipr::Unit_location unit_locus; // 编译单元中的逻辑位置

ipr::Source_location src_locus; // 源文件, 行, 和列

ref_sequence<ipr::Annotation> notes;

const ipr::Unit_location& unit_location() const override { return unit_locus; }

const ipr::Source_location& source_location() const override { return src_locus; }

const ipr::Sequence<ipr::Annotation>& annotation() const override { return notes; }

};

也就是说,impl:Stmt 提供了实现 ipr:​​:Stmt 接口所需的三个数据项,并覆盖了 ipr:​​:Stmt 的三个虚函数来实现这一点。

基本上,所有 impl 类都遵循 Stmt 的模式:

template<typename D>

struct impl::Decl : Stmt<Node<D> > {

basic_decl_data<D> decl_data;

ipr::Named_map∗ pat;

val_sequence<ipr::Substitution> args;

Decl() : decl_data(0), pat(0) { }

const ipr::Sequence<ipr::Substitution>& substitutions() const { return args; }

const ipr::Named_map& generating_map() const override { return ∗util::check(pat); }

const ipr::Linkage& lang_linkage() const override;

const ipr::Region& home_region() const override;

};

最后,我们可以定义叶类 impl::Var:

struct Var : impl::Decl<ipr::Var> {

const ipr::Expr∗ init;

const ipr::Region∗ lexreg;

Var();

bool has_initializer() const override;

const ipr::Expr& initializer() const override;

const ipr::Region& lexical_region() const override;

};

请注意,Var 不是模板;它是我们应用程序中的用户级抽象。Var 的实现是泛型编程的一个示例,但它的使用是经典的面向对象编程。

    继承和参数化的组合非常强大。这种表达能力可能会让初学者感到困惑,有时甚至会让经验丰富的程序员在面对新的应用领域时感到困惑。然而,这种组合的好处是显而易见的:类型安全、性能和最小的源代码大小。类层级结构和虚函数提供的可扩展性不会受到影响。

27.5  建议(Advice)

[1] 当必须用代码表达一个总体思路时,请考虑将其表示为模板还是类层级结构;§27.1。

[2] 模板通常为各种参数提供通用代码;§27.1。

[3] 抽象类可以完全向用户隐藏实现细节;§27.1。

[4] 不规则的实现通常最好表示为派生类;§27.2。

[5] 如果不希望明确使用自由存储,则模板比类层级结构更有优势;§27.2。

[6] 在内联很重要的情况下,模板比抽象类更有优势;§27.2。

[7] 模板接口很容易用模板参数类型来表达;§27.2。

[8] 如果需要运行时解析,则类层级结构是必需的;§27.2。

[9] 模板和类级次结构的组合通常比单独使用任何一种都要好;§27.2。

[10] 将模板视为类型生成器(和函数生成器);§27.2.1。

[11] 从同一模板生成的两个类之间没有默认关系;§27.2.1。

[12] 不要混合类层级结构和数组;§27.2.1。

[13] 不要天真地模板化大型类层级结构;§27.3。

[14] 模板可用于为单个(弱类型)实现提供类型安全的接口;§27.3.1。

[15] 模板可用于组成类型安全和紧致的数据结构;§27.4.1。

[16] 模板可用于线性化类层级结构(最小化空间和访问时间);§27.4.2.

内容来源:

<<The C++ Programming Language >> 第4版,作者 Bjarne Stroustrup

The C++ Programming Language 读书笔记 - Bjarne_Stroustrup 1979年,贝尔丝·斯托芬鲁普(Bjarne_Stroustrup)发表了著名的“C++和对象技术”论文,对C++语言的基础语法、数据结构、类和对象等进行了全面系统的阐述。近几十年来,随着C++作为高级编程语言在工程应用中的广泛接受,学习C++的读者越来越多,但是对于那些从事C++开发工作的人来说,了解C++的背景知识仍然是一个重要的前提。本书就是为了帮助读者理解并掌握C++的语言特性及其背后的原理,帮助读者快速熟悉C++语法和各种数据结构、算法的用法。 阅读详情

相关推荐

探索C++之父Bjarne Stroustrup的编程理念与实践

C++是一种广泛使用的计算机编程语言,它是由贝尔实验室的Bjarne Stroustrup在1979年开发出来的,并在1985年正式发布。C++既保持了C语言的高效率和灵活性,又引入了面向对象编程(OOP)的特性,使得软件开发更加模块化,易于维护。泛型编程是一种编程范式,它侧重于创建可适用于多种数据类型的代码。与面向对象编程(OOP)关注于数据和行为的封装不同,泛型编程更注重在多种数据类型间共享算法和数据结构。

weixin_32999557的博客 1162

C++ Mixin初探

背景 在阅读ceph源码时发现了下面的一处写法,由于本人才疏学浅,这种写法 是第一次接触,一时间不理解这种写法的含义以及设计理念,于是便查找资料学习相关知识。 template<class T> class MDSHolder : public T { ...... }; 最终确定这是c++实现mixin的方式,也就是Template Parameters as Base C...

jiang4357291的博客 2468

Scratch(四十一):升级版垃圾分类

哈喽,大家好!之前给大家展示过“Scratch(二十四):垃圾分类”。今天呢,给大家展示的Scratch是`升级版垃圾分类`。接下来,我们一起看一下效果吧。

我可以很大侠的博客 6871

ReferencePipeline

用于描述中间管道阶段或者管道源阶段的抽象基类。 继承AbstractPipeline,实现 Stream AbstractPipeline 继承 PipelineHelper,实现BaseStream 文档说明 管道类的抽象父类,是 Stream 接口及其原生特化的核心实现。它会管理流管道的构建及评估 AbstractPipeline 代表一个流管道的的初始部分,它封...

aiw5822的博客 1100

M1安装homebrew报错LibreSSL SSL_read: SSL_ERROR_SYSCALL, errno 54解决方法

在mac系统中,使用homebrew可以很方便的管理包。但按照官网的说明执行命令时总是报错原因是这个资源访问有问题,那么我们可以直接使用国内的镜像。给大家推荐一个中国科学技术大学的镜像站点,里面有各种资源https言归正传,开始踩坑。......

qq_42427085的博客 1457

mos管结电容等效模型_MOS管的防冲击防反接电路

MOS管的反接和抑制冲击一:原理分析MOS管由于生产工艺等因素,会产生相应的寄生电容,体二极管等。Mos管的寄生电容如图1所示,可以看到其具有三个寄生电容:G和S的电容Cgs;G和D的电容:Cgd,也称为反向传输电容、米勒电容、Crss;D和S的电容Cds。D和S之间的体二极管D1.图 1:MOS管等效模型寄生电容的数值可以从元器件的datasheet中得到,如图2,图3:Ciss(输入电容)=C...

weixin_29179583的博客 1860

Template Template Parameters(双重模板参数)

一、需求引入  一个  template parameter 本身也可以是个  class template , 这一点非常有用 。 我们将再次以  stack class template 说明这种用法。    为了使用其它类型的元素容器 , stack class  使用者必须两次指定元素类型: 一次是元素类型本身,另一次是容器类型:  Stackint,std::vectorint>

wangdamingll的博客 2858

STM32 FOC半周期控制延时分析与硬件同步配置

在电机矢量控制(FOC)系统中,数字控制延时是影响电流环带宽、观测器收敛性与系统稳定性的核心瓶颈。其本质源于PWM更新、ADC采样与计算执行之间的时序错配,典型表现为1.5个PWM周期的相位滞后,导致滑模观测器(SMO)失效或高速振荡。通过零阶保持(ZOH)建模可量化该延时对系统相频特性的影响,并揭示其等效为0.5u(t)+0.5u(t−1)的平滑控制律。工程上突破的关键在于重构外设协同机制——以高级定时器重复计数器(RCR0)驱动中心对齐PWM的半周期更新事件,使控制量在0.5T_PWM内生效,同步触发多

flink9streamer的博客 1132

C++之父Bjarne Stroustrup:程序员在数学上付出的努力,永远也不会白费

1979年诞生的C++已迈入“不惑之年”,如今却依旧在主流编程语言中占据重要一席。

《程序员》官方BLOG 2万+

肖特基二极管选型参数,结构原理,工艺与注意问题总结

肖特基二极管(Schottky Diode)是一种特殊的二极管,也被称为肖特基势垒二极管。它是利用金属与半导体接触形成的金属-半导体结原理制成的。与传统的PN结二极管相比,肖特基二极管具有更低的正向压降、更高的开关速度、更高的反向恢复时间以及更好的温度稳定性等特点。本文对肖特基二极管的工作原理,结构特点,工艺流程,选型参数及设计注意事项进行总结。

fydar的博客 817

用 CDS 作为 Referenced Data Source 开发 SAP Gateway OData 服务,一条更轻的 SEGW 路线

本文介绍了SAP Gateway项目中从传统手工建模到基于CDS View的现代化开发方式转变。主要内容包括: 传统方式需要在SEGW中手动创建Entity Type、Entity Set等元素,并在DPC_EXT中编写大量查询逻辑,存在模型层和业务逻辑重复表达的问题。 7.50版本后,SAP Gateway与ABAP CDS深度集成,可通过SEGW直接引用CDS View作为数据源,自动生成数据模型和SADL读取逻辑,支持完整的OData查询功能。 最佳实践建议通过Consumption View而非直接

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 707

C++编程语言:抽象机制:第23章——模板(Bjarne Stroustrup)

C++ 抽象机制:模板

ComputerInBook的专栏 1332

【滚雪球学数学建模】第1节·建模入门+三步法+案例

🎓 本文收录于 《滚雪球学数学建模》专栏,本专栏专注于从零基础出发,带你循序渐进掌握数学建模的核心方法与思维路径。通过“滚雪球式”学习法,从最简单的生活化案例到经典建模工具,再到省赛、国赛真题实战演练,逐步积累知识与技能,帮助你搭建完整的建模体系。无论你是刚接触建模的新生,还是希望提升科研与竞赛能力的学者与工程师,本专栏都将为你提供一条清晰、高效、可实操的建模成长路线,助力你快速进阶,突破难点,迈向数学建模竞赛与实际应用的更高峰 🚀!

**My Coding Family** 6415

C++编程语言:抽象机制:第25章——特化(Bjarne Stroustrup)

C++编程语言:特化

ComputerInBook的专栏 1153

2025年开源气象大模型的实现原理与实践指南

气象大模型在人工智能时代实现了革命性突破,通过深度学习技术以更低的计算成本达到甚至超越传统数值天气预报的精度。开源气象大模型的出现使得全球研究者和机构都能参与气象AI的创新。本文详细解析了开源气象大模型的实现原理,包括核心架构、数据准备、训练方法和实际预测流程,并提供了实践指南。核心架构主要采用Transformer、图神经网络和扩散模型,处理多模态数据融合和时空联合建模。数据体系构建涉及数据来源、预处理和增强策略。模型训练关键技术包括损失函数设计、分布式训练优化和训练过程监控。微调与领域适应策略包括迁移学

专注AI大模型,软件混淆,授权 1183

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

从丹麦的旧GIER到C++之父Bjarne Stroustrup ,未来属于理想者

Bjarne创造C++的初衷是为了实现高效使用硬件与强大抽象机制的结合。当时,他想用通信系统构建一个多计算机系统,这个通信系统可以是共享内存,也可以是网络。他需要编写底层接近硬件的代码,如内存管理器、进程调度程序和设备驱动程序,同时也需要软件分离组件以便它们以良好方式进行通信。而在当时,没有一种语言能够胜任这样的多计算机系统开发需求,于是他在C语言的基础上引入并扩充了面向对象的概念,发明了C++,这个结果是他付出众多时间与打磨的甘甜果实。

敖行客 Allthinker的博客 1511

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

C++编程语言:抽象机制:第24章——泛型编程(Bjarne Stroustrup)

C++ 泛型编程

ComputerInBook的专栏 890

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

C++编程语言:抽象机制:第16章——类(Bjarne Stroustrup)

C++抽象机制:类

ComputerInBook的专栏 1086

C++编程语言:抽象机制:第29章——一个矩阵的设计(Bjarne Stroustrup)

一个矩阵的设计:C++实现

ComputerInBook的专栏 1260

C++ 之父 Bjarne Stroustrup : 简单的表述方式才是最优的方案

2016 年的最后一天,图灵访谈给各位小伙伴儿献上特大彩蛋!借用 Bjarne 大师的话“趁你还足够年轻的时候,喜欢上某些学科,选择具有挑战性和感兴趣的工作并养成良好的习惯!”,预祝你们在 2017 年找到新的方向! Bjarne Stroustrup(本贾尼·斯特劳斯特卢普) 1982 年,贝尔实验室(美国 AT&T 公司)的 Bjarne Stroustrup 博士在 C 语言的基础...

Harrytsz的博客 1359

C++语言演进与Bjarne Stroustrup的跨世纪思考

从C++11的类型推导到C++20的Concepts,类型系统完成了从隐式规则到显式约束的转变。正如他常说的:"C++不是要变得简单,而是要变得更不容易出错"——这或许就是这门历经45年演进的语言给我们的终极启示。更令人兴奋的是C++20引入的协程,这让异步代码的编写变得像同步代码般直观。从早期的auto_ptr到现在的unique_ptr/shared_ptr,我们经历了所有权语义的不断完善。通过简单的网页操作就能对比C++11到C++20的编译差异,比本地配置开发环境方便太多。类型系统的革命性演进。

QuartzLynx65的博客 749

C++编程语言:抽象机制:第26章——实例化(Bjarne Stroustrup)

C++ 抽象机制:实例化

ComputerInBook的专栏 759

C++之父Bjarne Stroustrup亲临现场,2025全球C++及系统软件技术大会重磅官宣

在这个以算力与效率为信仰的时代,C++ 再次被推到聚光灯下——无论是 OpenAI 的推理引擎,还是 NVIDIA 的加速库、DeepSeek 的底层编译框架,C++ 依然是那根隐形的钢梁,支撑着智能世界的底座。他是 C++ Reflection TS 的项目编辑、Boost 基金会的执行董事,也是模式匹配和语言变体等多个 C++ 提案的作者。年,Bjarne 在全球 C++ 大会上的主题是 「原则、问题与解决方案」,他深入剖析了 C++ 社区所面临的核心挑战,同时为未来语言的发展制定了战略方向。

优快云资讯 7578

C++之父Bjarne Stroustrup: 简单的表述方式才是最优的方案(图灵访谈)

2016年的最后一天,图灵访谈给各位小伙伴儿献上特大彩蛋!借用Bjarne大师的话“趁你还足够年轻的时候,喜欢上某些学科,选择具有挑战性和感兴趣的工作并养成良好的习惯!”,预祝你们在2017年找到新的方向!

TuringInterview的博客 915

C++之父Bjarne Stroustrup:如何学习C/C++语言

C++ 使用的成长及其性质,已经受到学习C++ 的方式的强有力影响。由此可知,如果对应该如何教和学C++ 缺乏认识的话,要想理解它就可能比较困难。如果缺乏这方面的认识,可能就无法理解C++的快速成长的某些方面。 关于应该如何有效地将C++ 教给相对而言的新手,如何使他们能有效地使用学到的东西,这些问题从很早就影响着C++ 的设计。我做了许多教学工作——至少是做了许多教授某些研究者(并不是专业的教育工作者)的工作。我一直设法将自己的想法传播出去,在观察自己和别人所教的人们写出的实际程序方面,有许多成功与失败

人邮异步社区 2678

C++之父访谈录:我也没想到 C ++ 会这么成功!

强大、灵活、复杂:C ++的起源可以追溯到40年前,如今,它仍然是当今使用最广泛的编程语言之一。为什么C > ++能够长盛不衰?TechRepublic对C ++之父Bjarne Stroustrup进行访谈,了解在他眼中的C ++。

优快云资讯 2万+
上一篇: C++编程语言:抽象机制:第26章——实例化(Bjarne Stroustrup)
下一篇: 什么是超越编程(逾编程)(元编程?)
ComputerInBook
博客等级 码龄19年 1168粉丝 465原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值