Qt常用数据类型(2)

6. 日期和时间

6.1. QDate

// 构造函数
QDate::QDate();
QDate::QDate(int y, int m, int d);

// 公共成员函数
// 重新设置日期对象中的日期
bool QDate::setDate(int year, int month, int day);
// 给日期对象添加 ndays 天
QDate QDate::addDays(qint64 ndays) const;
// 给日期对象添加 nmonths 月
QDate QDate::addMonths(int nmonths) const;
// 给日期对象添加 nyears 月
QDate QDate::addYears(int nyears) const;

// 得到日期对象中的年/月/日
int QDate::year() const;
int QDate::month() const;
int QDate::day() const;
void QDate::getDate(int *year, int *month, int *day) const;
 
/*日期对象格式化
    d       -   没有前导零的日子 (1 to 31)  
    dd      -   前导为0的日子   (01 to 31)  
    ddd     -   显示(缩写) 周一、周二、周三、周四、周五、周六、周日     
    dddd    -   显示(完整) 星期一、星期二、星期三、星期四、星期五、星期六、星期日
    
    M       -   没有前导零的月份(1到12)  
    MM      -   前导零的月份(01到12)  
    MMM     -   缩写 1月、2月、3月...         
    MMMM    -   完整 一月、二月、三月...
    
    yy      -   两个数字的年 (00 to 99)
    yyyy    -   以四位数表示的年份
*/
QString QDate::toString(const QString &format) const;

// 操作符重载 ==> 日期比较
bool QDate::operator!=(const QDate &d) const;
bool QDate::operator<(const QDate &d) const;
bool QDate::operator<=(const QDate &d) const;
bool QDate::operator==(const QDate &d) const;
bool QDate::operator>(const QDate &d) const;
bool QDate::operator>=(const QDate &d) const;

// 静态函数 -> 得到本地的当前日期
[static] QDate QDate::currentDate();

6.2. QTime

// 构造函数
QTime::QTime();
/*
    h       ==> must be in the range 0 to 23
    m and s   ==> must be in the range 0 to 59
    ms      ==> must be in the range 0 to 999
*/ 
QTime::QTime(int h, int m, int s = 0, int ms = 0);

// 公共成员函数
// Returns true if the set time is valid; otherwise returns false.
bool QTime::setHMS(int h, int m, int s, int ms = 0);
QTime QTime::addSecs(int s) const;
QTime QTime::addMSecs(int ms) const;

// 示例代码
  QTime n(14, 0, 0);                // n == 14:00:00
  QTime t;
  t = n.addSecs(70);                // t == 14:01:10
  t = n.addSecs(-70);               // t == 13:58:50
  t = n.addSecs(10 * 60 * 60 + 5);  // t == 00:00:05
  t = n.addSecs(-15 * 60 * 60);     // t == 23:00:00

// 从时间对象中取出 时/分/秒/毫秒
// Returns the hour part (0 to 23) of the time. Returns -1 if the time is invalid.
int QTime::hour() const;
// Returns the minute part (0 to 59) of the time. Returns -1 if the time is invalid.
int QTime::minute() const;
// Returns the second part (0 to 59) of the time. Returns -1 if the time is invalid.
int QTime::second() const;
// Returns the millisecond part (0 to 999) of the time. Returns -1 if the time is invalid.
int QTime::msec() const;


// 时间格式化
/*
  -- 时
    h ==>  The hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display)
    hh  ==>  The hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display)
    H ==>  The hour without a leading zero (0 to 23, even with AM/PM display)
    HH  ==>  The hour with a leading zero (00 to 23, even with AM/PM display)
    -- 分
    m ==>  The minute without a leading zero (0 to 59)
    mm  ==>  The minute with a leading zero (00 to 59)
    -- 秒
    s ==>  The whole second, without any leading zero (0 to 59)
    ss  ==>  The whole second, with a leading zero where applicable (00 to 59)
    -- 毫秒
  zzz ==>  The fractional part of the second, to millisecond precision, 
      including trailing zeroes where applicable (000 to 999).
  -- 上午或者下午
    AP or A   ==>    使用AM/PM(大写) 描述上下午, 中文系统显示汉字
    ap or a   ==>    使用am/pm(小写) 描述上下午, 中文系统显示汉字
*/
QString QTime::toString(const QString &format) const;


// 操作符重载 ==> 时间比较
bool QTime::operator!=(const QTime &t) const;
bool QTime::operator<(const QTime &t) const;
bool QTime::operator<=(const QTime &t) const;
bool QTime::operator==(const QTime &t) const;
bool QTime::operator>(const QTime &t) const;
bool QTime::operator>=(const QTime &t) const;

