未分类 · 2022年11月29日

Qt所有的类


QT常用类大全
QApplication 应用程序类
QLabel 标签类
QPushButton 按钮类
QButtonGroup 按钮组合类
QGroupBox 群组类
QDateTimeEdit 日期时间编辑框类
QLineEdit 行编辑框类
QTextEdit 文本编辑框类
QComboBox 组合框类
QProgressBar 进度条类
QLCDNumber 数字显示框类
QScrollBar 滚动条类
QSpinBox 微调框类
QSlider 滑动条类
QIconView 图标视图类
QListView 列表视图类
QListBox 列表框类
QTable 表格类
QValidator 有效性检查类
QImage 图像类
QMainWindow 主窗口类
QPopupMenu 弹出性菜单类
QMenuBar 菜单栏类
QToolButton 工具按钮类
QToolTip 提示类
QWhatsThis 这是什么类
QAction 动作类
QHBoxLayout 水平布局类
QVBoxLayout 垂直布局类
QGridLayout 表格布局类
QT对话框类
QMessageBox 消息对话框类
QProgressDialog 进度条对话框类
QWizard 向导对话框类
QFileDialog 文件对话框类
QColorDialog 颜色对话框类
QFontDialog 字体对话框类
QPrintDialog 打印对话框类



  QChar 类是 Qt 中用于表示一个字符的类,实现在 QtCore 共享库中。QChar 类内部用2个字节的Unicode编码来表示一个字符。

        构造

        QChar 类提供了多个不同原型的构造函数以方便使用,如:

[plain] view plaincopyprint?

    QChar();                   //  构造一个空字符,即'\0'  
    QChar(char ch);         // 由字符数据ch构造  
    QChar(uchar ch);        // 由无符号字符数据ch构造  
    QChar(ushort code);   // 由无符号短整形数据code构造,code是Unicode编码  
    QChar(short code);     //由 短整形数据code构造,code是Unicode编码  
    QChar(uint code);      // 由无符号整型数据code构造,code是Unicode编码  
    QChar(int code);       // 由整型数据code构造,code是Unicode编码  

查看文本打印

    QChar();                   // 构造一个空字符,即'\0'  
    QChar(char ch);         // 由字符数据ch构造  
    QChar(uchar ch);        // 由无符号字符数据ch构造  
    QChar(ushort code);   // 由无符号短整形数据code构造,code是Unicode编码  
    QChar(short code);     //由 短整形数据code构造,code是Unicode编码  
    QChar(uint code);      // 由无符号整型数据code构造,code是Unicode编码  
    QChar(int code);       // 由整型数据code构造,code是Unicode编码  

查看文本打印

    QChar();                   // 构造一个空字符,即'\0'  
    QChar(char ch);         // 由字符数据ch构造  
    QChar(uchar ch);        // 由无符号字符数据ch构造  
    QChar(ushort code);   // 由无符号短整形数据code构造,code是Unicode编码  
    QChar(short code);     //由 短整形数据code构造,code是Unicode编码  
    QChar(uint code);      // 由无符号整型数据code构造,code是Unicode编码  
    QChar(int code);       // 由整型数据code构造,code是Unicode编码  

       实际使用时很少直接构造 QChar 类的对象,而是把这些构造函数当做类型转换来用,让编译器自动构造所需的QChar类对象。也就是说,在所有需要QChar类作为参数的地方都可以安全地使用各种整数类型。

       判断

       QChar 类提供了很多成员函数,可以对字符的类型进行判断,如:
[plain] view plaincopyprint?

    bool isDigit() const;            //  判断是否是十进制数字('0' - '9')  
    bool isLetter() const;          // 判断是否是字母  
    bool isNumber() const;        // 判断是否是数字,包括正负号、小数点等  
    bool isLetterOrNumber();    // 判断是否是字母或数字  
    bool isLower() const;           // 判断是否是小写字母  
    bool isUpper() const;           // 判断是否是大写字母  
    bool isNull() const;              //  判断是否是空子符'\0'  
    bool isPrint() const;            //  判断是否是可打印字符  
    bool isSpace() const;         // 判断是否是分隔符,包括空格等  

查看文本打印

    bool isDigit() const;            // 判断是否是十进制数字('0' - '9')  
    bool isLetter() const;          // 判断是否是字母  
    bool isNumber() const;        // 判断是否是数字,包括正负号、小数点等  
    bool isLetterOrNumber();    // 判断是否是字母或数字  
    bool isLower() const;           // 判断是否是小写字母  
    bool isUpper() const;           // 判断是否是大写字母  
    bool isNull() const;              // 判断是否是空子符'\0'  
    bool isPrint() const;            // 判断是否是可打印字符  
    bool isSpace() const;         // 判断是否是分隔符,包括空格等  

查看文本打印

    bool isDigit() const;            // 判断是否是十进制数字('0' - '9')  
    bool isLetter() const;          // 判断是否是字母  
    bool isNumber() const;        // 判断是否是数字,包括正负号、小数点等  
    bool isLetterOrNumber();    // 判断是否是字母或数字  
    bool isLower() const;           // 判断是否是小写字母  
    bool isUpper() const;           // 判断是否是大写字母  
    bool isNull() const;              // 判断是否是空子符'\0'  
    bool isPrint() const;            // 判断是否是可打印字符  
    bool isSpace() const;         // 判断是否是分隔符,包括空格等  

       转换

       QChar 类提供了一些成员函数进行数据的转换,如:
