Paint Java Tutorial

Paint Java Tutorial

Standard Template Library

Overview

Please help improve this article by adding reliable references. Unsourced material may be challenged and removed. (September 2007)

The STL provides a ready-made set of common classes for C++, such as containers and associative arrays, that can be used with any built-in type and with any user-defined type that supports some elementary operations (such as copying and assignment). STL algorithms are independent of containers, which significantly reduces the complexity of the library.

The STL achieves its results through the use of templates. This approach provides compile-time polymorphism that is often more efficient than traditional run-time polymorphism. Modern C++ compilers are tuned to minimize any abstraction penalty arising from heavy use of the STL.

The STL was created as the first library of generic algorithms and data structures for C++, with four ideas in mind: generic programming, abstractness without loss of efficiency, the Von Neumann computation model, and value semantics.

Contents

Containers

The STL contains sequence containers and associative containers. The standard sequence containers include vector, deque, and list. The standard associative containers are set, multiset, map, and multimap. There are also container adaptors queue, priority_queue, and stack, that are containers with specific interface, using other containers as implementation.

Container

Description

Sequences (Arrays / Linked Lists) - ordered collections

vector

a dynamic array, like C array (i.e., capable of random access) with the ability to resize itself automatically when inserting or erasing an object. Inserting and removing an element to/from back of the vector at the end takes amortized constant time. Inserting and erasing at the beginning or in the middle is linear in time.

A specialization for type bool exists, which optimizes for space by storing bool values as bits.

list

a doubly-linked list; elements are not stored in contiguous memory. Opposite performance from a vector. Slow lookup and access (linear time), but once a position has been found, quick insertion and deletion (constant time).

deque (double ended queue)

a vector with insertion/erase at the beginning or end in amortized constant time, however lacking some guarantees on iterator validity after altering the deque.

Container adaptors

queue

Provides FIFO queue interface in terms of push/pop/front/back operations.

Any sequence supporting operations front(), back(), push_back(), and pop_front() can be used to instantiate queue (e.g. list and deque).

priority_queue

Provides priority queue interface in terms of push/pop/top operations (the element with the highest priority is on top).

Any random-access sequence supporting operations front(), push_back(), and pop_front() can be used to instantiate priority_queue (e.g. vector and deque).

Elements should additionally support comparison (to determine which element has a higher priority and should be popped first).

stack

Provides LIFO stack interface in terms of push/pop/top operations (the last-inserted element is on top).

Any sequence supporting operations back(), push_back(), and pop_back() can be used to instantiate stack (e.g. vector, list, and deque).

Associative containers - unordered collections

set

a mathematical set; inserting/erasing elements in a set does not invalidate iterators pointing in the set. Provides set operations union, intersection, difference, symmetric difference and test of inclusion. Type of data must implement comparison operator < or custom comparator function must be specified. Implemented using a self-balancing binary search tree.

multiset

same as a set, but allows duplicate elements.

map

an associative array; allows mapping from one data item (a key) to another (a value). Type of key must implement comparison operator < or custom comparator function must be specified. Implemented using a self-balancing binary search tree.

multimap

same as a map, but allows duplicate keys.

hash_set

hash_multiset

hash_map

hash_multimap

similar to a set, multiset, map, or multimap, respectively, but implemented using a hash table; keys are not ordered, but a hash function must exist for the key type. These containers are not part of the C++ Standard Library, but are included in SGI's STL extensions, and are included in common libraries such as the GNU C++ Library in the __gnu_cxx namespace. These are scheduled to be added to the C++ standard as part of TR1, with the slightly different names of unordered_set, unordered_multiset, unordered_map and unordered_multimap.

Other types of containers

bitset

stores series of bits similar to a fixed-sized vector of bools. Implements bitwise operations and lacks iterators. Not a Sequence.

valarray

another C-like array like vector, but is designed for high speed numerics at the expense of some programming ease and general purpose use. It has many features that make it ideally suited for use with vector processors in traditional vector supercomputers and SIMD units in consumer-level scalar processors, and also ease vector mathematics programming even in scalar computers.

Iterators