// 静态函数 -> 得到当前时间
[static] QTime QTime::currentTime();

经时计时器

QTime的经时计时器已经过时了，推荐使用QElapsedTimer。

//QTime已废弃的函数
// 开始计时
void QTime::start();
// 计时结束
int QTime::elapsed() const;
// 重新计时
int QTime::restart();

// 推荐使用的API函数
// QElapsedTimer 类
void QElapsedTimer::start();
qint64 QElapsedTimer::restart();
qint64 QElapsedTimer::elapsed() const;

• 主要的使用方法就是测量一个操作耗时多久，例子如下：

QElapsedTimer elapse;
elapse.start();

for(int i = 0;i<10000000;i++);

qDebug()<<elapse.elapsed()<<endl;

6.3. QDateTime

// 构造函数
QDateTime::QDateTime();
QDateTime::QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec = Qt::LocalTime);

// 公共成员函数
// 设置日期
void QDateTime::setDate(const QDate &date);
// 设置时间
void QDateTime::setTime(const QTime &time);
// 给当前日期对象追加 年/月/日/秒/毫秒, 参数可以是负数
QDateTime QDateTime::addYears(int nyears) const;
QDateTime QDateTime::addMonths(int nmonths) const;
QDateTime QDateTime::addDays(qint64 ndays) const;
QDateTime QDateTime::addSecs(qint64 s) const;
QDateTime QDateTime::addMSecs(qint64 msecs) const;

// 得到对象中的日期
QDate QDateTime::date() const;
// 得到对象中的时间
QTime QDateTime::time() const;

// 日期和时间格式, 格式字符参考QDate 和 QTime 类的 toString() 函数
QString QDateTime::toString(const QString &format) const;


// 操作符重载 ==> 日期时间对象的比较
bool QDateTime::operator!=(const QDateTime &other) const;
bool QDateTime::operator<(const QDateTime &other) const;
bool QDateTime::operator<=(const QDateTime &other) const;
bool QDateTime::operator==(const QDateTime &other) const;
bool QDateTime::operator>(const QDateTime &other) const;
bool QDateTime::operator>=(const QDateTime &other) const;

// 静态函数
// 得到当前时区的日期和时间(本地设置的时区对应的日期和时间)
[static] QDateTime QDateTime::currentDateTime();

7，Container

介绍

Qt库提供了一组通用的基于模板的容器类。这些类可用于存储指定类型的项。例如，如果您需要一个可调整大小的QString数组，请使用QList<QString>。

这些容器类被设计成比STL容器更轻、更安全、更容易使用。如果您不熟悉STL，或者更喜欢使用“Qt方式”，您可以使用这些类而不是STL类。

容器类是隐式共享的，它们是可重入的，并且它们被优化为速度、低内存消耗和最小的内联代码扩展，从而导致更小的可执行文件。此外，在所有用于访问它们的线程将它们用作只读容器的情况下，它们是线程安全的。

容器提供了遍历的迭代器。STL风格的迭代器是最有效的迭代器，可以与Qt和STL的泛型算法一起使用。提供java风格的迭代器是为了向后兼容。

容器类

Qt提供了以下顺序容器:QList、QStack和QQueue。 对于大多数应用程序，QList是最好的类型。 它提供了非常快的追加。 如果您确实需要一个链表，请使用std::list。 QStack和QQueue是提供LIFO和FIFO语义的方便类。

Qt还提供了这些关联容器:QMap、QMultiMap、QHash、QMultiHash和QSet。 “Multi”容器方便地支持与单个键关联的多个值。 “哈希”容器通过使用哈希函数而不是对排序集进行二进制搜索来提供更快的查找。

作为特殊情况，QCache和QContiguousCache类在有限的缓存存储中提供对象的高效哈希查找。

容器可以嵌套。例如，完全可以使用 QMap<QString, QList<int>>，其中键类型为 QString，值类型为 QList<int>。

存储在各种容器中的值可以是任何可分配的数据类型。要符合条件，类型必须提供一个复制构造函数和一个赋值运算符。对于某些操作，还需要默认构造函数。这涵盖了您可能希望存储在容器中的大多数数据类型，包括 int 和 double 等基本类型、指针类型以及 QString、QDate 和 QTime 等 Qt 数据类型，但不包括 QObject 或任何QObject 子类（QWidget、QDialog、QTimer 等）。如果您尝试实例化 QList<QWidget>，编译器将抱怨 QWidget 的复制构造函数和赋值运算符被禁用。如果要将这些类型的对象存储在容器中，请将它们存储为指针，例如 QList<QWidget *>。

