Qt中的QMap介绍与使用，在坛子里逛了一圈，发现在使用QMap中，出现过很多的问题，Map是一个很有用的数据结构。它以“键-值”的形式保存数据。在使用的时候，通过提供字符标示(键)即可得到想要的数据。这个“数据”即可以是一个字符串，也可以是任意对象，当然也包括自己定义的类对象。说明：map是以值传递的形式保存数据的。

1. 基本应用

下面以“键-值”都是QString的例子说明QMap的基本使用方法。更详细的说明，请查看《Qt帮助手册》或其他资源。

#include

#include

usingnamespacestd;

classMapTest

{

public:

voidshowMap()

{

if(!m_map.isEmpty())return;//判断map是否为空

m_map.insert("111","aaa");//向map里添加一对“键-值”

if(!m_map.contains("222"))//判断map里是否已经包含某“键-值”

m_map.insert("222","bbb");

m_map["333"] ="ccc";//另一种添加的方式

qDebug("map[333] , value is : "+ m_map["333"]);//这种方式既可以用于添加，也可以用于获取，但是你必须知道它确实存在

if(m_map.contains("111")){

QMap::iterator it = m_map.find("111");//找到特定的“键-值”对

qDebug("find 111 , value is : "+ it.data());//获取map里对应的值

}

cout<

qDebug("size of this map is : %d", m_map.count());//获取map包含的总数

cout<

QMap::iterator it; //遍历map

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

qDebug( "%s: %s", it.key().ascii(), it.data().ascii());//用key()和data()分别获取“键”和“值”

}

m_map.clear(); //清空map

}

private:

QMap m_map; //定义一个QMap对象

};

#include

#include

using namespace std;

class MapTest

{

public:

void showMap()

{

if(!m_map.isEmpty()) return; //判断map是否为空

m_map.insert("111", "aaa"); //向map里添加一对“键-值”

if(!m_map.contains("222")) //判断map里是否已经包含某“键-值”

m_map.insert("222", "bbb");

m_map["333"] = "ccc"; //另一种添加的方式

qDebug("map[333] , value is : " + m_map["333"]); //这种方式既可以用于添加，也可以用于获取，但是你必须知道它确实存在

if(m_map.contains("111")){

QMap::iterator it = m_map.find("111"); //找到特定的“键-值”对

qDebug("find 111 , value is : " + it.data()); //获取map里对应的值

}

cout<< endl;

qDebug("size of this map is : %d", m_map.count()); //获取map包含的总数

cout<< endl;

QMap::iterator it; //遍历map

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

qDebug( "%s: %s", it.key().ascii(), it.data().ascii()); //用key()和data()分别获取“键”和“值”

}

m_map.clear(); //清空map

}

private:

QMap m_map; //定义一个QMap对象

};

调用类函数showMap(),显示结果：

map[333] , value is : ccc

find 111 , value is : aaa

size of thismap is : 3

111: aaa

222: bbb

333: ccc

map[333] , value is : ccc

find 111 , value is : aaa

size of this map is : 3

111: aaa

222: bbb

333: ccc

2. 对象的使用

map当中还可以保存类对象、自己定义类对象，例子如下(摘自QT帮助文档《Qt Assistant》，更详细的说明参考之)：

以注释形式说明

#include

#include

#include

//自定义一个Employee类，包含fn、sn、sal属性

classEmployee

{

public:

Employee(): sn(0) {}

Employee( constQString& forename,constQString& surname,intsalary )

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

{ }

QString forename() const{returnfn; }

QString surname() const{returnsn; }

intsalary()const{returnsal; }

voidsetSalary(intsalary ) { sal = salary; }

private:

QString fn;

QString sn;

intsal;

};

intmain(intargc,char**argv)

{

QApplication app( argc, argv );

typedefQMap EmployeeMap;//自定义一个map类型，值为EmployeeMap对象

EmployeeMap map;

map["JD001"] = Employee("John","Doe", 50000);//向map里插入键-值

map["JW002"] = Employee("Jane","Williams", 80000);

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

Employee sasha( "Sasha","Hind", 50000 );

map["SH001"] = sasha;

sasha.setSalary( 40000 ); //修改map值的内容，因为map采用值传递，所以无效

//批量打印

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() );

}

return0;

}

#include

#include

#include

//自定义一个Employee类，包含fn、sn、sal属性

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; //自定义一个map类型，值为EmployeeMap对象

EmployeeMap map;

