qmap的书写格式linux,QMap Class – Qt 参考中文帮助文档

The QMap class is a value-based template class that provides

a dictionary.

More…

#include

List of all member functions.

Public Members

typedef Keykey_type

typedef Tmapped_type

typedef QPairvalue_type

typedef value_type*pointer

typedef constvalue_type*const_pointer

typedef value_type&reference

typedef constvalue_type&const_reference

typedef size_tsize_type

typedef QMapIteratoriterator

typedef QMapConstIteratorconst_iterator

typedef QPairinsert_pair

QMap ()

QMap ( constQMap&m )

QMap ( conststd::map&m )

~QMap ()

QMap & operator= ( constQMap&m )

QMap & operator= ( conststd::map&m )

iterator begin ()

iterator end ()

const_iterator begin () const

const_iterator end () const

iterator replace ( constKey&k, constT&v )

size_type size () const

bool empty () const

QPair insert ( constvalue_type&x )

void erase ( iteratorit )

void erase ( constkey_type&k )

size_type count ( constkey_type&k ) const

T & operator[] ( constKey&k )

void clear ()

typedef QMapIteratorIterator

typedef QMapConstIteratorConstIterator

typedef TValueType

iterator find ( constKey&k )

const_iterator find ( constKey&k ) const

const T & operator[] ( constKey&k ) const

bool contains ( constKey&k ) const

size_type count () const

QValueList keys () const

QValueList values () const

bool isEmpty () const

iterator insert ( constKey&key, constT&value, booloverwrite = TRUE )

void remove ( iteratorit )

void remove ( constKey&k )

Protected Members

void detach ()

Related Functions

QDataStream & operator>> ( QDataStream&s, QMap&m )

QDataStream & operator<< ( QDataStream&s, constQMap&m )

Detailed Description

The QMap class is a value-based template class that provides

a dictionary.

QMap is a Qt implementation of an STL-like map container. It

can be used in your application if the standard map is not

available. QMap is part of the Qt Template

Library.

QMap defines a template instance to create a

dictionary with keys of type Key and values of type Data. QMap does

not store pointers to the members of the map; instead, it holds a

copy of every member. For that reason, QMap is value-based, whereas

QPtrList and QDict are pointer-based.

QMap contains and manages a collection of objects of type Data with

associated key values of type Key and provides iterators that allow

the contained objects to be addressed. QMap owns the contained

items.

Some classes cannot be used within a QMap. For example everything

derived from QObject and thus all classes that implement widgets.

Only values can be used in a QMap. To qualify as a value, the class

must provide

A copy constructor

An assignment operator

A default constructor, i.e. a constructor that does not take any arguments.

Note that C++ defaults to field-by-field assignment operators and

copy constructors if no explicit version is supplied. In many cases,

this is sufficient.

The class used for the key requires that the operator< is implemented

to define ordering of the keys.

QMap’s function naming is consistent with the other Qt classes

(e.g., count(), isEmpty()). QMap also provides extra functions for

compatibility with STL algorithms, such as size() and empty().

Programmers already familiar with the STL map can use these

functions instead.

Example:

#include

class Employee

{

public:

Employee(): sn(0) {}

Employee( const QString& forename, const QString& surname, int salary )

: fn(forename), sn(surname), sal(salary)

{ }

QString forename() const { return fn; }

QString surname() const { return sn; }

int salary() const { return sal; }

void setSalary( int salary ) { sal = salary; }

private:

QString fn;

QString sn;

int sal;

};

int main(int argc, char **argv)

{

QApplication app( argc, argv );

typedef QMap EmployeeMap;

EmployeeMap map;

map[“JD001”] = Employee(“John”, “Doe”, 50000);

map[“JD002”] = Employee(“Jane”, “Williams”, 80000);

map[“TJ001”] = Employee(“Tom”, “Jones”, 60000);

Employee sasha( “Sasha”, “Hind”, 50000 );

map[“SH001”] = sasha;

sasha.setSalary( 40000 );

EmployeeMap::Iterator it;

for ( it = map.begin(); it != map.end(); ++it ) {

printf( “%s: %s, %s earns %d\n”,

it.key().latin1(),

it.data().surname().latin1(),

it.data().forename().latin1(),

it.data().salary() );

}

return 0;

}

Program output:

JD001: Doe, John earns 50000

JW002: Williams, Jane earns 80000