[plain] view plaincopyprint?

    char toAscii() const;           // 得到字符的ASCII码  
    QChar toLower() const;    // 转换成小写字母  
    QChar toUpper() const;    // 转换成大写字母  
    ushort unicode() const;    // 得到Unicode编码  

查看文本打印

    char toAscii() const;           // 得到字符的ASCII码  
    QChar toLower() const;    // 转换成小写字母  
    QChar toUpper() const;    // 转换成大写字母  
    ushort unicode() const;    // 得到Unicode编码  

查看文本打印

    char toAscii() const;           // 得到字符的ASCII码  
    QChar toLower() const;    // 转换成小写字母  
    QChar toUpper() const;    // 转换成大写字母  
    ushort unicode() const;    // 得到Unicode编码  

注意这几个函数都不会改变对象自身,转换的结果通过返回值反映出来。

      比较

      Qt 中定义了一些与 QChar 类相关的比较操作符, 如:
[plain] view plaincopyprint?

    bool operator !=& nbsp; (QChar c1, QChar c2);    // 判 断 c1 是否不等于 c2  
    bool operator <  (QChar c1, QChar c2);     //  判断  c1 是否小于 c2  
    bool operator <=& nbsp;(QChar c1, QChar c2);   // 判 断 c1 是否小于等于 c2  
    bool operator == (QChar c1, QChar c2);   // 判断 c1  
    是否等于c2  
    bool operator >  (QChar c1, QChar c2);    // 判 断 c1 是否大于 c2  
    bool operator >= (QChar c1, QChar c2);   // 判断  c1  
    是否大于等于 c2  

QString 类是 Qt 中用于表示字符串的类,实现在 QtCore 共享库中。QString 类在实现上有以下特征。

      1)字符串采用 Unicode 内部编码,可以表示世界上大多数语言的文字。

      2)字符串的存储有引用计数,当一个 QString 对象被复制为另一个 QString 对象时,它们实际上指向相同的存储空间,仅仅是增加一个引用计数。

      3)采用 “按需复制” 的技术,当指向相同存储空间的多个 QString 对象中的一个要被修改时,将真正复制一个新的字符串并进行修改。

       构造

       QString 类提供了很多不同原型的构造函数以方便使用。如:
[plain] view plaincopyprint?

    Qstring();                                        //  构造空字符串  
    QString(QChar ch);                           //  由 QChar 对象 ch构造  
    QString(const QChar *pch, int size);    //  由 QChar 数组pch构造,size 是数组大小  
    QString(const QString &obj);              //  拷贝构造函数  
    QString(const char *str);                  //   由字符串 str 构造,str是一个普通字符串  

查看文本打印

    Qstring();                                        // 构造空字符串  
    QString(QChar ch);                           // 由 QChar 对象 ch构造  
    QString(const QChar *pch, int size);    // 由 QChar 数组pch构造,size 是数组大小  
    QString(const QString &obj);              // 拷贝构造函数  
    QString(const char *str);                  //  由字符串 str 构造,str是一个普通字符串  

查看文本打印

    Qstring();                                        // 构造空字符串  
    QString(QChar ch);                           // 由 QChar 对象 ch构造  
    QString(const QChar *pch, int size);    // 由 QChar 数组pch构造,size 是数组大小  
    QString(const QString &obj);              // 拷贝构造函数  
    QString(const char *str);                  //  由字符串 str 构造,str是一个普通字符串  

       由于存在这些构造函数,凡是可以用 QString 类作为参数的地方,都可以安全地使用 QChar 对象或普通的字符串。

       判断 

       可以用下面的成员函数判断 QString 对象是否为空字符串:
[plain] view plaincopyprint?

    bool isEmpty() const;    // 判断是否为空字符串  

查看文本打印

    bool isEmpty() const;    // 判断是否为空字符串  

查看文本打印

    bool isEmpty() const;    // 判断是否为空字符串  

       转换

       QString 类提供了很多函数用于将字符串转换为数值,如:
[plain] view plaincopyprint?

    double toDouble(bool *ok =& nbsp;0) const;                                     //  转换为高精度浮点数  
    float toFloat(bool *ok =& nbsp;0) cosnt;                                          //  转换为浮点数  
    int toInt(bool *ok, int base =& nbsp;10) const;                                 //  转换为整型数  
    long toLong(bool *ok, int base =& nbsp;10) cosnt;                            //  转换为长整型  
    short toShort(bool *ok, int base =& nbsp;10) const;                          //  转换为短整型  
    uint toUInt(bool *ok =& nbsp;0; int base = 10) const   & nbsp;                     //  转换为无符号整型数  
    ulong toLong(bool *ok =& nbsp;0, int base = 10) const;  & nbsp;                  //  转换为无符号长整型数   
    ushort toUShort(bool *ok =& nbsp;0, int base = 10) const;  & nbsp;              //  转换为无符号短整型数  

