Complete Traversals and their Implementation Using the Standard Template Library

Standard iteration mechanisms, even ones of such generality as those in the C++ Standard Template Library (STL), do not allow insertions to be made in a container during a traversal of the container. Since ad hoc ways of handling such iterations are tedious to program and error-prone, programmers should ideally have at their command an efficient generic solution. In earlier work we formally characterized the complete traversal problem and presented generic solutions by means of two generic algorithms and a container adaptor, all defined within the STL framework. Here we develop additional theory for reasoning about complete traversals and address the question of how general the complete traversal problem is by showing that it subsumes well-known graph (or relation) problems such as reachability and transitive closure.

In my last column (see ibid., January/February 2001), I talked about a notational device for matrix algebra called tensor diagrams. This time I write some C++ code to symbolically evaluate these quantities. This gives me a chance to play with some as yet untried features in the C++ standard library, such as strings and standard template library (STL) container classes.

This tutorial gives an overview of the C++ standard template library (STL), including its overall structure, functionality, and capabilities. Particular emphasis is placed on the ways in which STL ...

A functional style of programming has become common in C++, following the introduction of the Standard Template Library (STL) into C++'s standard library. C++ is, however, notably lacking in its support for this style and thus cannot take full advantage of its own standard libraries. C++'s mechanisms for defining functions or objects to pass to STL algorithms are overly verbose. The effective use of modern C++ libraries calls for lambda functions in the language.This paper describes a design and implementation of built-in lambda functions for C++. C++'s compilation model, where activation records are maintained in a stack, and the lack of automatic object lifetime management, make safe lambda functions and closures challenging: if a closure outlives its scope of definition, references stored in a closure dangle. Our design is careful to balance between conciseness of syntax and explicit annotations to guarantee safety.Lambda functions can be declared without annotating their parameter types. C++0x, the forthcoming revision of standard C++, supports constrained templates and modular type checking. We describe how to infer parameter types of lambda functions from the constraints of generic functions in order to support modular type checking in the presence of lambda functions. Our design is currently under consideration for adoption to C++0x.

A short example of a Windows® application is modified to use the generic containers, iterators, and function adapters of the C++ Standard Template Library. Comparison is made with the containers and iteration mechanism provided by the Microsoft Foundation Classes.

We present DASH, a C++ template library that offers distributed data structures and parallel algorithms and implements a compiler-free PGAS (partitioned global address space) approach. DASH offers many productivity and performance features such as global-view data structures, efficient support for the owner-computes model, flexible multidimensional data distribution schemes and interoperability with STL (standard template library) algorithms. DASH also features a flexible representation of the parallel target machine and allows the exploitation of several hierarchically organized levels of locality through a concept of Teams. We evaluate DASH on a number of benchmark applications and we port a scientific proxy application using the MPI two-sided model to DASH. We find that DASH offers excellent productivity and performance and demonstrate scalability up to 9800 cores.

Traditional static checking centers around finding bugs in programs by isolating cases where the language has been used incorrectly. These language‐based checkers do not understand the semantics of software libraries, and therefore cannot be used to detect errors in the use of libraries. In this paper, we introduce STLlint, a program analysis we have implemented for the C++ Standard Template Library and similar, generic software libraries, and we present the general approach that underlies STLlint. We show that static checking of library semantics differs greatly from checking of language semantics, requiring new representations of program behavior and new algorithms. Major challenges include checking the use of generic algorithms, loop analysis for interfaces, and organizing behavioral specifications for extensibility. Copyright © 2005 John Wiley & Sons, Ltd.

An architecture for generic extensions

Generic libraries, such as the C++ Standard Template Library (STL), provide flexible, high-performance algorithms and datatypes, along with functional specifications and guarantees. It is left as a nontrivial task to the library user to choose appropriate algorithms and data types for a particular problem. In the present paper, we describe an automatic analysis to aid library users in selecting types for use in generic programs. The analysis is based on manipulation and comparison of symbolic complexity expressions, constructed using cost-bound functions and abstract interpretation of program behaviour. Our analysis serves to detect and rectify performance bugs by recommending type selections that will improve performance.