遍历容器

Qt提供了两种遍历容器的风格：

java风格的迭代器和stl风格的迭代器。java风格的迭代器更容易使用并提供高级功能，而STL风格的迭代器稍微更高效，可以与Qt和STL的通用算法一起使用。

• java风格

范例：

QList<int> list;
list<<1<<2<<3<<4<<5;

QListIterator<int> it(list);
while (it.hasNext())
{
    qInfo()<<it.next();
}

• STL风格

范例：

QList<int> list;
list<<1<<2<<3<<4<<5;
for(QList<int>::Iterator it = list.begin();it!=list.end();it++)
{
    qInfo()<<*it;
}

序列式容器

QList/QVector

QList<T>是Qt的通用容器类之一。 它将item存储在相邻的内存位置，并提供快速的基于索引的访问。 QVector<T>曾经是Qt 5中的一个不同的类，但现在是QList的一个简单别名。

QList<T>和QVarLengthArray<T>提供类似的api和功能。 它们通常是可互换的，但会对性能产生影响。 以下是用例概述:

• QList应该是您的默认首选。
• QVarLengthArray提供了一个在堆栈上保留空间的数组，但如果需要，可以动态增长到堆上。 它适用于短寿命的小容器。
• 如果您需要一个真正的链表，它保证在链表中间插入的时间是常数，并且对项使用迭代器而不是索引，那么可以使用std::list。

公有函数

• 添加数据

//支持流插入
QList<int>()<<1<<2<<3<<4<<5;
//尾部添加
void append(const T &value)
void append(const QList<T> &value)
void push_back(const T &value)
//头部添加
void prepend(const T &value)
void push_front(const T &value)
//指定位置添加    
QList::iterator insert(qsizetype i, QList::parameter_type value)
QList::iterator insert(qsizetype i, qsizetype count, QList::parameter_type value)
QList::iterator insert(QList::iterator before, const T &value)

• 获取数据

T &back()
T &last()

T &first()
T &front()

const T &constFirst() const
const T &constLast() const

//返回下标为i的元素，如果下标i不合法，则返回defaultValue
T value(int i) const
T value(int i, const T &defaultValue) const  
    
const T &at(int i) const
    
T &operator[](int i)
    
//返回从位置pos开始的子列表。如果length为-1(默认)，则包含pos中的所有元素; 
QList<T> mid(int pos, int length = -1) const

• 删除数据

//清空list
void clear()

//删除元素   
int removeAll(const T &value)
bool removeOne(const T &value)
void removeAt(int i)
    
void removeFirst()
void pop_front()
    
void removeLast()
void pop_back()
    
//删除索引位置为i的元素并返回它。    
T takeAt(qsizetype i)
QList::value_type takeFirst()
QList::value_type takeLast()

• 查找/替换

//返回value在列表中第一次出现的索引位置，从索引位置from向前搜索。 如果没有匹配的项，则返回-1。  
qsizetype indexOf(const AT &value, qsizetype from = 0) const
//返回value在列表中最后一次出现的索引位置，从索引位置from反向搜索。如果from是-1(默认值)，则搜索从最后一项开始。如果没有匹配的项，则返回-1。     
qsizetype lastIndexOf(const AT &value, qsizetype from = -1) const
//将索引位置为i的项替换为value
void replace(qsizetype i, QList::parameter_type value)
//如果列表中包含值的出现，则返回true; 否则返回false。 该函数要求值类型具有operator==()的实现。     
bool contains(const AT &value) const

• 交换/移动

//将索引位置from到索引位置to  
//["A", "B", "C", "D", "E", "F"] move(1,4)-> ["A", "C", "D", "E", "B", "F"]
void move(qsizetype from, qsizetype to)

void swap(QList<T> &other)
//交换下标i j的元素    
void swapItemsAt(int i, int j)

• 判断函数

int count(const T &value) const
int count() const
int size() const
int length() const

bool empty() const
bool isEmpty() const
//如果列表第一项/后一项等于value,则返回true; 否则返回false。  
bool startsWith(const T &value) const    
bool endsWith(const T &value) const
//预分配空间大小    
void reserve(int alloc)

QStack

QStack<T>是Qt的通用容器类之一。 它为相同类型的项实现堆栈数据结构。

