STL-General.rar_STL资源-CSDN下载

共1个文件

pdf：1个

版权申诉

127 浏览量 2022-09-21 17:33:13 上传评论收藏 46KB RAR 举报

STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的数据结构和算法。STL的主要目标是提高代码的可读性、可维护性和性能，通过使用泛型编程（Generic Programming）理念实现。在“STL General.rar_STL”这个压缩包中，我们主要会了解到STL的基本概念、主要组件以及如何在实际编程中应用它们。 STL的核心组件包括容器（Containers）、迭代器（Iterators）、算法（Algorithms）和函数对象（Function Objects，也称为仿函数或Functors）。容器是用来存储元素的类模板，如vector、list、deque、set和map等，它们提供了不同类型的元素组织方式。迭代器则充当容器中的指针，可以用来遍历容器内的元素，并支持多种操作，如前向、反向、随机访问等。算法是执行特定操作的一组模板函数，如排序、查找、复制等，它们可以作用于任何满足特定要求的迭代器范围。函数对象则封装了函数调用行为，使得可以像操作普通对象一样使用函数。容器之间各有特点。例如，vector是动态数组，支持随机访问但插入和删除操作在中间位置相对较慢；list是双向链表，插入和删除速度快，但访问速度较慢；set和map是基于红黑树的数据结构，可以实现快速查找，但插入和删除的速度介于vector和list之间。 STL的另一个重要特点是它的泛型性。由于所有组件都是模板定义的，因此可以应用于任何类型的数据，只要这些数据类型满足相应的接口要求。这种设计使得STL具有极高的可重用性和灵活性。在实际编程中，STL的使用通常涉及以下几个步骤：选择合适的容器来存储数据，根据需求定义迭代器类型，然后使用算法对容器中的元素进行操作。例如，如果需要对一组整数进行排序，可以先创建一个vector，用push_back()函数添加元素，然后调用sort()算法进行排序。 STL还包含了一些辅助组件，如分配器（Allocators）、适配器（Adapters，如stack和queue）以及用于内存管理的智能指针（Smart Pointers）。分配器允许用户自定义内存管理策略，适配器将基本容器转化为更特殊的结构，如栈和队列，而智能指针则提供了自动内存管理，防止内存泄漏。在STL General.pdf文档中，你将详细学习到STL的每个部分，包括其设计哲学、使用方法、性能优化技巧以及常见问题的解决办法。通过对STL的深入理解和熟练运用，你将能够编写出更加高效、易维护的C++代码。

资源推荐

资源详情

资源评论

收起资源包目录

STL-General.rar （1个子文件）

STL General.pdf 54KB

A modest STL tutorial

By Jak Kirman

I am using a software tool called hyperlatex to create this document. The tutorial is also available in

compressed postscript form. For those wanting to install a copy of these pages on their system, they

may be freely copied providing they are not modified in any significant way (other than, say, locale

changes). The file tutorial.tar.Z contains a tarred distribution of the pages. Please note that I will be

making modifications to this document in the coming months, so you may want to occasionally

check for changes. I will start putting in version numbers, and if I can manage to, changebars.

Disclaimer

I started looking at STL a little over a year ago; for a long time I could compile only minimal

subsets of the HP version of the library. More recently, the compilers used by the students I teach

have been able to support more of STL, and I have been adding it to the introductory and advanced

courses I teach.

I have been using C++ for six or seven years, and teaching C++ and object-oriented design courses

in industry for five. I really like the design philosophies in STL; I think that you can learn a great

deal about how generalization can simplify programming by understanding why STL is constructed

the way it is.

At the moment, books are starting to appear on STL; I haven’t yet bought any of them, but I have

looked at some. I would be very interested to hear peoples’ opinions of any books written on STL.

I haven’t seen very much online documentation on STL, apart from the good but rather dense paper

by Stepanov and Lee, I thought I would try to write something to give people a taste of what a good

library will be do for them.

Another reason for getting people to start trying out STL soon is to put pressure on the

compiler-writers to get their compilers patched up enough to take the strain it puts on them...

This is a fairly recent project (started April 1995) to which I can’t devote too much time, so it is still

very short, and pretty poorly organized.

I would greatly appreciate comments or suggestions from anyone.

Outline

STL contains five kinds of components: containers, iterators, algorithms, function objects and

allocators.

In the section Example I present a simple example, introducing each of the five categories of STL

components one at a time.

In the section Philosophy I explain the rationale behind the organization of STL, and give some

hints on the best ways to use it. (Not yet written)

The Components section goes into each category of component in more detail.

The section Extending STL shows how to define your own types to satisfy the STL requirements.

(Not yet written)

A first example

Most of you probably use some kind of auto-allocating array-like type. STL has one called vector.

To illustrate how vector works, we will start with a simple C++ program that reads integers, sorts

them, and prints them out. I will gradually replace bits of this program with STL calls.

Version 1: Standard C++

Here is a standard C++ program to read a list of integers, sort them and print them:

#include <stdlib.h>

#include <iostream.h>