查看文本打印

    double toDouble(bool *ok = 0) const;                                     // 转换为高精度浮点数  
    float toFloat(bool *ok = 0) cosnt;                                          // 转换为浮点数  
    int toInt(bool *ok, int base = 10) const;                                 // 转换为整型数  
    long toLong(bool *ok, int base = 10) cosnt;                            // 转换为长整型  
    short toShort(bool *ok, int base = 10) const;                          // 转换为短整型  
    uint toUInt(bool *ok = 0; int base = 10) const                         // 转换为无符号整型数  
    ulong toLong(bool *ok = 0, int base = 10) const;                     // 转换为无符号长整型数   
    ushort toUShort(bool *ok = 0, int base = 10) const;                 // 转换为无符号短整型数  

查看文本打印

    double toDouble(bool *ok = 0) const;                                     // 转换为高精度浮点数  
    float toFloat(bool *ok = 0) cosnt;                                          // 转换为浮点数  
    int toInt(bool *ok, int base = 10) const;                                 // 转换为整型数  
    long toLong(bool *ok, int base = 10) cosnt;                            // 转换为长整型  
    short toShort(bool *ok, int base = 10) const;                          // 转换为短整型  
    uint toUInt(bool *ok = 0; int base = 10) const                         // 转换为无符号整型数  
    ulong toLong(bool *ok = 0, int base = 10) const;                     // 转换为无符号长整型数   
    ushort toUShort(bool *ok = 0, int base = 10) const;                 // 转换为无符号短整型数  

       这些函数能够解析 QString 对象的内容,将其转换为相应的数值。其中 ok 参数指向一个 bool 型变量, 这个参数用于输出转换是否成功的信息。base参数则是转换为整数类型时的基。这些函数都不会改变 QString 对象自身。 

注意: 当字符串以 0x开头时,转换的基自动转换为16, 当字符串以0开头时,转换的基自动为8。

       下面这些成员函数可以将一个数值转换为字符串并设为 QString 对象的值:
[plain] view plaincopyprint?

    QString &setNum(int n, int base =& nbsp;10);                                           //  整型数  
    QString &setNum(uint n, int base =& nbsp;10);                                         //  无符号整型数  
    QString &setNum(long n, int base =& nbsp;10);                                        //  长整型  
    QString &setNum(ulong n, int base =& nbsp;10);                                       //  无符号长整型数  
    QString &setNum(short n, int base =& nbsp;10);                                       //  短整型数  
    QString &setNum(ushort n, int base =& nbsp;10);                                      //  无符号短整型数  
    QString &setNum(double n, char format =& nbsp;'g', int precision = 6);   & nbsp;      // 高精度浮点数  
    QString &setNum(float n, char format =& nbsp;'g', int precision = 6);   & nbsp;        // 浮点 数  

查看文本打印

    QString &setNum(int n, int base = 10);                                           // 整型数  
    QString &setNum(uint n, int base = 10);                                         // 无符号整型数  
    QString &setNum(long n, int base = 10);                                        // 长整型  
    QString &setNum(ulong n, int base = 10);                                       // 无符号长整型数  
    QString &setNum(short n, int base = 10);                                       // 短整型数  
    QString &setNum(ushort n, int base = 10);                                      // 无符号短整型数  
    QString &setNum(double n, char format = 'g', int precision = 6);          // 高精度浮点数  
    QString &setNum(float n, char format = 'g', int precision = 6);            // 浮点数  

查看文本打印

    QString &setNum(int n, int base = 10);                                           // 整型数  
    QString &setNum(uint n, int base = 10);                                         // 无符号整型数  
    QString &setNum(long n, int base = 10);                                        // 长整型  
    QString &setNum(ulong n, int base = 10);                                       // 无符号长整型数  
    QString &setNum(short n, int base = 10);                                       // 短整型数  
    QString &setNum(ushort n, int base = 10);                                      // 无符号短整型数  
    QString &setNum(double n, char format = 'g', int precision = 6);          // 高精度浮点数  
    QString &setNum(float n, char format = 'g', int precision = 6);            // 浮点数  

       将浮点数转换为字符串时,format 参数指定转化格式,precision 参数指定转换结果的精度,既有效数组的个数。注意这些函数会改变 QString 对象本身的值,而以下的函数则采用了不同的做法,它们返回一个新的临时对象以供使用:
[plain] view plaincopyprint?

    QString number(int n, int base = 10);  
    QString number(uint n, int base = 10);  
    QString number(long n, int base = 10);  
    QString number(ulong n ,int base = 10);  
    QString number(double n, char format = 'q', int precision = 6);  

查看文本打印

    QString number(int n, int base = 10);  
    QString number(uint n, int base = 10);  
    QString number(long n, int base = 10);  
    QString number(ulong n ,int base = 10);  
    QString number(double n, char format = 'q', int precision = 6);  

查看文本打印

    QString number(int n, int base = 10);  
    QString number(uint n, int base = 10);  
    QString number(long n, int base = 10);  
    QString number(ulong n ,int base = 10);  
    QString number(double n, char format = 'q', int precision = 6);  

       这些函数都是静态成员函数,因而与某个具体的对象无关,可以直接通过类名调用。

       QString 类也提供了大小写转换的函数,如:
[plain] view plaincopyprint?

    QString toLower() const;    // 转换为小写  
    QString toUpper() const;    // 转换为大写  

查看文本打印

    QString toLower() const;    // 转换为小写  
    QString toUpper() const;    // 转换为大写  