堆栈是后进先出(LIFO)结构。 使用push()将项目添加到堆栈的顶部，并使用pop()从顶部检索项目。 top()函数提供对最上面的项的访问，而不需要删除它。

QStack继承自QList。 QList的所有功能也适用于QStack。 例如，您可以使用isEmpty()来测试堆栈是否为空，并且您可以使用QList的迭代器类(例如，qlisttiterator)遍历QStack。 但除此之外，QStack还提供了三个方便的函数，方便地实现后进先出语义:push()、pop()和top()。

T pop()
void push(const T &t)
void swap(QStack<T> &other)
T &top()
const T &top() const

QQueue

QQueue<T>是Qt的泛型容器类之一。 它为相同类型的项实现队列数据结构。

队列是先进先出(FIFO)结构。 使用enqueue()将条目添加到队列尾部，并使用dequeue()从头部检索条目。 head()函数提供了对头项的访问，而不删除它。

QQueue继承自QList。 QList的所有功能也适用于QQueue。 例如，您可以使用isEmpty()来测试队列是否为空，并且您可以使用QList的迭代器类(例如，qlisttiterator)遍历QQueue。 但除此之外，QQueue还提供了三个方便的函数，使FIFO语义的实现变得很容易:enqueue()、dequeue()和head()。

//删除队头并返回它  
T dequeue()
//将值t加到队尾    
void enqueue(const T &t)
//返回队头的引用
T &head()
const T &head() const
    
void swap(QQueue<T> &other)

QStringList

QStringList继承自QList<QString>。 它提供基于索引的快速访问以及快速插入和删除。 将字符串列表作为值参数传递既快速又安全。
QList的所有功能也适用于QStringList。 例如，可以使用isEmpty()来测试列表是否为空，还可以调用append()、prepend()、insert()、replace()、removeAll()、removeAt()、removeFirst()、removeLast()和removeOne()等函数来修改QStringList。 此外，QStringList提供了一些方便的函数，使处理字符串列表更容易:

• 判断是否包含某个字符串

bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

• 过滤：返回包含子字符串str的所有字符串的列表

QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
QStringList filter(const QRegularExpression &re) const

• 查找

//从左往右查找
qsizetype indexOf(const AT &value, qsizetype from = 0) const
qsizetype indexOf(const QRegularExpression &re, qsizetype from = 0) const
    
//从右往左查找
qsizetype lastIndexOf(const AT &value, qsizetype from = -1) const
qsizetype lastIndexOf(const QRegularExpression &re, qsizetype from = -1) const

• 连接：将QStringList中的所有字符串连接为一个字符串，每个元素由给定的分隔符(可以是空串)分隔。

QString join(const QString &separator) const
QString join(QChar separator) const

• 删除：从QStringList中删除重复的元素。 返回已删除元素的数量。

qsizetype removeDuplicates()

• 替换：返回一个字符串列表，其中每个字符串在找到before文本时都将before文本替换为after文本

QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QStringList &replaceInStrings(const QRegularExpression &re, const QString &after)

• 排序：升序

void sort(Qt::CaseSensitivity cs = Qt::CaseSensitive)

关联式容器

QMap

QMap<Key, T> 是 Qt 的通用容器类之一。 它存储(键，值)对，并提供与键关联的值的快速查找。
QMap 和 QHash 提供非常相似的功能。 区别在于：

• QHash 提供比 QMap 更快的平均查找速度。
• 在迭代 QHash 时，项目是任意排序的。 使用 QMap，项目总是按键排序。
• QHash 的键类型必须提供 operator==() 和全局 qHash(Key) 函数。 QMap 的键类型必须提供 operator<() 指定总顺序。 从 Qt 5.8.1 开始，使用指针类型作为键也是安全的，即使底层 operator<() 不提供全序。

公有函数

• 添加数据

//插入新的键值对，如果已经有一个键为key的项，则该项的值将被value替换；如果有多个键为key的项，则最近插入的项的值将被value替换。  
QMap::iterator insert(const Key &key, const T &value)
QMap::iterator insert(QMap::const_iterator pos, const Key &key, const T &value)
void insert(const QMap<Key, T> &map)
void insert(QMap<Key, T> &&map)

• 获取数据

T &first()            //获取第一个值
const Key &firstKey() const   //获取第一个键
    
T &last()
const Key &lastKey() const
    
Key key(const T &value, const Key &defaultKey = Key()) const  //根据值获取键

QList<Key> keys() const         //获取所有键
QList<Key> keys(const T &value) const //获取指定值对应的所有键