// a and b point to integers. cmp returns -1 if a is less than b,

// 0 if they are equal, and 1 if a is greater than b.

inline int cmp (const void *a, const void *b)

{

int aa = *(int *)a;

int bb = *(int *)b;

return (aa < bb) ? -1 : (aa > bb) ? 1 : 0;

}

// Read a list of integers from stdin

// Sort (c library qsort)

// Print the list

main (int argc, char *argv[])

{

const int size = 1000; // array of 1000 integers

int array [size];

int n = 0;

// read an integer into the n+1 th element of array

while (cin >> array[n++]);

n--; // it got incremented once too many times

qsort (array, n, sizeof(int), cmp);

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

cout << array[i] << "\n";

}

Version 2: containers, iterators, algorithms

STL provides a number of container types, representing objects that contain other objects. One of

these containers is a class called vector that behaves like an array, but can grow itself as necessary.

One of the operations on vector is push_back, which pushes an element onto the end of the vector

(growing it by one).

A vector contains a block of contiguous initialized elements -- if element index k has been

initialized, then so have all the ones with indices less than k.

Notice that this means you cannot just bang things into a vector in a random order; it has to be

grown like a worm. If efficiency is not a primary concern, you could use a map from integers to

values in order to fill a vector in random order.

You can ask a vector how many elements it has with size. This is the logical number of elements

-- the number of elements up to the highest-indexed one you have used. There is a also a notion of

capacity -- the number of elements the vector can hold before reallocating.

Let’s read the elements and push them onto the end of a vector. This removes the arbitrary limit on

the number of elements that can be read.

Also, instead of using qsort, we will use the STL sort routine, one of the many algorithms provided

by STL. The sort routine is generic, in that it will work on many different types of containers. The

way this is done is by having algorithms deal not with containers directly, but with iterators.

Preview of iterators

I’ll go into iterators in detail later, but for now here is enough to get started.

Iterators provide a way of specifying a position in a container. An iterator can be incremented or

dereferenced, and two iterators can be compared. There is a special iterator value called

"past-the-end".

You can ask a vector for an iterator that points to the first element with the message begin. You

can get a past-the-end iterator with the message end. The code

vector<int> v;

// add some integers to v

vector::iterator i1 = v.begin();

vector::iterator i2 = v.end();

will create two iterators like this:

Operations like sort take two iterators to specify the source range. To get the source elements, they

increment and dereference the first iterator until it is equal to the second iterator. Note that this is a

semi-open range: it includes the start but not the end.

Two vector iterators compare equal if they refer to the same element of the same vector.

Putting this together, here is the new program:

#include <string.h>

#include <algo.h>

#include <vector.h>

#include <stdlib.h>

#include <iostream.h>

main ()

{

vector<int> v; // create an empty vector of integers

int input;

while (cin >> input) // while not end of file

v.push_back (input); // append to vector

// sort takes two random iterators, and sorts the elements between

// them. As is always the case in STL, this includes the value

// referred to by first but not the one referred to by last; indeed,

// this is often the past-the-end value, and is therefore not

// dereferenceable.

sort(v.begin(), v.end());

int n = v.size();

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

cout << v[i] << "\n";

}

Incidentally, this is much faster than qsort; at least a factor of 20 on the examples I tried. This is

presumably due to the fact that comparisons are done inline.

Version 3: iterator adaptors

In addition to iterating through containers, iterators can iterate over streams, either to read elements

or to write them.

评论收藏

内容反馈

版权申诉

JaniceLu

粉丝: 109

STL-General.rar_STL

STL.rar_STL

stl.rar_STL

STL-Manual.rar_stl chm

STL.rar_3d_STL_STL文件显示_labview_stl顶点向量

pb_Stl-master.zip

stl-views.gdb

stl-view.rar_ STL _stl view_stl 3D_stl 3d view_stl-view

STL文档

常用STL模型文件

stl文件格式

STL.rar_STL_STL 库

STL.rar_STL_stl.

SGI-STL-.rar_STL_sgi stl

STL-MOUSEMOVE.rar_STL opengl_STL文件_VC 界面_stl vc_鼠标 旋转

sgi-STL.rar_STL_sgi_sgi stl

source-stl.rar_STL 源码_stl source_stl 代码

STL-Web-Server.rar_stl web_web服务器

STL.rar_stl编程

STL_STL_

STL.rar_学习使用STL

STL.rar_stl入门

STL源码.rar

stl_map.rar_event

vc-stl.rar_STL_VC STL_stl 坐标_vc CAD STL_vc++读取 显示

Class-Files.rar_algorithms

node-stl.zip_.stl文件_STL文件_stl 体积_stl模型_体积 STL

stl_algobase.h

前端-css，基础知识，需要了解需要使用

5G移动通信：从理论到实践

最新资源

STL-MOUSEMOVE.rar_STL opengl_STL文件_VC 界面_stl vc_鼠标旋转

vc-stl.rar_STL_VC STL_stl 坐标_vc CAD STL_vc++读取显示