[QT Programming Series-22]: Basic Framework - QT Common Data Structures: QString, QList, QVector, QMap, QHash, QSet, QPair Quick View

Table of contents

1. Overview of QT common data structures

2. Comparison between QList and QVector

3. Comparison between QPair and QMap

4. Comparison of QT data structure and STL library data structure

5. Performance comparison between QT data structure and STL library data structure

---

1. Overview of QT common data structures 

In Qt, there are several main data structures commonly used to process and organize data, including:

1. QString: A class for storing and manipulating strings. QString is a commonly used string type in Qt, which provides rich string manipulation methods and fast string processing capabilities.

2. QList: A dynamic array that can be used to store multiple elements of the same data type . It can easily perform insertion, deletion and access operations, and provides a series of member functions and iterators to manipulate elements.

3. QVector: Similar to QList, it is also a dynamic array, but it is usually more suitable for fast access and traversal of elements than QList.

4. QMap: A container of key-value pairs, used to store and find mapping relationships. Provides fast key-value access and search capabilities, as well as operations such as sorting and iterating on maps.

5. QHash: Similar to QMap, it is a container that stores key-value pairs , but does not guarantee the order of elements. It is faster and more efficient than QMap in search and insertion operations, and is suitable for fast search of large amounts of data .

6. QSet: An unordered collection , used to store unique elements. Provides efficient insert, find, and delete operations, suitable for handling collection problems.

7. QPair: A container that stores a pair of values ​​(not key-value pairs) , which can be used to combine multiple values.

These data structures are commonly used in Qt, and they have different advantages and applicability in different scenarios.

You can choose the appropriate data structure to process and organize data according to your specific needs.

Please consult the Qt documentation for more detailed information and usage examples.

2. Comparison between QList and QVector

QList and QVector are two commonly used container classes in Qt for storing multiple elements of the same data type.

They differ in use and performance , and you can choose a suitable container according to your specific needs.

Here are some comparisons of QList and QVector:

1. Memory allocation method: this is the most fundamental difference between them

   • QList: Implemented using a doubly linked list , elements are not stored contiguously in memory , suitable for frequent insertion and deletion operations. But accessing elements is slower due to the structure of the linked list.
   • QVector: Use continuous memory blocks to store elements , and can quickly access elements at any index, suitable for frequent random access operations .

2. Insertion and deletion operations:

   • QList: Due to the use of linked list implementation, the insertion and deletion of elements is faster, and no other elements need to be moved.
   • QVector: Inserting and deleting elements at the end (or pre-allocated space) is fast, but inserting and deleting elements in the middle requires moving the elements behind, and the performance is poor.

3. Random access operation:

   • QList: To access elements, you need to traverse from the head or tail of the linked list. For large data sets, the access speed is slow.
   • QVector: Due to the continuous memory block storage, elements can be quickly accessed directly according to the index, which is suitable for frequent random access operations.

4. Memory usage:

   • QList: Additional linked list nodes introduce a certain amount of memory overhead, which may take up more memory for containers with a large number of small elements.
   • QVector: As a continuous memory block to store elements, there is no additional linked list node overhead and less memory usage.

According to the above characteristics, QList is suitable for dealing with situations that require frequent insertion and deletion of elements, while QVector is suitable for situations that require frequent random access to elements. If for a specific use case, you need both fast insertion and deletion and fast random access, you can make a choice according to the actual situation or consider using other more suitable container classes.

It should be noted that for the general case, the performance difference between the two usually does not have a significant impact on the overall performance of the program. Therefore, it is more important to correctly choose the container class that suits your needs.

3. Comparison between QPair and QMap

QPair and QMap are two different container classes in Qt, used for different purposes.

QPair is a generic container class for storing two values. It is suitable for situations where two values ​​of different types need to be combined, but does not provide functions such as lookup and sorting of key-value pairs. With QPair, you can easily access and manipulate these two values, but you cannot search or sort by key.

In contrast, QMap is an associative container class for storing key-value pairs. It provides key-based lookup and insertion operations, and can sort by key. QMap can quickly retrieve the corresponding value according to the key, and provides the function of sorting by key, so QMap is more suitable for use when searching and sorting according to the key is required.