The STL implements five different types of iterators. These are input iterators (which can only be used to read a sequence of values), output iterators (which can only be used to write a sequence of values), forward iterators (which can be read, written to, and move forward), bidirectional iterators (which are like forward iterators but can also move backwards) and random access iterators (which can move freely any number of steps in one operation).

It is possible to have bidirectional iterators act like random access iterators, as moving forward ten steps could be done by simply moving forward a step at a time a total of ten times. However, having distinct random access iterators offers efficiency advantages. For example, a vector would have a random access iterator, but a list only a bidirectional iterator.

Iterators are the major feature which allow the generality of the STL. For example, an algorithm to reverse a sequence can be implemented using bidirectional iterators, and then the same implementation can be used on lists, vectors and deques. User-created containers only have to provide an iterator which implements one of the 5 standard iterator interfaces, and all the algorithms provided in the STL can be used on the container.

This generality also comes at a price at times. For example, performing a search on an associative container such as a map or set can be much slower using iterators than by calling member functions offered by the container itself. This is because an associative container's methods can take advantage of knowledge of the internal structure, which is opaque to algorithms using iterators.

Algorithms

A large number of algorithms to perform operations such as searching and sorting are provided in the STL, each implemented to require a certain level of iterator (and therefore will work on any container which provides an interface by iterators).

Functors

The STL includes classes that overload the function operator (operator()). Classes that do this are called functors or function objects. They are useful for keeping and retrieving state information in functions passed into other functions. Regular function pointers can also be used as functors.

A particularly common type of functor is the predicate. For example, algorithms like find_if take a unary predicate that operates on the elements of a sequence. Algorithms like sort, partial_sort, nth_element and all sorted containers use a binary predicate which must provide a strict weak ordering, that is, it must behave like a membership test on a transitive, irreflexive and antisymmetric binary relation. If none is supplied, these algorithms and containers use less by default, which in turn calls the less-than-operator <.

Criticisms

Quality of compiler

The Quality of Implementation (QoI) of the C++ compiler has a large impact on usability of STL (and templated code in general):

Error messages involving templates tend to be very long and difficult to decipher. This problem has been considered so severe that a number of tools have been written which simplify and prettyprint STL-related error messages to make them more comprehensible.

Careless use of STL templates can lead to code bloat. This has been countered with special techniques within STL implementation (using void* containers internally) and by improving optimization techniques used by compilers.

Template instantiation tends to increase compilation time and memory usage (even by an order of magnitude). Until the compiler technology improves enough this problem can be only partially eliminated by very careful coding and avoiding certain idioms.

STL design issues

1. Design flaws due to limitations in the C++ language

Initialization of STL containers with constants within the source code is not as easy as data structures inherited from C (addressed in C++0x with initializer lists).

2. Perceived flaws due to the requirement to maximize speed and minimize space usage

STL containers are not intended to be used as base classes (their destructors are deliberately non-virtual); deriving from a container is a common mistake.

3. Other flaws, caused either by trade-offs in design or which have become more visible over time

The concept of iterators as implemented by STL can be difficult to understand at first: for example, if a value pointed to by the iterator is deleted, the iterator itself is then no longer valid. This is a common source of errors. Most implementations of the STL provide a debug mode which is slower but can locate such errors if used. However, at present no better replacement for iterators has been suggested and a similar problem exists in other languages, for example Java.

Certain iteration patterns do not map to the STL iterator model. For example, callback enumeration APIs cannot be made to fit the STL model without the use of coroutines, which are platform-dependent and/or unavailable, and are outside the C++ standard.

Compiler compliance does not guarantee that Allocator objects, used for memory management for containers, will work with state dependent behavior. For example, a portable library can't define an allocator type that will pull memory from different pools using different allocator objects of that type. (Meyers, p. 50)

The set of algorithms is not complete for example, the copy_if algorithm was left out by oversight (Stroustrup, p. 530) (added in C++0x: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2666.pdf).

The interface of some containers (in particular string) is bloated (Sutter and Alexandrescu, p. 79); others are considered insufficient.

Hashing containers were left out of the original standard, but have been added in Technical Report 1, a recent extension to C++.

History

The architecture of STL is largely the creation of one person, Alexander Stepanov. In 1979 he began working out his initial ideas of generic programming and exploring their potential for revolutionizing software development. Although David Musser had developed and advocated some aspects of generic programming already by year 1971, it was limited to a rather specialized area of software development (computer algebra).