map["JD001"] = Employee("John", "Doe", 50000); //向map里插入键-值

map["JW002"] = Employee("Jane", "Williams", 80000);

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

Employee sasha( "Sasha", "Hind", 50000 );

map["SH001"] = sasha;

sasha.setSalary( 40000 ); //修改map值的内容，因为map采用值传递，所以无效

//批量打印

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 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

#include

#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

See also end() and QMapIterator.

const_iterator QMap::begin () const

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

See also end() and QMapConstIterator.

void QMap::clear ()

Removes all items from the map.

See also remove().

bool QMap::contains ( constKey&k ) const

Returns TRUE if the map contains an item with key k; otherwise

returns FALSE.

size_type QMap::count ( constkey_type&k ) const

Returns the number of items whose key is k. Since QMap does

not allow duplicate keys, the return value is always 0 or 1.

This function is provided for STL compatibility.

size_type QMap::count () const

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Returns the number of items in the map.

See also isEmpty().

void QMap::detach () [protected]

If the map does not share its data with another QMap instance,

nothing happens; otherwise the function creates a new copy of this

map and detaches from the shared one. This function is called

whenever the map is modified. The implicit sharing mechanism is

implemented this way.

bool QMap::empty () const

Returns TRUE if the map contains zero items; otherwise returns FALSE.

This function is provided for STL compatibility. It is equivalent

to isEmpty().

See also size().

iterator QMap::end ()

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.

This iterator equals begin() if the map is empty.

See also begin() and QMapIterator.

const_iterator QMap::end () const

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

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.

This iterator equals begin() if the map is empty.

See also begin() and QMapConstIterator.

void QMap::erase ( iteratorit )

Removes the item associated with the iterator it from the map.

This function is provided for STL compatibility. It is equivalent

to remove().

See also clear().

void QMap::erase ( constkey_type&k )

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Removes the item with the key k from the map.

iterator QMap::find ( constKey&k )

Returns an iterator pointing to the element with key k in the map.

Returns end() if no key matched.

See also QMapIterator.

const_iterator QMap::find ( constKey&k ) const

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Returns an iterator pointing to the element with key k in the map.

Returns end() if no key matched.

See also QMapConstIterator.

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

Inserts the value with key. If there is already a value

associated with key, it is replaced, unless overwrite is

FALSE (it is TRUE by default).

QPair QMap::insert ( constvalue_type&x )

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Inserts the (key, value) pair x into the map. x is a QPair

whose first element is a key to be inserted and whose second

element is the associated value to be inserted. Returns a pair

whose first element is an iterator pointing to the inserted item

and whose second element is a bool indicating TRUE if x was

inserted and FALSE if it was not inserted because it was already

present.

bool QMap::isEmpty () const

Returns TRUE if the map contains zero items; otherwise returns FALSE.

See also count().

QValueList QMap::keys () const

Returns a list of all the keys in the map.

QMap& QMap::operator= ( constQMap&m )

Assigns m to this map and returns a reference to this map.

All iterators of the current map become invalidated by this

operation. The cost of such an assignment is O(1), because QMap is

implicitly shared.

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

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Assigns m to this map and returns a reference to this map.

All iterators of the current map become invalidated by this

operation.

T & QMap::operator[] ( constKey&k )

Returns the value associated with the key k. If no such

key is present, an empty item is inserted with this key

and a reference to the item is returned.

You can use this operator both for reading and writing:

QMap map;

map["Clinton"] = "Bill";

stream << map["Clinton"];

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

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Warning: This function differs from the non-const version of the

same function. It will not insert an empty value if the key k

does not exist. This may lead to logic errors in your program. You

should check if the element exists before calling this function.

Returns the value associated with the key k. If no such

key is present, a reference to an empty item is returned.

void QMap::remove ( iteratorit )

Removes the item associated with the iterator it from the map.

See also clear().

void QMap::remove ( constKey&k )

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Removes the item with the key k from the map.

iterator QMap::replace ( constKey&k, constT&v )

Replaces the value with key k from the map if possible, and

inserts the new value v with key k in the map.

See also insert() and remove().

size_type QMap::size () const

Returns the number of items in the map.

This function is provided for STL compatibility. It is equivalent

to count().

See also empty().

QValueList QMap::values () const

Returns a list of all the values in the map.

Related Functions

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

Writes the map m to the stream s. The types Key and T

must implement the streaming operator as well.

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

Reads the map m from the stream s. The types Key and T

must implement the streaming operator as well.