查看文本打印

    QString toLower() const;    // 转换为小写  
    QString toUpper() const;    // 转换为大写  

       这些函数都不会改变 QString 对象本身,而是将转换后的结果作为返回值。

       比较

       QString 类提供了一个函数用于两个 QString 对象的比较:
[plain] view plaincopyprint?

    int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

查看文本打印

    int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

查看文本打印

    int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

这是一个静态成员函数,它可以比较 s1 和 s2 的大小,参数 cs 有以下两个取值。
[plain] view plaincopyprint?

    Qt::CaseInsensitive: 表示对大小写不敏感  
    Qt::Casesensitive :    表示对大小写敏感  

查看文本打印

    Qt::CaseInsensitive: 表示对大小写不敏感  
    Qt::Casesensitive :    表示对大小写敏感  

查看文本打印

    Qt::CaseInsensitive: 表示对大小写不敏感  
    Qt::Casesensitive :    表示对大小写敏感  

       返回值的含义如下:大于 0 表示 s1 大于 s2,等于 0 表示 s1 等于 s2, 小于 0 表示 s1 小于 s2。

       为了方便使用,QString 类还提供了以下重载函数用于比较:
[plain] view plaincopyprint?

    int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

查看文本打印

    int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

查看文本打印

    int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

      这个函数用于比较 QString 对象自身和 QString 对象 other。      实际上更为直观的是使用 QString 类的比较操作符,如:
[plain] view plaincopyprint?

    bool operator <  (StringType other) const;        //  比较是否小于 other人  
    bool operator <=& nbsp; (StringType other) const;      //  比较是否小于等于 other  
    bool operator ==& nbsp; (StringType other) const;      //  比较是否等于 other  
    bool operator >  (StringType other) constt;       //  比较是否大于 other  
    bool operator >=& nbsp; (StringType other) const;      //  比较是否大于等于 other  
    bool operator !=& nbsp; (StringType other) const;       //  比较是否不等于 other  

查看文本打印

    bool operator < (StringType other) const;        // 比较是否小于 other人  
    bool operator <= (StringType other) const;      // 比较是否小于等于 other  
    bool operator == (StringType other) const;      // 比较是否等于 other  
    bool operator > (StringType other) constt;       // 比较是否大于 other  
    bool operator >= (StringType other) const;      // 比较是否大于等于 other  
    bool operator != (StringType other) const;       // 比较是否不等于 other  

查看文本打印

    bool operator < (StringType other) const;        // 比较是否小于 other人  
    bool operator <= (StringType other) const;      // 比较是否小于等于 other  
    bool operator == (StringType other) const;      // 比较是否等于 other  
    bool operator > (StringType other) constt;       // 比较是否大于 other  
    bool operator >= (StringType other) const;      // 比较是否大于等于 other  
    bool operator != (StringType other) const;       // 比较是否不等于 other  

      这里的 StringType 指的是 (const QString &)或 (const char *),哥也就是说,这些操作副既可以与 QString 对象比较,也可以与普通的字符串比较。它们的局限性是第一个操作数必须是 QString 对象,因此,Qt 中又定义了以下操作符:
[plain] view plaincopyprint?

    bool operator <  (const char *s1, const QString &s2);                 //  比较 s1 是否小于 s2  
    bool operator <=& nbsp; (const char *s1, const QString &s2);               //  比较 s1 是否小于等于 s2  
    bool operator ==& nbsp; (const char *s1, const QString &s2);               //  比较 s1 是否等于 s2  
    bool operator >  (const char *s1, const QString &s2);                 //  比较 s1 是否大于 s2  
    bool operator >=& nbsp; (const char *s1, const QString &s2);               //  比较 s1 是否大于等于 s2  
    bool operator !=& nbsp; (const char *s1, const QString &s2);                //  比较 s1 是否不等于 s2  

查看文本打印

    bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2  
    bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2  
    bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2  
    bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2  
    bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2  
    bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2  

查看文本打印

    bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2  
    bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2  
    bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2  
    bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2  
    bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2  
    bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2  

       这些操作符不是 QString 类的成员,它们的第一个参数是普通字符串。

       查找
       用以下的成员函数可以判断 QString 对象是否包含指定的字符串或字符:
[plain] view plaincopyprint?

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

查看文本打印

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

查看文本打印

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

        用以下的成员函数可以得到 QString 对象包含某个特定字符串或字符的个数:
[plain] view plaincopyprint?

    int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

查看文本打印

    int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

查看文本打印

    int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

        用以下的成员函数可以得到 QString 对象中某个特定字符串或字符出现的位置:
[plain] view plaincopyprint?

    int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

查看文本打印

    int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

查看文本打印

    int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

        这里参数 from 是查找的起点,它可以为负数,-i 表示倒数第i个字符。查找的方向是从前往后。返回值是查找到的字符串或字符的位置,如果没有找到则返回 -1。

        QString 类中还有与此功能相似的函数用于从后往前查找字符串或字符:
[plain] view plaincopyprint?

    int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const  

查看文本打印

    int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const  

查看文本打印

    int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const  

        字符串处理

 QString  类支持用赋值操作符进行对象的复制,其赋值操作符的声明如下:    