T value(const Key &key, const T &defaultValue = T()) const  //获取指定键对应的值
QList<T> values() const                   //获取所有值

T &operator[](const Key &key)       
T operator[](const Key &key) const

• 删除数据

void clear()

QMap::size_type remove(const Key &key)
QMap::size_type removeIf(Predicate pred)
    
T take(const Key &key)

• 查找

bool contains(const Key &key) const
/* 返回两个迭代器
迭代器1：是指向当前 map 容器中第一个等于(如果没有找到，就找或大于的第一个) key 的键值对的迭代器（lowerBound()）。
迭代器2：是指向当前 map 容器中第一个大于 key 的键值对的迭代器。（upperBound()）
*/
QPair<QMap::iterator, QMap::iterator> equal_range(const Key &key)
    
QMap::iterator find(const Key &key)

QMap::iterator lowerBound(const Key &key)
QMap::iterator upperBound(const Key &key)

• 判断

QMap::size_type count(const Key &key) const
QMap::size_type count() const
QMap::size_type size() const
    
bool empty() const
bool isEmpty() const

QMultiMap

QMultiMap<Key, T>是Qt的通用容器类之一。 它存储(键、值)对，并根据键提供快速查找。

该类大部分函数和QMap一样，除了下面新增的几个。

• 移除，比QMap多了一个

QMultiMap::size_type remove(const Key &key, const T &value)

• 替换

• 如果已经有一个键为key的项，则该项的值将被value替换。
• 如果有多个键为key的项，则最近插入的项的值将被value替换。

QMultiMap::iterator replace(const Key &key, const T &value)

• 合并：把other合并到当前map

QMultiMap<Key, T> &unite(const QMultiMap<Key, T> &other)
 QMultiMap<Key, T> &unite(QMultiMap<Key, T> &&other)

QHash

• 添加数据

QHash::iterator insert(const Key &key, const T &value)
 void insert(const QHash<Key, T> &other)

• 获取数据

Key key(const T &value, const Key &defaultKey = Key()) const

QList<Key> keys() const
QList<Key> keys(const T &value) const
   
 T value(const Key &key, const T &defaultValue = T()) const
 QList<T> values() const

• 删除数据

void clear()

bool remove(const Key &key)
qsizetype removeIf(Predicate pred)

T take(const Key &key)

• 查找

bool contains(const Key &key) const
    
QHash::iterator find(const Key &key)

• 判断

qsizetype count(const Key &key) const
qsizetype count() const
qsizetype size() const
    
bool empty() const
bool isEmpty() const

QMultiHash

QMultiHash<Key, T>是Qt的通用容器类之一。 它继承了QHash，并通过一些方便的函数对其进行扩展，使其比QHash更适合存储多值哈希。 多值散列是一种允许具有相同键的多个值的散列。

QMultiHash主要镜像QHash的API。 例如，您可以使用isEmpty()来测试散列是否为空，并且您可以使用QHash的迭代器类(例如，QHashIterator)遍历QMultiHash。 但与QHash不同的是，它提供了一个insert()函数，该函数允许插入具有相同键的多个项。 replace()函数对应于QHash::insert()。 它还提供了方便的operator+()和operator+=()。

与QMultiMap不同，QMultiHash不提供插入项的排序。 唯一的保证是共享相同密钥的项将连续出现，从最近插入的值到最近插入的值。

• 移除

qsizetype remove(const Key &key, const T &value)

• 替换

typename QHash<Key, T>::iterator replace(const Key &key, const T &value)

• 案例

class Grade //班级
{
public:
    Grade(int number, const QString& GradeName)
        :number(number),name(GradeName)
    {}
    friend QDebug operator<<(QDebug out, const Grade& stu);
    friend bool operator==(const Grade& left, const Grade& right);
    friend uint qHash(const Grade& stu, uint seed = 0);
private:
    int number;     //班级号
    QString name;   
};
QDebug operator<<(QDebug out, const Grade& stu)
{
    out << "[" << stu.number <<"," << stu.name << "]";
    return out;
}
bool operator==(const Grade& left, const Grade& right)
{
    return (left.number == right.number);
}
uint qHash(const Grade& stu, uint seed)
{
    return stu.number;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QHash<Grade, QString> hash;
    hash.insert(Grade(1403, "安卓"), "张三");
    hash.insert(Grade(1406, "苹果"), "李四");

    qDebug() << hash;

    return a.exec();
}

QSet