This paper describes a suite of laboratory experiments for a CS2 course. The main thrust of the experiments is to promote an understanding of a container-class library: the Standard Template Library for C++ or the Java Generic Library for Java. All of the experiments are stored on the World Wide Web, and students have considerable latitude on when each experiment must be completed.

In the west inland of China, construction of large-span bridges become more and used, but in the existing anti-wind specification there is not the explicit values of strong wind characteristic parameters for inland areas influenced by complex mountainous region. Considering the phenomenon that the study on field measurement of turbulence characteristics has not yet been developed and combining the cable-stayed bridge with span 352m in the western gap of valley areas, a data processing system of wind speed observation based on Borland C++ Builder is compiled. The system can quickly and intelligently realize the statistical analysis of wind field monitoring data by the integration with standard template library (STL) which is defined as vector in C++. The paper presents program function, structure and development thoughts. Through the analysis for one-year field measured data, strong wind characteristics such as, the mean wind velocity, direction, turbulence intensity, gust factor and turbulence integral length are obtained. The results of the analysis provide the bases for wind tunnel test, flutter and buffeting analysis and wind load calculation and the results are compared with those of numerical simulation by FLUENT. The reliability and efficiency are confirmed.

This paper describes a suite of laboratory experiments for a CS2 course. The main thrust of the experiments is to promote an understanding of a container-class library: the Standard Template Library for C++ or the Java Generic Library for Java. All of the experiments are stored on the World Wide Web, and students have considerable latitude on when each experiment must be completed.

Boost provides a collection of free peer-reviewed portable C++ source libraries that work well with, and are in the same spirit as, the C++ Standard Template Library (Stl). The Boost Graph Library (Bgl) [198], which is one of the libraries in the collection, offers an extensive set of generic graph-algorithms.

All engineering disciplines rely on standard components to design and build artifacts. The key technical challenge in software engineering is to enable the adoption of such a model to the development of software. The transformation from line-by-line development to component-based development will address many of the industry's persistent productivity and quality problems. Indeed, component-based software development has been a long-standing dream of the software industry, prompting a search for both technical and nontechnical solutions. A successful approach to component-based development requires a comprehensive solution that draws on advances in programming languages, programming paradigms, algorithm analysis, and software design. This paper presents an approach based on the C++ Standard Template Library. More than a traditional library, STL embodies a concrete approach to software design based on a well-defined taxonomy and theory of software components. I present the fundamental contributions of STL to a paradigm of component programming — a component-based software development paradigm in which there is a clear separation between component development and application development. I motivate component programming, give the requirements for components and catalogs, and give an example of component programming applied to the standard Keyword in Context (KWIC) problem. I then summarize the implications of component programming for the software industry and for software engineering education.

From a high level point of view, developers define objects they manipulate in terms of structures or classes. For example, a pixel may be represented as a structure of three color components : red, green, blue and an image as an array of pixels. In such cases, the data layout is said to be organized as an array of structures (AoS). However, developing efficient applications on modern processors and accelerators often require to organize data in different ways. An image may also be stored as a structure of three arrays, one for each component. This data layout is called a structure of array (SoA) and is also mandatory to take advantage of SIMD units embedded in all modern processors. In this paper, we propose a lightweight C++ template-based framework to provide the high level representation most programmers use (AoS) on different data layouts fitted for SIMD vectorization. Some templated containers are provided for each proposed layout with a uniform AoS-like interface to access elements. Containers are transformed into different combinations of tuples and vectors from the C++ Standard Template Library (STL) at compile time. This way, we provide more optimization opportunities for the code, especially automatic vectorization. We study the performance of our data-layouts and compare them to their explicit versions, based on structures and vectors, for different algorithms and architectures (x86 and ARM). Results show that compilers do not always perform automatic vectorization on our data-layouts as with their explicit versions even if underlying containers and access patterns are similar. Thus, we investigate the use of SIMD intrinsics and of Boost.SIMD ! /bSIMD libraries to vectorize the codes. We show that combining our approach with Boost.SIMD/bSIMD libraries ensures a similar performance as with a manual vectorization using intrinsics, and in almost all cases better performance than with automatic vectorization without increasing the code complexity.