[plain] view plaincopyprint?

    QString &operator =& nbsp; (const QString &other);        //  复制另外一个 QString 对象  
    QString &operator =& nbsp; (const char *str);               //  复制普通字符串  
    QString &operator =& nbsp; (char ch);                         //  复制字符  
    QString &operator =& nbsp; (QChar ch);                       //  复制 QChar 类对象  

查看文本打印

    QString &operator = (const QString &other);        // 复制另外一个 QString 对象  
    QString &operator = (const char *str);               // 复制普通字符串  
    QString &operator = (char ch);                         // 复制字符  
    QString &operator = (QChar ch);                       // 复制 QChar 类对象  

查看文本打印

    QString &operator = (const QString &other);        // 复制另外一个 QString 对象  
    QString &operator = (const char *str);               // 复制普通字符串  
    QString &operator = (char ch);                         // 复制字符  
    QString &operator = (QChar ch);                       // 复制 QChar 类对象  

        以下的成员函数可以将另一个字符串或字符接在 QString 对象后面,形成一个整体的字符串:
[plain] view plaincopyprint?

    QString &append(const QString &str);                //  接续 QString 对象  
    QString &append(const char *str);                    //  接续普通字符串  
    QString &append(QChar ch);                            //  接续 QChar 对象   

查看文本打印

    QString &append(const QString &str);                // 接续 QString 对象  
    QString &append(const char *str);                    // 接续普通字符串  
    QString &append(QChar ch);                            // 接续 QChar 对象   

查看文本打印

    QString &append(const QString &str);                // 接续 QString 对象  
    QString &append(const char *str);                    // 接续普通字符串  
    QString &append(QChar ch);                            // 接续 QChar 对象   

        它们的返回值是 QString 对象自己的引用,也就是说,可以用在这个返回值再次调用成员函数,形成连续的字符串接续操作。

        为了让代码更直观, QString 类中还定义了一个操作符用于字符串的接续:
[plain] view plaincopyprint?

    QString &operator +=& nbsp; (const QString &other);     //  续接 QString 对象  
    QString &operator += (const char *str);    // 续接普通字符串  
    QString &operator += (char ch);    // 接续字符型数据  
    QString &operator += (QChar ch);   // 接续 QChar 对象  

查看文本打印

    QString &operator += (const QString &other);     // 续接 QString 对象  
    QString &operator += (const char *str);    // 续接普通字符串  
    QString &operator += (char ch);    // 接续字符型数据  
    QString &operator += (QChar ch);   // 接续 QChar 对象  

查看文本打印

    QString &operator += (const QString &other);     // 续接 QString 对象  
    QString &operator += (const char *str);    // 续接普通字符串  
    QString &operator += (char ch);    // 接续字符型数据  
    QString &operator += (QChar ch);   // 接续 QChar 对象  

        它们的功能与 append 相同。由于 C++ 语言允许赋值操作符和复合赋值操作符的返回值作为左值使用,因此它们的返回值也被设计为 QString 对象自己的引用,故也可以连续操作。但由于复合赋值操作符的结合顺序是从右往左,要想先计算左边的操作数需要加括号。

       与 append 函数功能类似,以下的成员函数也能够将另一个字符串或字符与 QString 对象连接起来,但是接在原字符串的前面:
[plain] view plaincopyprint?

    QString &prepend(const QString &str);          //  在前面接续 QString 对象  
    QString &prepend(const char *str);              //  在前面接续普通字符串  
    QString &prepend(QChar ch);                      //  在前面接续 QChar 对象  

查看文本打印

    QString &prepend(const QString &str);          // 在前面接续 QString 对象  
    QString &prepend(const char *str);              // 在前面接续普通字符串  
    QString &prepend(QChar ch);                      // 在前面接续 QChar 对象  

查看文本打印

    QString &prepend(const QString &str);          // 在前面接续 QString 对象  
    QString &prepend(const char *str);              // 在前面接续普通字符串  
    QString &prepend(QChar ch);                      // 在前面接续 QChar 对象  

       功能更一般化的是在 QString 对象的任意位置插入另一个字符串或字符,如:
[plain] view plaincopyprint?

    QString &insert(int position, const QString &str);                   //  插入字符串  
    QString &insert(int position, const QChar *pch, int size);         //  插入 QChar 数组  
    QString &insert(int position, QChar ch);                               //  插入 QChar 对象  

查看文本打印

    QString &insert(int position, const QString &str);                   // 插入字符串  
    QString &insert(int position, const QChar *pch, int size);         // 插入 QChar 数组  
    QString &insert(int position, QChar ch);                               // 插入 QChar 对象  

查看文本打印

    QString &insert(int position, const QString &str);                   // 插入字符串  
    QString &insert(int position, const QChar *pch, int size);         // 插入 QChar 数组  
    QString &insert(int position, QChar ch);                               // 插入 QChar 对象  

       这里 position 参数是要插入的位置,返回值也是对 QString 对象自己的引用。 

       与插入相反的操作是移除 QString 对象中的一部分,如:
[plain] view plaincopyprint?

    QString &remove(int position, int n);  

查看文本打印

    QString &remove(int position, int n);  

查看文本打印

    QString &remove(int position, int n);  

       这个函数可以移除 QString 对象中从位置 position 开始的 n 个字符,下面两个成员函数则可以从 QString 对象中移除指定的字符串或字符:
[plain] view plaincopyprint?

    QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
    QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

查看文本打印

    QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
    QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

查看文本打印

    QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
    QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

       以下是 QString 对象的替换操作:
[plain] view plaincopyprint?

    QString &replace(int position, int n, const QString &after);                    // QString  对象  
    QString &replace(int position, int n, const QChar *pch, int size);            // QChar  数组  
    QString &replace(int opsition, int n, QChar after);                                // QChar  对象  

查看文本打印

    QString &replace(int position, int n, const QString &after);                    // QString 对象  
    QString &replace(int position, int n, const QChar *pch, int size);            // QChar 数组  
    QString &replace(int opsition, int n, QChar after);                                // QChar 对象  

查看文本打印

    QString &replace(int position, int n, const QString &after);                    // QString 对象  
    QString &replace(int position, int n, const QChar *pch, int size);            // QChar 数组  
    QString &replace(int opsition, int n, QChar after);                                // QChar 对象  

      这三个函数的功能是将 QString 对象从 position 开始的 n 个字符替换为新内容,新内容分别由 QString 对象、QChar 数组 和 QChar 对象表示。

      以下成员函数则可以搜索指定的字符串或字符并开始替换:
[plain] view plaincopyprint?

    QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs =& nbsp;Qt::CaseSensitive);      // QString  替换为 QString  
    QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs =& nbsp;Qt::CaseSensitive);                       // QChar  替换为 QString  
    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs =& nbsp;Qt::CaseSensitive);                              // Qchar  替换为 QChar  

查看文本打印

    QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString  
    QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QString  
    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar  

查看文本打印

    QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString  
    QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QString  
    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar  

      下面这个成员函数可以清空一个 QString 对象的内容,使之成为空字符串。
[plain] view plaincopyprint?

    void clear();  

查看文本打印

    void clear();  

查看文本打印

    void clear();  

       而下面这个成员函数可以截断 QStrring 对象,也就是去掉指定位置后的所有内容:
[plain] view plaincopyprint?

    void truncate(int position);      // 从位置 position 截断,位置从0开始编号  

查看文本打印

    void truncate(int position);      // 从位置 position 截断,位置从0开始编号  

查看文本打印

    void truncate(int position);      // 从位置 position 截断,位置从0开始编号  

       下面这个成员函数可以截掉 QString 对象最后的若干个字符:
[plain] view plaincopyprint?

    void chop(int n);     // 截掉最后的 n个字符  

查看文本打印

    void chop(int n);     // 截掉最后的 n个字符  

查看文本打印

    void chop(int n);     // 截掉最后的 n个字符  

        以下几个成员函数可以得到 QString 对象的子字符串:
[plain] view plaincopyprint?

    QString left(int n) const;      // 得到左边 n 个字符构成的子字符串  
    QString right(int n) const;    // 得到右边 n 个字符构成的子字符串  
    QString mid(int position, int n = -1) const;  // 从中间得到子字符串  

查看文本打印

    QString left(int n) const;      // 得到左边 n 个字符构成的子字符串  
    QString right(int n) const;    // 得到右边 n 个字符构成的子字符串  
    QString mid(int position, int n = -1) const;  // 从中间得到子字符串  

查看文本打印

    QString left(int n) const;      // 得到左边 n 个字符构成的子字符串  
    QString right(int n) const;    // 得到右边 n 个字符构成的子字符串  
    QString mid(int position, int n = -1) const;  // 从中间得到子字符串  

        从中间得到子字符串时,参数 position 是子字符串的起始位置,参数 n 是字符串的个数,如果n 为 -1,则表示一直到原字符串的结尾。

        注意上述三个函数并不修改 QString 对象自身,而是返回一个临时对象以供使用。

        下面这个成员函数可以截去 QString 对象中头部和尾部的空白字符:
[plain] view plaincopyprint?

    QString trimmed() const;  

查看文本打印

    QString trimmed() const;  

查看文本打印

    QString trimmed() const;  

        空白字符包括空格、回车、换行、制表符等字符。下面这个成员函数不仅能去掉 QString 对象头尾的空白字符,还能将中间的连续多个空白字符全部替换成一个空格:
[plain] view plaincopyprint?

    QString simlified() const;  

查看文本打印

    QString simlified() const;  

查看文本打印

    QString simlified() const;  

        加法操作符可以将两个字符串或字符连接起来并以 QString 临时对象的方式返回:
[plain] view plaincopyprint?

    const QString operator+(const QString &s1, const QString &s2);         
    const QString operator+(const QString &s1, const char *s2);  
    const QString operator+(const char s1, const QString &s2);  
    const QString operator+(const QString &s, char ch);   

查看文本打印

    const QString operator+(const QString &s1, const QString &s2);         
    const QString operator+(const QString &s1, const char *s2);  
    const QString operator+(const char s1, const QString &s2);  
    const QString operator+(const QString &s, char ch);   

查看文本打印

    const QString operator+(const QString &s1, const QString &s2);         
    const QString operator+(const QString &s1, const char *s2);  
    const QString operator+(const char s1, const QString &s2);  
    const QString operator+(const QString &s, char ch);   

        注意加法操作符的两个操作数中必须至少有一个是 QString 对象,否则无法重载操作符。显然,加法操作副都不是 QString 类的成员。     

        索引

        QString 类也像普通的字符串一样可以根据下标得到某个位置上的字符:
[plain] view plaincopyprint?

    const QChar at(int position) const;  

查看文本打印

    const QChar at(int position) const;  

查看文本打印

    const QChar at(int position) const;  

        这是一个成员函数,更直观的方法是用以下的操作符:
[plain] view plaincopyprint?

    const QChar operator[] (int position) const;  
    const QChar operator[] (uint position) const;  

查看文本打印

    const QChar operator[] (int position) const;  
    const QChar operator[] (uint position) const;  

查看文本打印

    const QChar operator[] (int position) const;  
    const QChar operator[] (uint position) const;  

         这样对 QString 对象的取字符操作就类似于对一个字符数组的操作。事实上,通过【】操作符得到的字符还可以被修改,要用到另外两个重载的【】操作符:
[plain] view plaincopyprint?

    QCharRef operator[] (int position);  
    QCharRef operator[] (uint position);  

查看文本打印

    QCharRef operator[] (int position);  
    QCharRef operator[] (uint position);  

查看文本打印

    QCharRef operator[] (int position);  
    QCharRef operator[] (uint position);  

         返回的 QCharRef 类是一个辅助类,对它的修改将反映到原字符串中去。

         统计

         以下两个成员函数都可以得到 QString 对象中字符的个数:
[plain] view plaincopyprint?

    int size() const;  
    int length() const;  

查看文本打印

    int size() const;  
    int length() const;  

查看文本打印

    int size() const;  
    int length() const;  

         注意字符的个数并不一定等于字节数。

QPoint 类代表一个坐标点,实现在 QtCore 共享库中。它可以认为是一个整型的横坐标和一个整型的纵坐标的组合。

    构造

    QPoint 类支持以下两种构造方式:
[plain] view plaincopyprint?

    QPoint();    // 构造横纵坐标均为 0 的 QPoint 对象  
    QPoint(int x, int y);    //  构造横纵坐标分别为 x 和 y 的 QPont 对象  

查看文本打印

    QPoint();    // 构造横纵坐标均为 0 的 QPoint 对象  
    QPoint(int x, int y);    // 构造横纵坐标分别为 x 和 y 的 QPont 对象  

查看文本打印

    QPoint();    // 构造横纵坐标均为 0 的 QPoint 对象  
    QPoint(int x, int y);    // 构造横纵坐标分别为 x 和 y 的 QPont 对象  

    属性

    通过以下成员函数可得到 QPoint 对象中的横纵坐标的引用:
[plain] view plaincopyprint?

    int &rx();    // 得到横坐标的引用  
    int &ry();    // 到到纵坐标的引用  

查看文本打印

    int &rx();    // 得到横坐标的引用  
    int &ry();    // 到到纵坐标的引用  

查看文本打印

    int &rx();    // 得到横坐标的引用  
    int &ry();    // 到到纵坐标的引用  

     注意这些引用都不是只读的,也就是说可以通过它们直接修改 QPoint。

     通过以下的成员函数可以设置 QPoint 对象中的横纵坐标:
[plain] view plaincopyprint?

    void setX(int x);    // 设置横坐标为 x  
    void setY(int y);    // 设置纵坐标为 y  

查看文本打印

    void setX(int x);    // 设置横坐标为 x  
    void setY(int y);    // 设置纵坐标为 y  

查看文本打印

    void setX(int x);    // 设置横坐标为 x  
    void setY(int y);    // 设置纵坐标为 y  

     下面两个成员函数则是只读的,可以获得 QPoint 对象中的横纵坐标:
[plain] view plaincopyprint?

    int x() const;    // 获得横坐标  
    int y() const;    // 获得纵坐标  

查看文本打印

    int x() const;    // 获得横坐标  
    int y() const;    // 获得纵坐标  

查看文本打印

    int x() const;    // 获得横坐标  
    int y() const;    // 获得纵坐标  

     操作符

QPoint 类支持加法和减法的复合赋值操作:
[plain] view plaincopyprint?

    QPoint &operator+=(const QPoint &point);    // 加赋值  
    QPoint &operator-=(const QPoint &point);    // 减赋值  

查看文本打印

    QPoint &operator+=(const QPoint &point);    // 加赋值  
    QPoint &operator-=(const QPoint &point);    // 减赋值  

查看文本打印

    QPoint &operator+=(const QPoint &point);    // 加赋值  
    QPoint &operator-=(const QPoint &point);    // 减赋值  

    这两个操作符是它的成员。而以下的操作符则不是它的成员:
[plain] view plaincopyprint?

    cosnt QPoint operator+ (const QPoint &p1, const QPoint &p2);    //  加法  
    const QPoint operator- (const QPoint &p1, const QPoint &p2);     //  减法  
    const QPoint operator- (const QPoint &point);                          //  取负数  
    bool operator== (const QPoint &p1, const QPoint &p2);            //  判断是否相等  
    bool operator!= (const QPoint &p1, const QPoint);                   //  判断是否不等  

 QSize 类代表一个矩形区域的大小,实现在 QtCore 共享库中。它可以认为是由一个整型的宽度和整型的高度组合而成的。

        构造