If you need to store key-value pairs and want to be able to search and sort according to the key, you should choose to use QMap. If you simply need to combine two values ​​of different types without searching and sorting, then QPair is enough.

It is necessary to choose whether to use QPair or QMap according to specific needs, and each of them has different advantages and uses in different scenarios.

4. Comparison of QT data structure and STL library data structure

There are some differences and comparisons between Qt data structures and STL (Standard Template Library) library data structures, here are some main points of comparison:

1. Type naming and namespaces:

   • Qt data structure: Qt data structure starts with "Q", such as QString, QList, QVector, etc., and is located in the Qt namespace.
   • STL data structure: STL data structures are named after common naming methods, such as string, vector, list, etc., and are located in the std namespace.

2. Frameworks and dependencies:

   • Qt data structure: Qt data structure is part of the Qt framework and is mainly used for the development of Qt applications. They are tightly integrated with other modules and functions of Qt and depend on the Qt framework .
   • STL data structure: The STL data structure is part of the C++ standard library and can be used in any C++ environment that supports the C++ standard library and does not depend on a specific framework.

3. Additional features and extensions:

   • Qt data structures: Qt data structures generally provide specific functionality that is tightly integrated with other parts of the Qt framework, such as the signals and slots mechanism, the Qt meta-object system, etc.
   • STL data structures: STL data structures provide a common set of containers, algorithms, and iterators , without specific functionality for integration with specific frameworks or libraries.

4. The Qt meta-object system supports:

   • Qt data structure: Qt data structure can connect signals and slots through Qt's meta-object system to realize dynamic event processing.
   • STL data structure: The STL data structure does not have direct meta-object system support and cannot be connected with the signal and slot mechanism. They are mainly used for data storage and processing.

5. API and usage:

   • Qt data structure: Qt data structure provides an API consistent with Qt style, has its own specific member functions and usage, and is tightly integrated with other Qt components.
   • STL data structure: The STL data structure follows the design principles of the C++ standard library and provides a consistent and general API, similar to other C++ standard library containers and algorithms.

It is necessary to choose to use Qt or STL data structure according to specific needs and scenarios. If you are developing an application using the Qt framework and need tight integration with other Qt modules, then Qt data structures may be a better fit. If you're writing code in pure C++ and only need common containers and algorithms, then STL data structures might be a more appropriate choice.

5. Performance comparison between QT data structure and STL library data structure

In terms of performance, there are some differences and comparisons between Qt data structures and STL library data structures.

Here are some common performance comparison points:

1. Memory management and storage layout:

   • Qt data structures: Qt data structures often require additional internal pointers and metadata to support Qt-specific features such as dynamic features and the signal-slot mechanism. This may cause some additional memory overhead.
   • STL library data structures: STL library data structures typically use a compact memory layout , storing only the elements themselves, without additional internal pointers and metadata. This reduces memory overhead.

2. Insertion and deletion operations:

   • Qt data structure: Since some of Qt's data structures (such as QList and QVector) use pointers to traverse internal data structures based on linked lists or arrays, the performance when inserting and deleting elements may be better.
   • STL library data structures: Some data structures of the STL library (such as std::list and std::vector) may need to move or reallocate memory when inserting and deleting elements , so performance may be poor in the case of a large number of insertion and deletion operations.

3. Random access operation:

   • Qt data structure: Some data structures of Qt (such as QVector and QByteArray) use array-based internal storage, which can quickly and randomly access elements with better performance.
   • STL library data structure: Some data structures of the STL library (such as std::vector) also use array-based internal storage, and can also access elements quickly and randomly, with better performance.

It should be noted that for general use cases, the performance difference between Qt data structures and STL library data structures will usually not have a significant impact on the overall performance of the program . Therefore, when choosing a data structure, the main consideration should be functional requirements and code cleanliness, not just performance factors.

When encountering performance-sensitive situations, it is recommended to conduct specific performance tests and analysis, and select a more appropriate data structure according to the actual situation. In addition, for specific performance optimization needs, other more advanced data structures or custom optimization schemes can also be considered.