SH001: Hind, Sasha earns 50000

TJ001: Jones, Tom earns 60000

The latest changes to Sasha’s salary did not affect the value in

the list because the map created a copy of Sasha’s entry. In

addition, notice that the items are sorted alphabetically (by key)

when iterating over the map.

There are several ways to find items in a map. The begin() and

end() functions return iterators to the beginning and end of the

map. The advantage of using an iterator is that you can move

forward or backward by incrementing/decrementing the iterator. The

iterator returned by end() points to the element which is one past

the last element in the container. The past-the-end iterator is

still associated with the map it belongs to, however it is not

dereferenceable; operator*() will not return a well-defined value.

If the map is empty, the iterator returned by begin() will equal

the iterator returned by end().

Another way to find an element in the map is by using the find()

function. This returns an iterator pointing to the desired

item or to the end() iterator if no such element exists.

Another approach uses the operator[]. But be warned: if the map does

not contain an entry for the element you are looking for, operator[]

inserts a default value. If you do not know that the element you

are searching for is really in the list, you should not use

operator[]. The following example illustrates this:

QMap map;

map[“Clinton”] = “Bill”;

str << map[“Clinton”] << map[“Bush”] << endl;

The code fragment will print out “Clinton”, “”. Since the value

associated with the “Bush” key did not exist, the map inserted a

default value (in this case, an empty string). If you are not

sure whether a certain element is in the map, you should use find()

and iterators instead.

If you just want to know whether a certain key is contained in the

map, use the contains() function. In addition, count() tells you how

many keys there are currently in the map.

It is safe to have multiple iterators at the same time. If some

member of the map is removed, only iterators pointing to the removed

member become invalid; inserting in the map does not invalidate any

iterators.

Since QMap is value-based, there is no need to be concerned about deleting

items in the map. The map holds its own copies and will free

them if the corresponding member or the map itself is deleted.

QMap is implicitly shared. This means you can just make copies of

the map in time O(1). If multiple QMap instances share the same data

and one is modifying the map’s data, this modifying instance

makes a copy and modifies its private copy; it thus does not affect

other instances. From a developer’s point of view you can think

that a QMap and a copy of this map have nothing to do with each

other. If a QMap is being used in a multi-threaded program, you must

protect all access to the map. See QMutex.

There are several ways of inserting new items into the map. One

uses the insert() method; the other one uses operator[] like this:

QMap map;

map[“Clinton”] = “Bill”;

map.insert( qMakePair(“Bush”, “George”) );

Items can also be removed from the map in several ways. The first is

to pass an iterator to remove(). The other is to pass a key

value to remove(), which will delete the entry with the requested

key. In addition you can clear the entire map using the clear()

method.

See also QMapIterator, Qt Template Library Classes, Implicitly and Explicitly Shared Classes and Non-GUI Classes.

Member Type Documentation

QMap::ConstIterator

The map’s const iterator type, Qt style.

QMap::Iterator

The map’s iterator type, Qt style.

QMap::ValueType

Corresponds to QPair, Qt style.

QMap::const_iterator

The map’s const iterator type.

QMap::const_pointer

Const pointer to value_type.

QMap::const_reference

Const reference to value_type.

QMap::iterator

The map’s iterator type.

QMap::key_type

The map’s key type.

QMap::mapped_type

The map’s data type.

QMap::pointer

Pointer to value_type.

QMap::reference

Reference to value_type.

QMap::size_type

An unsigned integral type, used to represent various sizes.

QMap::value_type

Corresponds to QPair.

Member Function Documentation

QMap::QMap ()

Constructs an empty map.

QMap::QMap ( constQMap&m )

Constructs a copy of m.

This operation costs O(1) time because QMap is implicitly shared. The

first instance of applying modifications to a shared map will create a

copy that takes in turn O(n) time. However, returning a QMap from a

function is very fast.

QMap::QMap ( conststd::map&m )

Constructs a copy of m.

QMap::~QMap ()

Destroys the map. References to the values in the map and all

iterators of this map become invalidated. Since QMap is highly tuned

for performance you won’t see warnings if you use invalid iterators,

because it is not possible for an iterator to check whether it is

valid or not.

iterator QMap::begin ()

Returns an iterator pointing to the first element in the map. This

iterator equals end() if the map is empty.

The items in the map are traversed in the order defined by

operator

你可能也喜欢