[plain] view plaincopyprint?

    QSize();    // 构造一个非法的 QSize 对象  
    QSize(int width, int height);    //  构造宽度为 width、高度为 height 的 QSize  对 象   

查看文本打印

    QSize();    // 构造一个非法的 QSize 对象  
    QSize(int width, int height);    // 构造宽度为 width、高度为 height 的 QSize  对象   

查看文本打印

    QSize();    // 构造一个非法的 QSize 对象  
    QSize(int width, int height);    // 构造宽度为 width、高度为 height 的 QSize  对象   

        属性

        以下成员函数可以得到 QSize 对象中宽度和高度的引用:
[plain] view plaincopyprint?

    void setWidth(int width);    // 设置宽度  
    void setHeight(int height);    // 设置高度  

查看文本打印

    void setWidth(int width);    // 设置宽度  
    void setHeight(int height);    // 设置高度  

查看文本打印

    void setWidth(int width);    // 设置宽度  
    void setHeight(int height);    // 设置高度  

        通过以下成员函数可以获得 QSize 对象的宽度和高度:
[plain] view plaincopyprint?

    int width() const;    // 获得宽度  
    int height() const;  // 获得高度  

查看文本打印

    int width() const;    // 获得宽度  
    int height() const;  // 获得高度  

查看文本打印

    int width() const;    // 获得宽度  
    int height() const;  // 获得高度  

        操作符

        QSize 类支持和 QPoint 类相似的操作符。

QFont 类代表字体,实现在 QtGui 共享库中。

      构造

      QFont 类有以下几个常用的构造函数:
[plain] view plaincopyprint?

    QFont();    // 由应用程序的默认字体构造新字体对象  
    QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);    

查看文本打印

    QFont();    // 由应用程序的默认字体构造新字体对象  
    QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);    

查看文本打印

    QFont();    // 由应用程序的默认字体构造新字体对象  
    QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);    

       其中第二个构造函数的各个参数的含义解释如下。

       1) family: 字体的名称。

       2) pointSize: 字体的点大小,如果这个参数小于等于0,则自动设为 12。

       3) weight: 字体的粗细。

       4) italic: 字体是否为斜体。

       这些参数也可以在字体对象构造以后通过属性来修改。

       属性

       QFont 类的常用属性如下所示:

     字体的属性                                                                获取所用成员函数                                                               设置所有成员函数

           名称                                                                   QString family() const;                                                      void setFamily(const QString &family);

        点大小                                                                  int pointSize() const;                                                         void setPointSize(int pointSize);

      像素大小                                                                int pixelSize() const;                                                          void setPixelSize(int pixelSize);

          粗细                                                                    int weight() const;                                                              void setWeight(int weight);

          粗体                                                                    bool bold() const;                                                              void setBold(bool enable);

          斜体                                                                    bool italic() const;                                                              void setItalic(bool enable);

       下划线                                                                   bool underline() const;                                                     void setUnderline(bool enable);

       其中设置粗体属性实际上就是将字体的粗细设为一个确定的值。点大小与像素大小是指定字体大小的两种方式。如果指定了点大小,则像素大小属性的 值就是 -1;反之如果指定了像素大小,则点大小属性的值就是 -1。  
       如果指定的字体在使用时没有对应的字体文件,Qt 将自动选择最接近的字体。如果要显示的字符在字体中不存在,则字符会被显示为一个空心方框。      

QPixmap 类代表图像,实现在 QtGui 共享库中。

      构造

      以下构造函数生成的 QPixmap 对象为空图像:
[plain] view plaincopyprint?

    QPixmap();     // 构造一个大小为 0 的空图像  

查看文本打印

    QPixmap();     // 构造一个大小为 0 的空图像  

查看文本打印

    QPixmap();     // 构造一个大小为 0 的空图像  

      以下构造函数生成大小的 QPixmap 对象,但图像数据未初始化:
[plain] view plaincopyprint?

    QPixmap(const QSize &size);     // 构造大小为 size 的图像,图像数据未初始化  
    QPixmap(int width, int height);    //  等价于 QPixmap(QSize(width, height));  

查看文本打印

    QPixmap(const QSize &size);     // 构造大小为 size 的图像,图像数据未初始化  
    QPixmap(int width, int height);    // 等价于 QPixmap(QSize(width, height));  

查看文本打印

    QPixmap(const QSize &size);     // 构造大小为 size 的图像,图像数据未初始化  
    QPixmap(int width, int height);    // 等价于 QPixmap(QSize(width, height));  

      以下构造函数能够从指定的文件中加载图像并生成 QPixmap 对象:
[plain] view plaincopyprint?

    QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  

查看文本打印

    QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  

查看文本打印

    QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  

      其各个参数的含义解释如下。

      1) filename: 文件名。

      2) format: 字符串,表示图像文件的格式,如果为 0,将进行自动识别。

      3) flags:表示颜色的转换模式。

       如果图像文件加载失败则产生空图像,这里 flags 参数有以下取值。

       1) Qt::AutoColor:由系统自动决定。

       2) Qt::ColorOnly:彩色模式。

       3) Qt::MonoOnly:单色模式。

       图像参数

       以下成员函数可以获得 QPixmap 对象所表示的图像的相关信