在通用编程/TMP 世界中,模型/策略和“概念”到底是什么?

发布于 2024-08-20 15:53:31 字数 383 浏览 6 评论 0原文

我想在一处了解这三个概念的精确而简洁的定义。答案的质量应该取决于以下两点。

  1. 显示一个简单的代码片段来展示该概念/技术的用途和用途。
  2. 足够简单易懂,以便没有接触过该领域的程序员也能掌握。

注意:

可能有很多正确答案,因为每个概念都有许多不同的方面。 如果有很多好的答案,我最终会将问题转为 CW 并汇总答案。

-- 接受后编辑 --

Boost 有一篇关于通用编程概念的很好的文章

I'd like to know the precise yet succinct definitions of these three concepts in one place. The quality of the answer should depend on the following two points.

  1. Show a simple code snippet to show how and what the concept/technique is used for.
  2. Be simple enough to understand so that a programmer without any exposure to this area can grasp it.

Note:

There are probably many correct answers since each concept has many different facets. If there are a lot of good answers I will eventually turn the question into CW and aggregate the answers.

-- Post Accept Edit --

Boost has a nice article on generic programming concepts

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(3

反差帅 2024-08-27 15:53:31

概念是对类型的一组要求。例如,您可以有一个名为“RandomAccessible”的概念,它要求在 O(1) 时间内实现 operator[](int) 的类型。

由于概念从即将推出的 C++ 标准中被删除,它们仅作为文档无形地存在于 C++ 中。例如,您可以阅读SGI 对容器概念的描述

当一种类型满足某个概念的所有要求时,您可以将其称为该概念的模型。例如,std::vector 是 Container 概念的模型(或者等效地,std::vector“models”Container)。

最后,策略是一个行为单元,它可以与其他行为单元结合起来构建复杂的类。例如,假设您想构建两个类:一个固定大小的数组和一个动态调整大小的数组。这两个类都有很多共享功能,但只是存储机制和某些功能不同(例如,您不能在固定大小的数组上调用 push_back)。

template <class T, class StoragePolicy>
class array : public StoragePolicy
{
public:
  T& operator[](int i) { return data[i]; }
};

template <class T, int N>
class fixed_storage
{
  T data[N];
};

template <class T>
class dynamic_storage
{
  T* data;

public:
  void push_back(const T& value) 
  {
    // Code for dynamic array insertion
  }
};

用法如下:

int main()
{
  array<int, fixed_storage<int, 10> > fixed_array;
  array<int, dynamic_storage<int> > dynamic_array;

  dynamic_array.push_back(1);
  fixed_array[9] = dynamic_array[0];
}

显然这是一个非常粗糙且不完整的示例,但我希望它能够阐明策略背后的概念。

请注意,在示例中,我们可以说 fixed_storagedynamic_storageStoragePolicy 概念的“模型”。当然,我们需要正式定义 StoragePolicy 概念对其模型的要求。在这种情况下,只需定义一个可索引的 data 成员变量即可。

A concept is a set of requirements on a type. For example, you could have a concept called "RandomAccessible", which places the requirement on a type that it implements operator[](int) in O(1) time.

As concepts were dropped from the upcoming C++ standard, they only exist intangibly in C++ as documentation. As an example, you could read SGI's description of the Container concept.

When a type meets all the requirements of a concept, you call it a model of that concept. For example, std::vector is a model of the Container concept (or, equivalently, std::vector "models" Container).

Finally, a policy is a unit of behaviour, which can be combined with other units of behaviour to build complex classes. For example, say you wanted to build two classes: a fixed-size array, and a dynamically-resizable array. Both these classes have a lot of shared functionality, but just differ in their storage mechanisms, and some of their functionality (e.g. you can't call push_back on a fixed-size array).

template <class T, class StoragePolicy>
class array : public StoragePolicy
{
public:
  T& operator[](int i) { return data[i]; }
};

template <class T, int N>
class fixed_storage
{
  T data[N];
};

template <class T>
class dynamic_storage
{
  T* data;

public:
  void push_back(const T& value) 
  {
    // Code for dynamic array insertion
  }
};

Usage would be as follows:

int main()
{
  array<int, fixed_storage<int, 10> > fixed_array;
  array<int, dynamic_storage<int> > dynamic_array;

  dynamic_array.push_back(1);
  fixed_array[9] = dynamic_array[0];
}

Obviously this is a very crude and incomplete example, but I hope it illuminates the concept behind a policy.

Note that in the example, we could say that fixed_storage and dynamic_storage are "models" of the StoragePolicy concept. Of course, we would need to formally define exactly what the StoragePolicy concepts requires of its models. In this case, it would simply be to define an indexable data member variable.

音栖息无 2024-08-27 15:53:31

SGI 文档将“模型”称为 C++0x 提案中作为“概念”引入的内容:它是编译时,相当于 OO 建模中的“接口”。它总结了通用代码对模板参数提出的要求。

例如,您可以说 std::transform 函数的 OutputIterator 参数应该实现 operator++()operator=( T ) 以便该功能正常工作。

策略是另一回事:它使算法可以从外部更改。一个很好的例子是 stl 容器中较少使用的 Allocator 参数:它告诉算法如何分配内存。如果愿意,可以创建一个 std::vector,其中整个 vector 函数将在云端而不是在云端分配内存。堆。 (请注意,我不太容易实现这个分配器)。

A.o. the SGI documentation refers to 'model' as to what was introduced as 'concepts' in a C++0x proposal: it's the compile-time equivalent to what an 'interface' is in OO modelling. It summarizes the requirements generic code poses on a template parameter.

As an example you can say that the OutputIterator parameters of the std::transform function should implement operator++() and operator=( T ) in order for the function to work.

The policy is another thing: it makes an algorithm changeable from the outside. A nice example is the less used Allocator parameter of the stl containers: it tells the algorithm how to allocate memory. If one wants to, one can make a std::vector<int, AllocateOnCloud>, where the whole of the vector functions would allocate memory in the cloud instead of on the heap. (I'm not apt to implement this allocator, mind).

独享拥抱 2024-08-27 15:53:31

概念是类型必须满足的一组要求,以便对概念进行建模。

例如,如果对于类型为 的一对对象 ab,则类型 TLessThanComparable T 表达式 a < b 格式良好,可转换为 bool 并产生严格的弱排序关系。 int 类型是 LessThanComparable 模型的示例。

概念可以形成细化层次结构。如果A 的需求是B 的需求的超集,则概念A 是概念B 的细化。例如, Bi DirectionIterator 是 < a href="http://www.sgi.com/tech/stl/ForwardIterator.html" rel="nofollow noreferrer">ForwardIterator

概念用于限制模板可以专用的类型集。例如,std::sort 算法可以接受一对对象,只要它们建模 RandomAccessIterator

std::vector<int> vec;
std::list<int> list;

// OK, std::vector<int>::iterator is a model of `RandomAccessIterator`.
std::sort(vec.begin(), vec.end());

// error, std::list<int>::iterator is only a model of `BidirectionalIterator`.
std::sort(list.begin(), list.end());

请注意,概念是 C++ 标准和各种其他文档中使用的非正式对象。该语言不直接支持概念()。

A concept is a set of requirements that a type must satisfy in order to model the concept.

For example, a type T is LessThanComparable if for a pair of objects a and b of type T the expression a < b is well-formed, convertible to bool and induces a strict weak ordering relation. The type int is an example of a model of LessThanComparable.

Concepts can form refinement hierarchies. Concept A is a refinement of concept B if the requirements of A are a superset of the requirements of B. For example, BidirectionalIterator is a refinement of ForwardIterator.

Concepts are used to restrict the set of types a template can be specialized with. For example, the std::sort algorithm can accept a pair of objects as long as they model RandomAccessIterator.

std::vector<int> vec;
std::list<int> list;

// OK, std::vector<int>::iterator is a model of `RandomAccessIterator`.
std::sort(vec.begin(), vec.end());

// error, std::list<int>::iterator is only a model of `BidirectionalIterator`.
std::sort(list.begin(), list.end());

Note that concepts are informal objects used in the C++ standard and various other documents. The language does not support concepts directly (yet).

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文