Stepanov recognized the full potential for generic programming and persuaded his then-colleagues at General Electric Research and Development (including, primarily, David Musser and Deepak Kapur) that generic programming should be pursued as a comprehensive basis for software development. At the time there was no real support in any programming language for generic programming.

The first major language to provide such support was Ada, with its generic units feature. By 1987 Stepanov and Musser had developed and published an Ada library for list processing that embodied the results of much of their research on generic programming. However, Ada had not achieved much acceptance outside the defense industry and C++ seemed more likely to become widely used and provide good support for generic programming even though the language was relatively immature. Another reason for turning to C++, which Stepanov recognized early on, was the C/C++ model of computation which allows very flexible access to storage via pointers is crucial to achieving generality without losing efficiency.

Much research and experimentation were needed, not just to develop individual components, but to develop an overall architecture for a component library based on generic programming. First at AT&T Bell Laboratories and later at Hewlett-Packard Research Labs, Stepanov experimented with many architectural and algorithm formulations, first in C and later in C++. Musser collaborated in this research and in 1992 Meng Lee joined Stepanov's project at HP and became a major contributor.

This work undoubtedly would have continued for some time being just a research project or at best would have resulted in an HP proprietary library if Andrew Koenig of Bell Labs had not become aware of the work and asked Stepanov to present the main ideas at a November 1993 meeting of the ANSI/ISO committee for C++ standardization. The committee's response was overwhelmingly favorable and led to a request from Koenig for a formal proposal in time for the March 1994 meeting. Despite the tremendous time pressure, Alex and Meng were able to produce a draft proposal that received preliminary approval at that meeting.

The committee had several requests for changes and extensions (some of them major), and a small group of committee members met with Stepanov and Lee to help work out the details. The requirements for the most significant extension (associative containers) had to be shown to be consistent by fully implementing them, a task Stepanov delegated to Musser. It would have been quite easy for the whole enterprise to spin out of control at this point, but again Stepanov and Lee met the challenge and produced a proposal that received final approval at the July 1994 ANSI/ISO committee meeting. (Additional details of this history can be found in Stevens.) Subsequently, the Stepanov and Lee document 17 was incorporated into the ANSI/ISO C++ draft standard (1, parts of clauses 17 through 27). It also influenced other parts of the C++ Standard Library, such as the string facilities, and some of the previously adopted standards in those areas were revised accordingly.

In spite of STL's success with the committee, there remained the question of how STL would make its way into actual availability and use. With the STL requirements part of the publicly available draft standard, compiler vendors and independent software library vendors could of course develop their own implementations and market them as separate products or as selling points for their other wares. One of the first edition's authors, Atul Saini, was among the first to recognize the commercial potential and began exploring it as a line of business for his company, Modena Software Incorporated, even before STL had been fully accepted by the committee.

The prospects for early widespread dissemination of STL were considerably improved with Hewlett-Packard's decision to make its implementation freely available on the Internet in August 1994. This implementation, developed by Stepanov, Lee, and Musser during the standardization process, became the basis of many implementations offered by compiler and library vendors today.

List of STL implementations

libstdc++ from gnu (was part of libg++)

STLPort, based on SGI STL

Rogue Wave standard library (HP, SGI, SunSoft, Siemens-Nixdorf)

Dinkum STL library by P.J. Plauger

Notes

^ Meyers, Scott (2005). Effective C++ Third Edition - 55 Specific Ways to Improve Your Designs. Addison Wesley. ISBN 0-321-33487-6. 

^ Sutter, Herb; Alexandrescu, Andrei (2004). C++ Coding Standards: 101 Rules, Guidelines, and Best Practices. Addison-Wesley. 

See also

List of C++ template libraries

C++0x

Boost C++ Libraries

References

Alexander Stepanov and Meng Lee, The Standard Template Library. HP Laboratories Technical Report 95-11(R.1), November 14, 1995. (Revised version of A. A. Stepanov and M. Lee: The Standard Template Library, Technical Report X3J16/94-0095, WG21/N0482, ISO Programming Language C++ Project, May 1994.)