QSet<T>是Qt的泛型容器类之一。 它以不指定的顺序存储值，并提供非常快速的值查找。 在内部，QSet<T>被实现为一个QHash。

• 添加数据

QSet::iterator insert(const T &value)
QSet::iterator insert(QSet::const_iterator it, const T &value)

• 获取数据

QList<T> values() const

• 删除数据

void clear()

bool remove(const T &value)

• 查找

bool contains(const T &value) const
bool contains(const QSet<T> &other) const
    
QSet::const_iterator find(const T &value) const
QSet::iterator find(const T &value)

• 其他

int count() const
bool empty() const
bool isEmpty() const
int size() const

• 交集，差集，并集

//并集：ohter集合中不在这个集合中的每一项都被插入到这个集合中。 返回对该集合的引用。      
QSet<T> &unite(const QSet<T> &other)
//差集：从该集合中删除包含在ohter集合中的所有项。 返回对该集合的引用。  
QSet<T> &QSet::subtract(const QSet<T> &other)
//交集：从该集合中删除ohter集合中不包含的所有项。 返回对该集合的引用。      
QSet<T> &intersect(const QSet<T> &other)
//如果该集合与ohter集合至少有一个共同项，则返回true。      
bool intersects(const QSet<T> &other) const

8，算法

直接使用STL中的算法

QtGlobal

Qt类的头文件都会包含该头文件，所以不用再显式定义了

T qAbs(const T &t)  //求绝对值
//返回value限定在min至max范围之内的值
const T &qBound(const T &min, const T &val, const T &max)
//如果p1和p2近似相等，返回true
bool qFuzzyCompare(double p1, double p2)
bool qFuzzyCompare(float p1, float p2)
//如果浮点数约等于0，返回true    
bool qFuzzyIsNull(double d)
bool qFuzzyIsNull(float f)
//返回无穷大的数    
double qInf()
//求最大值和最小值
const T &qMax(const T &a, const T &b)
const T &qMin(const T &a, const T &b)
//四舍五入到最近的整数
qint64 qRound64(double d)
qint64 qRound64(float d)
int qRound(double d)
int qRound(float d)
//获得Qt版本    
const char *qVersion()

QtMath

常用函数

qreal qAcos(qreal v)      //以弧度角的形式返回 v 的反余弦值。 反余弦是余弦的逆运算。
qreal qAsin(qreal v)      //以弧度角的形式返回 v 的反正弦值。 反正弦是正弦的逆运算。
qreal qAtan2(qreal y, qreal x)  //返回由坐标 y 和 x 指定的点的反正切。 此函数将返回该点的角度（参数）。
qreal qAtan(qreal v)  //以弧度角的形式返回 v 的反正切。 反正切是正切的逆运算。

qreal qSin(qreal v)   //返回以弧度为单位的角v的正弦值
qreal qCos(qreal v)   //返回以弧度为单位的角v的余弦值。
qreal qTan(qreal v)   //返回以弧度为单位的角v的正切。
//此函数将浮点度数(角度)转换为弧度。   
float qDegreesToRadians(float degrees)
double qDegreesToRadians(double degrees)
//这个函数将浮点数radians弧度转换为角度。   
float qRadiansToDegrees(float radians)    
double qRadiansToDegrees(double radians)

qreal qExp(qreal v)   //返回 e 的 v 次幂的指数函数
qreal qFabs(qreal v)  //返回v的绝对值。

int qCeil(qreal v)    //返回值v的上限。上限值是不小于v的最小整数。例如，如果v是41.2，那么上限值是42
int qFloor(qreal v)   //返回值 v 的下限。下限是不大于 v 的最大整数。例如，如果 v 为 41.2，则下限为 41

//求直角三角形的斜边    
auto qHypot(F first, Fs... rest)
auto qHypot(Tx x, Ty y)
auto qHypot(Tx x, Ty y, Tz z)

quint32 qNextPowerOfTwo(quint32 value)  //这个函数返回比value大的2的最近幂。 对于0，它返回1，对于大于或等于2^31的值，它返回0。
quint64 qNextPowerOfTwo(quint64 value)
quint32 qNextPowerOfTwo(qint32 value)
quint64 qNextPowerOfTwo(qint64 value)
    
qreal qPow(qreal x, qreal y)        //返回x的y次方的值。也就是说，x是底数，y是指数。
qreal qSqrt(qreal v)            //返回v的平方根。如果v是负数，则返回NaN。
qreal qLn(qreal v)              //返回v的自然对数。自然对数以e为底。

宏