Alexander Stepanov (2007) (PDF). Notes on Programming. http://www.stepanovpapers.com/notes.pdf.  Stepanov reflects about the design of the STL.

Nicolai M. Josuttis (2000). The C++ Standard Library: A Tutorial and Reference. Addison-Wesley. ISBN 0-201-37926-0. 

Scott Meyers (2001). Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library. Addison-Wesley. ISBN 0-201-74962-9. 

Al Stevens (March 1995). "Al Stevens Interviews Alex Stepanov". Dr. Dobb's Journal. http://www.sgi.com/tech/stl/drdobbs-interview.html. Retrieved 2007-07-18. 

Bjarne Stroustrup (2000). The C++ Programming Language (3rd ed.). Addison-Wesley. ISBN 0-201-70073-5. 

Herb Sutter and Andrei Alexandrescu (2005). C++ Coding Standards. Addison-Wesley. ISBN 0-321-11358-6. 

David Vandevoorde and Nicolai M. Josuttis (2002). C++ Templates: The Complete Guide. Addison-Wesley Professional. ISBN 0-201-73484-2. 

Matthew Wilson (February 2004). "Callback Enumeration APIs & the Input Iterator Concept". Dr. Dobb's Journal. http://www.ddj.com/cpp/184401766. 

Atul Saini and David R. Musser, STL Tutorial and Reference Guide: C+ + Programming with the Standard Template Library. Foreword by Alexander Stepanov; [Copyright Modena Software Inc.] Addison-Wesley ISBN 0-201-63398-1

External links

STL programmer's guide official guide from SGI

STL Reference lists STL containers and their members

C/C++ reference includes a section on the STL

Apache (formerly Rogue Wave) C++ Standard Library Class Reference

Apache (formerly Rogue Wave) C++ Standard Library User Guide

Bjarne Stroustrup on The emergence of the STL (Page 5, Section 3.1)

STLPort, a very popular open-source implementation of the STL

Categories: C++ standard library | Generic programmingHidden categories: Articles needing additional references from September 2007 | All articles needing additional references | Wikipedia articles needing style editing from April 2008 | All articles needing style editing | Articles lacking in-text citations from April 2009 | All articles lacking in-text citations
About the Author

I am a professional writer from China Quality Lighting, which contains a great deal of information about fertilizer fish emulsion , wholesale spray paint, welcome to visit!

How should/could I approach this (beginners) Java/Netbeans issue?

I'm using Netbeans to create a JFrame in Java. I would like to make a dynamic canvas (a canvas that can be edited afterward, by entering form values, etc.) with, let's say, filled rectangles. I created the canvas in the design view, modified a few properties to make it look right, and then tried to draw a shape.

The tutorial I was working from asked to make "public void paint(Graphics g)". When I wrote that, Netbeans made an @override symbol to the left. What I learned is that Netbeans already made this somewhere in a read-only file, and that making it over-writes it.

How do I paint on the canvas if Netbeans already made a function like that?

Can I append to a function if it's already defined?

Or should I try to edit the read-only file? How would I even do that?

Am I missing something here?

This has to do with class inheritance, which is a feature of object-oriented programming -- it doesn't have anything to do with "overwriting" any source files.

The @Override annotation is simply to inform the compiler that you are declaring a member or method that "overrides" an element declared in a superclass.

In this case, your DynamicCanvas class (or whatever it's called) is derived from the Canvas class. Canvas already has a "public void paint(Graphics g)" method, and your method in the derived class has an identical signature (i.e., return value and argument list). So the paint method in your DynamicCanvas class "overrides" the paint method in the parent class.

This means that, when you create an object of type DynamicCanvas, and then call its paint function, the code that executes is the code you wrote in the DynamicCanvas class definition -- not the code included in the "paint" function of the Canvas class.

Placing the @Override annotation before your method declaration is a good idea, because it will force the compiler to check whether or not you are overriding the method properly, and notify you if there are any problems. However, I don't think you're *required* to use the annotation if, for some reason, you really don't want to.

In any case, no source file is being overwritten, so it doesn't matter that they are read-only. You're allowed to create derived classes based on "Canvas" and override its members and methods however you want in your derived class -- that's what object-oriented programming is all about. There is no reason to try to edit the source file.

Java tutorial Paint program (not so basic)