Описание класса QString
|
class | Null |
typedef | ConstIterator |
typedef | Iterator |
enum | NormalizationForm { NormalizationForm_D, NormalizationForm_C, NormalizationForm_KD, NormalizationForm_KC } |
enum | SectionFlag { SectionDefault, SectionSkipEmpty, SectionIncludeLeadingSep, SectionIncludeTrailingSep, SectionCaseInsensitiveSeps } |
flags | SectionFlags |
enum | SplitBehavior { KeepEmptyParts, SkipEmptyParts } |
typedef | const_iterator |
typedef | iterator |
QString () | |
QString ( const QChar * unicode, int size ) | |
QString ( QChar ch ) | |
QString ( int size, QChar ch ) | |
QString ( const QLatin1String & str ) | |
QString ( const QString & other ) | |
QString ( const char * str ) | |
QString ( const QByteArray & ba ) | |
~QString () | |
QString & | append ( const QString & str ) |
QString & | append ( const QStringRef & reference ) |
QString & | append ( const QLatin1String & str ) |
QString & | append ( const QByteArray & ba ) |
QString & | append ( const char * str ) |
QString & | append ( QChar ch ) |
QString | arg ( const QString & a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( const QString & a1, const QString & a2 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7, const QString & a8 ) const |
QString | arg ( const QString & a1, const QString & a2, const QString & a3, const QString & a4, const QString & a5, const QString & a6, const QString & a7, const QString & a8, const QString & a9 ) const |
QString | arg ( int a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( uint a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( long a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( ulong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( qlonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( qulonglong a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( short a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( ushort a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( QChar a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( char a, int fieldWidth = 0, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
QString | arg ( double a, int fieldWidth = 0, char format = 'g', int precision = -1, const QChar & fillChar = QLatin1Char( ' ' ) ) const |
const QChar | at ( int position ) const |
iterator | begin () |
const_iterator | begin () const |
int | capacity () const |
void | chop ( int n ) |
void | clear () |
int | compare ( const QString & other ) const |
int | compare ( const QString & other, Qt::CaseSensitivity cs ) const |
int | compare ( const QLatin1String & other, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
int | compare ( const QStringRef & ref, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
const_iterator | constBegin () const |
const QChar * | constData () const |
const_iterator | constEnd () const |
bool | contains ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
bool | contains ( QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
bool | contains ( const QRegExp & rx ) const |
bool | contains ( QRegExp & rx ) 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 QRegExp & rx ) const |
int | count () const |
QChar * | data () |
const QChar * | data () const |
iterator | end () |
const_iterator | end () const |
bool | endsWith ( const QString & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
bool | endsWith ( const QLatin1String & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
bool | endsWith ( const QChar & c, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
QString & | fill ( QChar ch, int size = -1 ) |
int | indexOf ( const QString & str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
int | indexOf ( const QLatin1String & 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 QRegExp & rx, int from = 0 ) const |
int | indexOf ( QRegExp & rx, int from = 0 ) const |
QString & | insert ( int position, const QString & str ) |
QString & | insert ( int position, const QLatin1String & str ) |
QString & | insert ( int position, const QChar * unicode, int size ) |
QString & | insert ( int position, QChar ch ) |
bool | isEmpty () const |
bool | isNull () const |
int | lastIndexOf ( const QString & str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
int | lastIndexOf ( const QLatin1String & 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 QRegExp & rx, int from = -1 ) const |
int | lastIndexOf ( QRegExp & rx, int from = -1 ) const |
QString | left ( int n ) const |
QString | leftJustified ( int width, QChar fill = QLatin1Char( ' ' ), bool truncate = false ) const |
QStringRef | leftRef ( int n ) const |
int | length () const |
int | localeAwareCompare ( const QStringRef & other ) const |
int | localeAwareCompare ( const QString & other ) const |
QString | mid ( int position, int n = -1 ) const |
QStringRef | midRef ( int position, int n = -1 ) const |
QString | normalized ( NormalizationForm mode ) const |
QString | normalized ( NormalizationForm mode, QChar::UnicodeVersion version ) const |
QString & | prepend ( const QString & str ) |
QString & | prepend ( const QLatin1String & str ) |
QString & | prepend ( const QByteArray & ba ) |
QString & | prepend ( const char * str ) |
QString & | prepend ( QChar ch ) |
void | push_back ( const QString & other ) |
void | push_back ( QChar ch ) |
void | push_front ( const QString & other ) |
void | push_front ( QChar ch ) |
QString & | remove ( int position, int n ) |
QString & | remove ( QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | remove ( const QString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | remove ( const QRegExp & rx ) |
QString | repeated ( int times ) const |
QString & | replace ( int position, int n, const QString & after ) |
QString & | replace ( int position, int n, const QChar * unicode, int size ) |
QString & | replace ( int position, int n, QChar after ) |
QString & | replace ( const QString & before, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( const QChar * before, int blen, const QChar * after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( QChar ch, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( const QLatin1String & before, const QLatin1String & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( const QLatin1String & before, const QString & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( const QString & before, const QLatin1String & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( QChar c, const QLatin1String & after, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString & | replace ( const QRegExp & rx, const QString & after ) |
void | reserve ( int size ) |
void | resize ( int size ) |
QString | right ( int n ) const |
QString | rightJustified ( int width, QChar fill = QLatin1Char( ' ' ), bool truncate = false ) const |
QStringRef | rightRef ( int n ) const |
QString | section ( QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault ) const |
QString | section ( const QString & sep, int start, int end = -1, SectionFlags flags = SectionDefault ) const |
QString | section ( const QRegExp & reg, int start, int end = -1, SectionFlags flags = SectionDefault ) const |
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 ( qlonglong n, int base = 10 ) |
QString & | setNum ( qulonglong 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 & | setUnicode ( const QChar * unicode, int size ) |
QString & | setUtf16 ( const ushort * unicode, int size ) |
QString | simplified () const |
int | size () const |
QStringList | split ( const QString & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
QStringList | split ( const QChar & sep, SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
QStringList | split ( const QRegExp & rx, SplitBehavior behavior = KeepEmptyParts ) const |
QString & | sprintf ( const char * cformat, ... ) |
void | squeeze () |
bool | startsWith ( const QString & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
bool | startsWith ( const QLatin1String & s, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
bool | startsWith ( const QChar & c, Qt::CaseSensitivity cs = Qt::CaseSensitive ) const |
QByteArray | toAscii () const |
QString | toCaseFolded () const |
double | toDouble ( bool * ok = 0 ) const |
float | toFloat ( bool * ok = 0 ) const |
int | toInt ( bool * ok = 0, int base = 10 ) const |
QByteArray | toLatin1 () const |
QByteArray | toLocal8Bit () const |
long | toLong ( bool * ok = 0, int base = 10 ) const |
qlonglong | toLongLong ( bool * ok = 0, int base = 10 ) const |
QString | toLower () const |
short | toShort ( bool * ok = 0, int base = 10 ) const |
std::string | toStdString () const |
std::wstring | toStdWString () const |
uint | toUInt ( bool * ok = 0, int base = 10 ) const |
ulong | toULong ( bool * ok = 0, int base = 10 ) const |
qulonglong | toULongLong ( bool * ok = 0, int base = 10 ) const |
ushort | toUShort ( bool * ok = 0, int base = 10 ) const |
QVector<uint> | toUcs4 () const |
QString | toUpper () const |
QByteArray | toUtf8 () const |
int | toWCharArray ( wchar_t * array ) const |
QString | trimmed () const |
void | truncate ( int position ) |
const QChar * | unicode () const |
const ushort * | utf16 () const |
QString & | vsprintf ( const char * cformat, va_list ap ) |
bool | operator!= ( const QString & other ) const |
bool | operator!= ( const QLatin1String & other ) const |
bool | operator!= ( const QByteArray & other ) const |
bool | operator!= ( const char * other ) const |
QString & | operator+= ( const QString & other ) |
QString & | operator+= ( const QLatin1String & str ) |
QString & | operator+= ( const QByteArray & ba ) |
QString & | operator+= ( const char * str ) |
QString & | operator+= ( const QStringRef & str ) |
QString & | operator+= ( char ch ) |
QString & | operator+= ( QChar ch ) |
bool | operator< ( const QString & other ) const |
bool | operator< ( const QLatin1String & other ) const |
bool | operator< ( const QByteArray & other ) const |
bool | operator< ( const char * other ) const |
bool | operator<= ( const QString & other ) const |
bool | operator<= ( const QLatin1String & other ) const |
bool | operator<= ( const QByteArray & other ) const |
bool | operator<= ( const char * other ) const |
QString & | operator= ( const QString & other ) |
QString & | operator= ( const QLatin1String & str ) |
QString & | operator= ( const QByteArray & ba ) |
QString & | operator= ( const char * str ) |
QString & | operator= ( char ch ) |
QString & | operator= ( QChar ch ) |
bool | operator== ( const QString & other ) const |
bool | operator== ( const QLatin1String & other ) const |
bool | operator== ( const QByteArray & other ) const |
bool | operator== ( const char * other ) const |
bool | operator> ( const QString & other ) const |
bool | operator> ( const QLatin1String & other ) const |
bool | operator> ( const QByteArray & other ) const |
bool | operator> ( const char * other ) const |
bool | operator>= ( const QString & other ) const |
bool | operator>= ( const QLatin1String & other ) const |
bool | operator>= ( const QByteArray & other ) const |
bool | operator>= ( const char * other ) const |
QCharRef | operator[] ( int position ) |
const QChar | operator[] ( int position ) const |
QCharRef | operator[] ( uint position ) |
const QChar | operator[] ( uint position ) const |
int | compare ( const QString & s1, const QString & s2, Qt::CaseSensitivity cs ) |
int | compare ( const QString & s1, const QString & s2 ) |
int | compare ( const QString & s1, const QLatin1String & s2, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
int | compare ( const QLatin1String & s1, const QString & s2, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
int | compare ( const QString & s1, const QStringRef & s2, Qt::CaseSensitivity cs = Qt::CaseSensitive ) |
QString | fromAscii ( const char * str, int size = -1 ) |
QString | fromLatin1 ( const char * str, int size = -1 ) |
QString | fromLocal8Bit ( const char * str, int size = -1 ) |
QString | fromRawData ( const QChar * unicode, int size ) |
QString | fromStdString ( const std::string & str ) |
QString | fromStdWString ( const std::wstring & str ) |
QString | fromUcs4 ( const uint * unicode, int size = -1 ) |
QString | fromUtf8 ( const char * str, int size = -1 ) |
QString | fromUtf16 ( const ushort * unicode, int size = -1 ) |
QString | fromWCharArray ( const wchar_t * string, int size = -1 ) |
int | localeAwareCompare ( const QString & s1, const QString & s2 ) |
int | localeAwareCompare ( const QString & s1, const QStringRef & s2 ) |
QString | number ( long n, int base = 10 ) |
QString | number ( double n, char format = 'g', int precision = 6 ) |
QString | number ( ulong n, int base = 10 ) |
QString | number ( int n, int base = 10 ) |
QString | number ( uint n, int base = 10 ) |
QString | number ( qlonglong n, int base = 10 ) |
QString | number ( qulonglong n, int base = 10 ) |
bool | operator!= ( const char * s1, const QString & s2 ) |
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+ ( char ch, const QString & s ) |
const QString | operator+ ( const QString & s, char ch ) |
bool | operator< ( const char * s1, const QString & s2 ) |
QDataStream & | operator<< ( QDataStream & stream, const QString & string ) |
bool | operator<= ( const char * s1, const QString & s2 ) |
bool | operator== ( const char * s1, const QString & s2 ) |
bool | operator> ( const char * s1, const QString & s2 ) |
bool | operator>= ( const char * s1, const QString & s2 ) |
QDataStream & | operator>> ( QDataStream & stream, QString & string ) |
QT_NO_CAST_FROM_ASCII | |
QT_NO_CAST_TO_ASCII |
Класс QString предоставляет строку символов Unicode.
QString хранит строку 16-битных QChar, где каждому QChar соответствует один символ Unicode 4.0. (Символы Unicode со значениями кодов больше 65535 хранятся с использованием суррогатных пар, т.е. двух последовательных QChar.)
Unicode - это международный стандарт, который поддерживает большинство использующихся сегодня систем письменности. Это расширение ASCII и Latin-1 (ISO 8859-1), где все символы ASCII/Latin-1 доступны на позициях с тем же кодом.
Внутри QString использует неявное совместное использование данных (копирование-при-записи), чтобы уменьшить использование памяти и избежать ненужного копирования данных. Это также позволяет снизить накладные расходы, свойственные хранению 16-битных символов вместо 8-битных.
В дополнение к QString Qt также предоставляет класс QByteArray для хранения сырых байт и традиционных нультерминальных строк. В большинстве случаев QString - необходимый для использования класс. Он используется во всем API Qt, а поддержка Unicode гарантирует, что ваши приложения можно будет легко перевести на другой язык, если в какой-то момент вы захотите увеличить их рынок распространения. Два основных случая, когда уместно использование QByteArray: когда вам необходимо хранить сырые двоичные данные и когда критично использование памяти (например, в Qt для встраиваемых Linux-систем).
Один из способов инициализации QString - просто передать const char * в конструктор. Например, следующий код создает QString размером 5 байт, содержащий данные "Hello":
QString str = "Hello";
QString преобразует данные const char * в Unicode, используя функцию fromAscii(). По умолчанию, fromAscii() обрабатывает символы с кодом выше 128 как символы Latin-1, но это может быть изменено вызовом QTextCodec::setCodecForCStrings().
Во всех функциях QString, которые принимают параметры const char *, const char * интерпретируется как классическая нультерминальная строка в стиле C. Допускается, что параметр const char * может быть равным 0.
Вы также можете предоставить строку данных как массив QChar:
static const QChar data[4] = { 0x0055, 0x006e, 0x10e3, 0x03a3 }; QString str(data, 4);
QString делает глубокую копию данных QChar, так что вы можете изменять их в дальнейшем без возникновения побочных эффектов. (Если из соображений производительности вы не хотите, чтобы была сделана глубокая копия символьных данных, то используйте вместо этого QString::fromRawData().)
Другой подход состоит в установке размера строки посредством resize() и посимвольной инициализации данных. QString использует индексы, начинающиеся с 0, как принято в массивах C++. Для доступа к символу в определённой позиции вы можете использовать operator[](). В неконстантных строках operator[]() возвращает ссылку на символ, которая может быть использована с левой стороны операции присваивания. Например:
QString str; str.resize(4); str[0] = QChar('U'); str[1] = QChar('n'); str[2] = QChar(0x10e3); str[3] = QChar(0x03a3);
Для доступа "только для чтения" необходимо использовать функцию at():
QString str; for (int i = 0; i < str.size(); ++i) { if (str.at(i) >= QChar('a') && str.at(i) <= QChar('f')) qDebug() << "Found character in range [a-f]"; }
Функция at() может быть быстрее, чем operator[](), поскольку она никогда не выполняет глубокое копирование. В качестве альтернативы используйте функции left(), right() или mid() для получения нескольких символов за один раз.
QString может содержать символ '\0' (QChar::Null). Функция size() всегда возвращает размер всей строки, включая содержащиеся символы '\0'.
После вызова функции resize() добавленные символы будут содержать неопределенные значения. Чтобы проинициализировать все символы определённым значением, вызовите функцию fill().
QString предоставляет множество перегруженных функций, предназначенных для упрощения использования строк. Например, если вы хотите сравнить QString со строковым литералом, вы можете написать код, подобный этому, и он будет работать так, как ожидается:
QString str;
if (str == "auto" || str == "extern"
|| str == "static" || str == "register") {
// ...
}
Вы также можете передавать строковые литералы в функции, которые принимают строки QString как аргументы, активизируя конструктор QString(const char *). Точно также вы можете передавать QString в функции, принимающие аргумент const char *, используя макрос qPrintable(), который возвращает данный QString как const char *. Это эквивалентно вызову <QString>.toLocal8Bit().constData().
QString предоставляет следующие базовые функции для изменения символьных данных: append(), prepend(), insert(), replace() и remove(). Например:
QString str = "and"; str.prepend("rock "); // str == "rock and" str.append(" roll"); // str == "rock and roll" str.replace(5, 3, "&"); // str == "rock & roll"
Если вы создаёте QString постепенно и заранее знаете, сколько примерно символов будет содержать QString, вы можете вызвать reserve(), запрашивая QString заранее выделить определённое количество памяти. Вы также можете вызвать capacity(), чтобы узнать, сколько фактически памяти выделил QString.
Первые два аргумента функций replace() и remove() - это позиция, с которой надо начать удаление, и количество символов, которое должно быть удалено. Если вы хотите заменить все вхождения конкретной подстроки другой подстрокой, используйте одну из перегруженных функций replace() с двумя параметрами.
Часто надо удалить из строки пробелы, символы табуляции и новой строки ('\n', '\t', ' ' и т.д.). Если вы хотите удалить пробельные символы с обоих концов QString, используйте функцию trimmed(). Если вы хотите удалить пробельные символы с обоих концов и заменить последовательности из нескольких таких символов одним пробелом внутри строки, используйте simplified().
Если вы хотите найти все вхождения символа или подстроки в QString, используйте indexOf() или lastIndexOf(). Первая функция осуществляет поиск вперед от указанной позиции, а последняя - осуществляет поиск назад. Обе функции возвращают индекс позиции символа или подстроки, если они были найдены, в противном случае возвращается -1. Например, здесь приведен типичный цикл, который находит все совпадения конкретной подстроки:
QString str = "We must be <b>bold</b>, very <b>bold</b>"; int j = 0; while ((j = str.indexOf("<b>", j)) != -1) { qDebug() << "Found <b> tag at index position" << j; ++j; }
QString предоставляет множество функций для преобразования чисел в строки и строк в числа. Смотрите функции arg(), функции setNum(), статические функции number(), toInt() и toDouble() и подобные функции.
Для получения строки в верхнем или нижнем регистре используйте toUpper() или toLower().
Списки строк обрабатываются классом QStringList. Вы можете разделить строку на список строк, используя функцию split(), и объединить список строк в одну строку с указанием разделителя, используя QStringList::join(). Вы можете получить список строк из строки со списком, взяв только те элементы, которые содержат определённую подстроку или которые соответствуют определённому QRegExp, используя функцию QStringList::find(). :
Если вы хотите определить, начинается ли или заканчивается ли QString определённой подстрокой, используйте startsWith() или endsWith(). Если вы просто хотите проверить, содержит ли QString определённый символ или подстроку, используйте функцию contains(). Если вам нужно узнать, сколько раз символ или подстрока встречаются в строке, используйте count().
QString можно сравнивать, используя перегруженные операторы, такие как operator<(), operator<=(), operator==(), operator>=() и так далее. Обратите внимание, что сравнение основывается исключительно на числовых значениях Unicode-символов. Это очень быстро, но не то, что ожидает человек; функция QString::localeAwareCompare() лучше подходит для сортировки строк пользовательского интерфейса.
Чтобы получить указатель непосредственно на символьные данные, вызовите data() или constData(). Эти функции возвращают указатель на начало данных QChar. Указатель гарантировано остаётся правильным до тех пор, пока не будет вызвана неконстантная функция на QString.
QString предоставляет следующие четыре функции, которые возвращают const char * версию строки как QByteArray: toAscii(), toLatin1(), toUtf8() и toLocal8Bit().
Для преобразования из одной из этих кодировок QString предоставляет функции fromAscii(), fromLatin1(), fromUtf8() и fromLocal8Bit(). Другие кодировки поддерживаются через класс QTextCodec.
Как уже упоминалось выше, QString предоставляет множество функций и операторов, которые позволяют легко взаимодействовать со строками const char *. Но эта функциональность как палка о двух концах: она делает QString более удобным в использовании, если все строки - ASCII или Latin-1, но всегда есть риск того, что неявное преобразование из или в const char * будет осуществлено с использованием неправильной 8-битной кодировки. Для минимизации этих рисков вы можете отключить эти неявные преобразования путём определения следующих двух символов препроцессора:
Один из способов определения этих символов препроцессора глобально для вашего приложения состоит в том, чтобы добавить следующую запись в ваш файл проекта qmake:
DEFINES += QT_NO_CAST_FROM_ASCII \ QT_NO_CAST_TO_ASCII
В этом случае вам необходимо явно вызывать fromAscii(), fromLatin1(), fromUtf8() или fromLocal8Bit() для создания QString из 8-битных строк или использовать лёгкий класс QLatin1String, например:
QString url = QLatin1String("http://www.unicode.org/");
Точно также вы должны явно вызывать toAscii(), toLatin1(), toUtf8() или toLocal8Bit() для преобразования QString в 8-битную строку. (Другие кодировки поддерживаются через класс QTextCodec.)
Примечания для программистов на CИз-за системы типов C++ и того факта, что QString применяет неявное совместное использование, строки QString могут быть обработаны как int или другие базовые типы. Например: QString Widget::boolToString(bool b) { QString result; if (b) result = "True"; else result = "False"; return result; } Переменная result - это нормальная переменная, размещённая в стеке. Поскольку при вызове return происходит возврат по значению, то вызывается копирующий конструктор и возвращается копия строки. Никакого фактического копирования не происходит благодаря неявному совместному использованию. |
По историческим причинам QString различает нулевую и пустую строки. Нулевая строка - это строка, которая инициализирована конструктором QString по умолчанию или передачей в конструктор (const char *)0. Пустая строка - это любая строка размером 0. Нулевая строка всегда пустая, но пустая строка не обязательно нулевая:
QString().isNull(); // возвращает true QString().isEmpty(); // возвращает true QString("").isNull(); // возвращает false QString("").isEmpty(); // возвращает true QString("abc").isNull(); // возвращает false QString("abc").isEmpty(); // возвращает false
Все функции, кроме isNull(), обрабатывают нулевые строки так же, как и пустые строки. Например, toAscii().constData() возвращает указатель на символ '\0' для нулевой строки (не нулевой указатель), а QString() при сравнении равен QString(""). Мы рекомендуем всегда использовать функцию isEmpty() и избегать isNull().
В функциях-членах, в которых формат аргумента может быть определён (например, arg(), number()), формат аргумента может быть одним из следующих:
Формат | Значение |
---|---|
e | представляется как [-]9.9e[+|-]999 |
E | представляется как [-]9.9E[+|-]999 |
f | представляется как [-]9.9 |
g | используется формат e или f, смотря какой окажется короче |
G | используется формат E или f, смотря какой окажется короче |
Точность также определяется форматом аргумента. Для форматов 'e', 'E' и 'f' точность представляет собой количество цифр после десятичной точки. Для форматов 'g' и 'G' точность представляет собой максимальное количество значащих цифр (конечные нули не учитываются).
Используя оператор '+' QString, легко создать сложную строку из нескольких подстрок. Вы часто будете писать такой код:
QString foo; QString type = "long"; foo->setText(QLatin1String("vector<") + type + QLatin1String(">::iterator")); if (foo.startsWith("(" + type + ") 0x")) ...
В этих конструкциях нет ничего неправильного, но есть несколько скрытых неэффективностей. Начиная с Qt 4.6, вы можете устранить их.
Во-первых, многократное использование оператора '+' обычно означает многократное выделение памяти. При объединении n подстрок, где n > 2, может быть осуществлено целых n - 1 обращений за выделением памяти.
Во-вторых, QLatin1String не хранит свою длину внутри себя, а вызывает qstrlen(), когда необходимо определить его длину.
В 4.6 был добавлен внутренний шаблонный класс QStringBuilder вместе с несколькими вспомогательными функциями. Этот класс помечен как внутренний и не отражён в документации, потому что вы не должны создавать его экземпляры в своём коде. Он будет использоваться автоматически, как описано ниже. Класс находится в src/corelib/tools/qstringbuilder.cpp, если вы хотите взглянуть на него.
QStringBuilder использует шаблоны выражений и переопределяет оператор '%', так что вы можете использовать '%' вместо '+' для объединения строк, а многократное объединение подстрок будет отложено до момента присвоения окончательного результата QString. В этот момент объём памяти, необходимый для окончательного результата, уже известен. Распределитель памяти в этом случае вызывается для получения необходимого места один раз, и подстроки копируются туда одна за другой.
QLatin1Literal - это второй внутренний класс, который может быть использован вместо QLatin1String, который нельзя изменить из соображений совместимости. QLatin1Literal хранит свою длину, тем самым экономя время, когда QStringBuilder вычисляет объём памяти, необходимый для окончательной строки.
Дополнительная эффективность достигается путём встраивания и уменьшения подсчёта ссылок (у QString, созданного из QStringBuilder, счётчик ссылок обычно равен 1, в то время как QString::append() требует дополнительной проверки).
Существует три способа, с помощью которых вы можете получить доступ к улучшенным методам создания строки. Прямым способом является подключение QStringBuilder везде, где вы хотите его применить, и использование оператора '%' вместо '+' при объединении строк:
#include <QStringBuilder> QString hello("hello"); QStringRef el(&hello, 2, 3); QLatin1String world("world"); QString message = hello % el % world % QChar('!');
При более глобальном подходе необходимо включить это определение:
#define QT_USE_FAST_CONCATENATION
и везде для объединения строк использовать '%' вместо '+'. Третий подход, который является наиболее удобным, но не полностью совместимым с исходным кодом, - это включение двух определений:
#define QT_USE_FAST_CONCATENATION #define QT_USE_FAST_OPERATOR_PLUS
и '+' будет везде выполняться как QStringBuilder '%'.
Смотрите также fromRawData(), QChar, QLatin1String, QByteArray и QStringRef.
Синоним QString::const_iterator в стиле Qt.
Синоним QString::iterator в стиле Qt.
Это перечисление описывает различные нормализованные формы текста Unicode.
Константа | Значение | Описание |
---|---|---|
QString::NormalizationForm_D | 0 | Каноническая декомпозиция |
QString::NormalizationForm_C | 1 | Каноническая декомпозиция с последующей канонической композицией |
QString::NormalizationForm_KD | 2 | Совместимая декомпозиция |
QString::NormalizationForm_KC | 3 | Совместимая декомпозиция с последующей канонической композицией |
Смотрите также normalized() и Unicode Standard Annex #15.
Данное перечисление определяет флаги, которые могут быть использованы для управления различными аспектами поведения функции section() в отношении разделителей и пустых полей.
Константа | Значение | Описание |
---|---|---|
QString::SectionDefault | 0x00 | Пустые поля подсчитываются, начальные и конечные разделители не учитываются, а разделитель сравнивается с учётом регистра. |
QString::SectionSkipEmpty | 0x01 | Пустые поля обрабатываются так, как будто их не существует, т.е. они не принимаются во внимание в отношении start и end. |
QString::SectionIncludeLeadingSep | 0x02 | Включает начальный разделитель (если такой есть) в строку результата. |
QString::SectionIncludeTrailingSep | 0x04 | Включает конечный разделитель (если такой есть) в строку результата. |
QString::SectionCaseInsensitiveSeps | 0x08 | Сравнивает разделитель без учёта регистра. |
Тип SectionFlags - это псевдоним (typedef) для QFlags<SectionFlag>. Он хранит комбинацию значений (по ИЛИ) SectionFlag.
Смотрите также section().
Данное перечисление определяет, как должна себя вести функция split() по отношению к пустым строкам.
Константа | Значение | Описание |
---|---|---|
QString::KeepEmptyParts | 0 | Если поле пустое, сохранять его в результат. |
QString::SkipEmptyParts | 1 | Если поле пустое, не включать его в результат. |
Смотрите также split().
Псевдоним типа QString::const_iterator предоставляет константный итератор в стиле STL для QString.
Смотрите также QString::iterator.
Псевдоним типа QString::iterator предоставляет неконстантный итератор в стиле STL для QString.
Смотрите также QString::const_iterator.
Создаёт нулевую строку. Нулевые строки также являются пустыми.
Смотрите также isEmpty().
Создаёт строку, инициализированную первыми size символами QChar массива unicode.
QString делает глубокую копию строковых данных. Unicode-данные копируются как есть, а символ Byte Order Mark сохраняется, если он присутствует.
Создаёт строку размером 1, содержащую символ ch.
Создаёт строку заданного размера size, каждый символ которой установлен в ch.
Смотрите также fill().
Создаёт копию Latin-1 строки str.
Смотрите также fromLatin1().
Создаёт копию other.
Эта операция занимает постоянное время, поскольку QString использует неявное совместное использование данных. Это делает возвращение QString, как результата функции, очень быстрым. Если экземпляр с разделением данных изменяется, то он будет скопирован (copy-on-write), и это потребует линейного времени.
Смотрите также operator=().
Создаёт строку, инициализированную строкой str в кодах ASCII. Получаемый константный указатель на char преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить этот конструктор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Смотрите также fromAscii(), fromLatin1(), fromLocal8Bit() и fromUtf8().
Создаёт строку, инициализированную массивом байт ba. Получаемый массив байт преобразуется в Unicode при помощи fromAscii(). Копирование останавливается на первом символе 0, в противном случае копируется весь массив байт.
Вы можете отключить этот конструктор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Смотрите также fromAscii(), fromLatin1(), fromLocal8Bit() и fromUtf8().
Уничтожает строку.
Добавляет строку str в конец этой строки.
Пример:
QString x = "free";
QString y = "dom";
x.append(y);
// x == "freedom"
Это то же самое, что и использование функции insert():
x.insert(x.size(), y);
Функция append() обычно очень быстрая (занимает постоянное время), поскольку QString резервирует дополнительное место в конце строковых данных, что позволяет ему увеличиваться, не перераспределяя строку каждый раз.
Смотрите также operator+=(), prepend() и insert().
Добавляет получаемую ссылку reference на строку к этой строке и возвращает результат.
Эта функция была введена в Qt 4.4.
Эта функция перегружает функцию append().
Добавляет строку str в кодах Latin-1 к этой строке.
Эта функция перегружает функцию append().
Добавляет массив байт ba к этой строке. Получаемый массив байт преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию append().
Добавляет строку str к этой строке. Получаемый константный указатель на char преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию append().
Добавляет символ ch к этой строке.
Возвращает копию этой строки с заменённым строкой a маркером размещения с наименьшим номером, например, %1, %2, ..., %99.
fieldWidth определяет минимальное количество места, которое должен занимать аргумент a. Если для a необходимо места меньше, чем fieldWidth, то он дополняется до fieldWidth символом fillChar. Положительное значение fieldWidth производит выравнивание по правому краю. Отрицательное значение fieldWidth производит выравнивание по левому краю.
Этот пример показывает, как мы могли бы создать строку status для отчёта о продвижении при обработке списка файлов:
QString i; // текущий номер файла QString total; // количество файлов в обработке QString fileName; // текущее имя файла QString status = QString("Processing file %1 of %2: %3") .arg(i).arg(total).arg(fileName);
В начале arg(i) заменяет %1. Затем arg(total) заменяет %2. Наконец, arg(fileName) заменяет %3.
Одним из преимуществ использования arg() над sprintf() является то, что порядок маркеров размещения может измениться, если строки приложения будут переведены на другие языки, но каждый arg() будет всё так же заменять наименьший по номеру не заменённый маркер размещения, независимо от того, где он появляется. Кроме того, если маркер размещения %i появляется в строке несколько раз, arg() заменяет все вхождения.
Если не осталось ни одного не заменённого маркера размещения, то выводится предупреждающее сообщение, и результат не определён. Номера маркеров размещения должны быть в диапазоне от 1 до 99.
Эта функция перегружает функцию arg().
Это то же самое, что и str.arg(a1).arg(a2), за исключением того что строки a1 и a2 заменяются за один проход. Это может иметь значение, если a1 содержит, например, %1:
QString str; str = "%1 %2"; str.arg("%1f", "Hello"); // возвращает "%1f Hello" str.arg("%1f").arg("Hello"); // возвращает "Hellof %2"
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3), за исключением того что строки a1, a2 и a3 заменяются за один проход.
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3).arg(a4), за исключением того что строки a1, a2, a3 и a4 заменяются за один проход.
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5), за исключением того что строки a1, a2, a3, a4 и a5 заменяются за один проход.
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6), за исключением того что строки a1, a2, a3, a4, a5 и a6 заменяются за один проход.
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7), за исключением того что строки a1, a2, a3, a4, a5, a6 и a7 заменяются за один проход.
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8), за исключением того что строки a1, a2, a3, a4, a5, a6, a7 и a8 заменяются за один проход.
Эта функция перегружает функцию arg().
Это то же самое, что и вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8).arg(a9), за исключением того что строки a1, a2, a3, a4, a5, a6, a7, a8 и a9 заменяются за один проход.
Эта функция перегружает функцию arg().
Аргумент a представляется по основанию base, которое по умолчанию равно 10 и должно быть между 2 и 36. Для оснований, отличных от 10, a рассматривается как целое число без знака.
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
За '%' может следовать 'L', в этом случае результат заменяется локализованным представлением a. При преобразовании используется локаль по умолчанию, установленная функцией QLocale::setDefault(). Если локаль по умолчанию не была указана, используется локаль "C". Флаг 'L' игнорируется, если основание base не равно 10.
QString str; str = QString("Decimal 63 is %1 in hexadecimal") .arg(63, 0, 16); // str == "Decimal 63 is 3f in hexadecimal" QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates)); str = QString("%1 %L2 %L3") .arg(12345) .arg(12345) .arg(12345, 0, 16); // str == "12345 12,345 3039"
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
Аргумент base определяет основание, используемое при преобразовании целого a в строку. Основание должно быть между 2 и 36.
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
Аргумент a представляется по полученному основанию base, которое по умолчанию равно 10 и должно быть между 2 и 36.
За '%' может следовать 'L', в этом случае результат заменяется локализованным представлением a. При преобразовании используется локаль по умолчанию. Локаль по умолчанию определяется из настроек локали системы при запуске приложения. Она может быть изменена с помощью QLocale::setDefault(). Флаг 'L' игнорируется, если основание base не равно 10.
QString str; str = QString("Decimal 63 is %1 in hexadecimal") .arg(63, 0, 16); // str == "Decimal 63 is 3f in hexadecimal" QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates)); str = QString("%1 %L2 %L3") .arg(12345) .arg(12345) .arg(12345, 0, 16); // str == "12345 12,345 3039"
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
Аргумент base определяет основание, используемое при преобразовании целого a в строку. Основание должно быть между 2 и 36, причём 8 - это восьмеричные числа, 10 - десятичные и 16 - шестнадцатеричные.
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
Аргумент base определяет основание, используемое при преобразовании целого a в строку. Основание должно быть между 2 и 36, причём 8 - это восьмеричные числа, 10 - десятичные и 16 - шестнадцатеричные.
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
Аргумент base определяет основание, используемое при преобразовании целого a в строку. Основание base должно быть между 2 и 36, причём 8 - это восьмеричные числа, 10 - десятичные и 16 - шестнадцатеричные.
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
Аргумент base определяет основание, используемое при преобразовании целого a в строку. Основание должно быть между 2 и 36, причём 8 - это восьмеричные числа, 10 - десятичные и 16 - шестнадцатеричные.
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
Аргумент base определяет основание, используемое при преобразовании целого a в строку. Основание должно быть между 2 и 36, причём 8 - это восьмеричные числа, 10 - десятичные и 16 - шестнадцатеричные.
Если fillChar равен '0' (цифра 0, ASCII 48), используется ноль локали. Для отрицательных значений ведущие нули могут появиться перед знаком минус.
Эта функция перегружает функцию arg().
Эта функция перегружает функцию arg().
Аргумент a интерпретируется как символ в коде Latin-1.
Эта функция перегружает функцию arg().
Аргумент a форматируется в соответствии с указанными форматом format и точностью precision. Для получения подробной информации смотрите Форматы аргументов.
fieldWidth определяет минимальное количество места, до которого дополняется a и заполняется символом fillChar. Положительное значение производит выравнивание текста по правому краю, отрицательное - по левому.
double d = 12.34;
QString str = QString("delta: %1").arg(d, 0, 'E', 3);
// str == "delta: 1.234E+01"
За '%' может следовать 'L', в этом случае результат заменяется локализованным представлением a. При преобразовании используется локаль по умолчанию, установленная функцией QLocale::setDefault(). Если локаль по умолчанию не была указана, используется локаль "C".
Если fillChar равен '0' (цифра 0, ASCII 48), эта функция будет использовать ноль локали для заполнения. Для отрицательных значений ведущие нули, вероятно, появятся перед знаком минус.
Смотрите также QLocale::toString().
Возвращает символ по указанному индексу position в строке.
Позиция position должна быть действительным индексом в строке (т.е., 0 <= position < size()).
Смотрите также operator[]().
Возвращает итератор в стиле STL, указывающий на первый символ в строке.
Смотрите также constBegin() и end().
Эта функция перегружает функцию begin().
Возвращает максимальное число символов, которые могут быть сохранены в строке без дополнительного перераспределения памяти.
Единственная цель этой функции - обеспечить оптимальное использование памяти в QString. Вообще, у вас крайне редко возникнет необходимость вызывать эту функцию. Если вы хотите узнать количество символов в массиве, используйте size().
Смотрите также reserve() и squeeze().
Удаляет n символов в конце строки.
Если n больше, чем size(), то вы получите пустую строку.
Пример:
QString str("LOGOUT\r\n");
str.chop(2);
// str == "LOGOUT"
Если вы хотите удалить символы в начале строки, используйте вместо этого remove().
Смотрите также truncate(), resize() и remove().
Очищает содержимое строки и делает её пустой.
Смотрите также resize() и isEmpty().
Сравнивает s1 с s2 и возвращает целое число, меньшее, равное или большее нуля, если s1 меньше, равно или больше, чем s2, соответственно.
Если cs равен Qt::CaseSensitive, то сравнение происходит с учётом регистра, в противном случае - без учёта.
Сравнение с учётом регистра основано исключительно на числовых значениях символов Unicode и производится очень быстро, но не соответствует ожиданиям человека. Рассмотрим сортировку видимых пользователем строк с помощью localeAwareCompare().
int x = QString::compare("aUtO", "AuTo", Qt::CaseInsensitive); // x == 0 int y = QString::compare("auto", "Car", Qt::CaseSensitive); // y > 0 int z = QString::compare("auto", "Car", Qt::CaseInsensitive); // z < 0
Эта функция была введена в Qt 4.2.
Смотрите также operator==(), operator<() и operator>().
Эта функция перегружает функцию compare().
Выполняет сравнение s1 и s2 с учётом регистра.
Эта функция перегружает функцию compare().
Выполняет сравнение s1 и s2, используя настройку cs учёта регистра.
Эта функция была введена в Qt 4.2.
Эта функция перегружает функцию compare().
Выполняет сравнение s1 и s2, используя настройку cs учёта регистра.
Эта функция была введена в Qt 4.2.
Эта функция перегружает функцию compare().
Лексически сравнивает эту строку с другой строкой other и возвращает целое число, меньшее, равное или большее нуля, если эта строка меньше, равна или больше другой строки.
Эквивалентно compare(*this, other).
Эта функция перегружает функцию compare().
Тоже самое, что и compare(*this, other, cs).
Эта функция была введена в Qt 4.2.
Эта функция перегружает функцию compare().
Тоже самое, что и compare(*this, other, cs).
Эта функция была введена в Qt 4.2.
Эта функция перегружает функцию compare().
Сравнивает ссылку ref на строку со строкой и возвращает целое число, меньшее, равное или большее нуля, если строка меньше, равна или больше, чем ref.
Эта функция перегружает функцию compare().
Возвращает константный итератор в стиле STL, указывающий на первый символ в строке.
Смотрите также begin() и constEnd().
Возвращает указатель на данные, хранящиеся в QString. Указатель можно использовать для доступа к символам, которые составляют строку. Для удобства данные завершаются символом '\0'.
Заметьте, что указатель остаётся действительным до тех пор, пока строка не будет изменена.
Смотрите также data() и operator[]().
Возвращает константный итератор в стиле STL, указывающий на воображаемый элемент после последнего элемента в списке.
Смотрите также constBegin() и end().
Возвращает true, если строка содержит вхождения строки str; в противном случае возвращает false.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString str = "Peter Pan";
str.contains("peter", Qt::CaseInsensitive); // возвращает true
Смотрите также indexOf() и count().
Эта функция перегружает функцию contains().
Возвращает true, если строка содержит вхождение символа ch; в противном случае возвращает false.
Эта функция перегружает функцию contains().
Возвращает true, если для регулярного выражения rx есть соответствие где-то в этой строке; в противном случае возвращает false.
Эта функция перегружает функцию contains().
Возвращает true, если для регулярного выражения rx есть соответствие где-то в этой строке; в противном случае возвращает false.
Если соответствие найдено, то регулярное выражение rx будет содержать найденное соответствие (смотрите QRegExp::matchedLength, QRegExp::cap).
Эта функция была введена в Qt 4.5.
Возвращает количество (возможно, перекрывающихся) вхождений строки str в эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Смотрите также contains() и indexOf().
Эта функция перегружает функцию count().
Возвращает количество вхождений символа ch в строке.
Эта функция перегружает функцию count().
Возвращает количество найденных соответствий регулярного выражения rx в строке.
Эта функция подсчитывает перекрывающиеся соответствия, так что в примере ниже есть четыре экземпляра "ana" или "ama":
QString str = "banana and panama";
str.count(QRegExp("a[nm]a")); // возвращает 4
Эта функция перегружает функцию count().
То же, что и size().
Возвращает указатель на данные, хранящиеся в QString. Указатель можно использовать для доступа к символам, которые составляют строку, и их изменения. Для удобства данные завершаются символом '\0'.
Пример:
QString str = "Hello world"; QChar *data = str.data(); while (!data->isNull()) { qDebug() << data->unicode(); ++data; }
Заметьте, что указатель остаётся действительным до тех пор, пока строка не будет изменена другими средствами. Если нужен доступ только для чтения, то функция constData() работает быстрее, потому что в этом случае не требуется создавать полную копию данных.
Смотрите также constData() и operator[]().
Это перегруженная функция.
Возвращает итератор в стиле STL, указывающий на воображаемый символ после последнего символа в строке.
Смотрите также begin() и constEnd().
Эта функция перегружает функцию end().
Возвращает true, если строка заканчивается s; иначе возвращает false.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
QString str = "Bananas"; str.endsWith("anas"); // возвращает true str.endsWith("pple"); // возвращает false
Смотрите также startsWith().
Эта функция перегружает функцию endsWith().
Возвращает true, если строка заканчивается c; иначе возвращает false.
Эта функция перегружает функцию endsWith().
Присваивает каждому символу в строке значение ch. Если size отличен от -1 (значение по умолчанию), то размер строки предварительно изменяется на size.
Пример:
QString str = "Berlin"; str.fill('z'); // str == "zzzzzz" str.fill('A', 2); // str == "AA"
Смотрите также resize().
Возвращает QString, инициализированный первыми size символами 8-битной ASCII-строки str.
Если размер size равен -1 (по умолчанию), то он подсчитывается при помощи qstrlen(str).
Если при помощи QTextCodec::setCodecForCStrings() был установлен кодек, то он используется для преобразования str в Unicode; иначе эта функция делает то же самое, что и fromLatin1().
Смотрите также toAscii(), fromLatin1(), fromUtf8() и fromLocal8Bit().
Возвращает QString, инициализированный первыми size символами строки str в кодах Latin-1.
Если размер size равен -1 (по умолчанию), то он подсчитывается при помощи qstrlen(str).
Смотрите также toLatin1(), fromAscii(), fromUtf8() и fromLocal8Bit().
Возвращает QString, инициализированный первыми size символами 8-битной строки str.
Если размер size равен -1 (по умолчанию), то он подсчитывается при помощи qstrlen(str).
Для преобразования из Unicode используется QTextCodec::codecForLocale().
Смотрите также toLocal8Bit(), fromAscii(), fromLatin1() и fromUtf8().
Создаёт QString, используя первые size Unicode-символов из массива unicode. Данные из unicode не копируются. Вызывающий должен быть уверен, что unicode не будет удалён или изменён, пока существует QString (или его немодифицированная копия).
Любая попытка модификации QString или его копии приведёт к созданию полной копии данных, что гарантирует неизменность исходных данных.
Здесь приведён пример того, как мы можем использовать QRegExp на сырых данных в памяти без необходимости копирования данных в QString:
QRegExp pattern;
static const QChar unicode[] = {
0x005A, 0x007F, 0x00A4, 0x0060,
0x1009, 0x0020, 0x0020};
int size = sizeof(unicode) / sizeof(QChar);
QString str = QString::fromRawData(unicode, size);
if (str.contains(QRegExp(pattern))) {
// ...
}
Предупреждение: Строка, созданная с помощью fromRawData(), не оканчивается символом '\0', за исключением случаев, когда исходный массив содержит символ '\0' в позиции size. Это означает, что unicode() не вернёт нультерминальную строку (хотя utf16() сделает именно так, поскольку копирует сырые данные).
Смотрите также fromUtf16().
Возвращает копию строки str. Получаемая строка преобразуется в Unicode при помощи функции fromAscii().
Этот конструктор доступен только в том случае, если Qt сконфигурирован с включённой поддержкой совместимости с STL.
Смотрите также fromAscii(), fromLatin1(), fromLocal8Bit() и fromUtf8().
Возвращает копию строки str. Предполагается, что получаемая строка закодирована в utf16, если размер wchar_t равен 2 байтам (например, в Windows), и в ucs4, если размер wchar_t равен 4 байтам (в большинстве Unix-систем).
Этот метод доступен только в том случае, если Qt сконфигурирован с включённой поддержкой совместимости с STL.
Смотрите также fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8() и fromUcs4().
Возвращает QString, инициализированный первыми size символами Unicode-строки unicode (в кодах ISO-10646-UCS-4).
Если size равен -1 (по умолчанию), unicode должна завершаться 0.
Эта функция была введена в Qt 4.2.
Смотрите также toUcs4(), fromUtf16(), utf16(), setUtf16() и fromWCharArray().
Возвращает QString, инициализированный первыми size байтами строки str в кодах UTF-8.
Если размер size равен -1 (по умолчанию), то он подсчитывается при помощи qstrlen(str).
Смотрите также toUtf8(), fromAscii(), fromLatin1() и fromLocal8Bit().
Возвращает QString, инициализированный первыми size символами Unicode-строки unicode (в кодах ISO-10646-UTF-16).
Если size равен -1 (по умолчанию), unicode должна завершаться 0.
Эта функция проверяет Byte Order Mark (BOM). Если он отсутствует, применяется порядок байт хоста.
Эта функция сравнительно медленная. По возможности используйте QString(const ushort *, int).
QString делает полную копию данных Unicode.
Смотрите также utf16() и setUtf16().
Возвращает копию строки string, причём кодировка string зависит от размера wchar. Если wchar равен 4 байтам, то строка string интерпретируется как ucs-4, если wchar равен 2 байтам, то как ucs-2.
Если size равен -1 (по умолчанию), то строка string должна иметь завершающий 0.
Эта функция была введена в Qt 4.2.
Смотрите также fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4() и fromStdWString().
Возвращает индекс позиции первого вхождения строки str в этой строке, поиск осуществляется вперёд, начиная с позиции с индексом from. Возвращает -1, если str не найдена.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString x = "sticky question"; QString y = "sti"; x.indexOf(y); // возвращает 0 x.indexOf(y, 1); // возвращает 10 x.indexOf(y, 10); // возвращает 10 x.indexOf(y, 11); // возвращает -1
Если from равен -1, то поиск начинается с последнего символа; если он равен -2, то с предпоследнего, и т.д..
Смотрите также lastIndexOf(), contains() и count().
Возвращает индекс позиции первого вхождения строки str в этой строке, поиск осуществляется вперёд, начиная с позиции с индексом from. Возвращает -1, если str не найдена.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString x = "sticky question"; QString y = "sti"; x.indexOf(y); // возвращает 0 x.indexOf(y, 1); // возвращает 10 x.indexOf(y, 10); // возвращает 10 x.indexOf(y, 11); // возвращает -1
Если from равен -1, то поиск начинается с последнего символа; если он равен -2, то с предпоследнего, и т.д..
Эта функция была введена в Qt 4.5.
Смотрите также lastIndexOf(), contains() и count().
Эта функция перегружает функцию indexOf().
Возвращает индекс позиции первого вхождения символа ch в строке, поиск осуществляется вперёд, начиная с позиции с индексом from. Возвращает -1, если ch не может быть найден.
Эта функция перегружает функцию indexOf().
Возвращает индекс позиции первого соответствия регулярного выражения rx в строке, поиск осуществляется вперёд, начиная с позиции с индексом from. Возвращает -1, если соответствия rx не найдено.
Пример:
QString str = "the minimum";
str.indexOf(QRegExp("m[aeiou]"), 0); // возвращает 4
Эта функция перегружает функцию indexOf().
Возвращает индекс позиции первого соответствия регулярного выражения rx в строке, поиск осуществляется вперёд, начиная с позиции с индексом from. Возвращает -1, если соответствия rx не найдено.
Если соответствие найдено, то регулярное выражение rx будет содержать найденное соответствие (смотрите QRegExp::matchedLength, QRegExp::cap).
Пример:
QString str = "the minimum";
str.indexOf(QRegExp("m[aeiou]"), 0); // возвращает 4
Эта функция была введена в Qt 4.5.
Вставляет строку str в позицию по индексу position и возвращает ссылку на эту строку.
Пример:
QString str = "Meal";
str.insert(1, QString("ontr"));
// str == "Montreal"
Если position больше, чем size(), то массив будет сначала расширен с помощью resize().
Смотрите также append(), prepend(), replace() и remove().
Эта функция перегружает функцию insert().
Вставляет строку str в кодах Latin-1 в позицию по индексу position.
Эта функция перегружает функцию insert().
Вставляет первые size символов QChar из массива unicode в указанную позицию с индексом position в строке.
Эта функция перегружает функцию insert().
Вставляет ch в указанную позицию с индексом position в строке.
Возвращает true, если в строке нет символов; иначе возвращает false.
Пример:
QString().isEmpty(); // возвращает true QString("").isEmpty(); // возвращает true QString("x").isEmpty(); // возвращает false QString("abc").isEmpty(); // возвращает false
Смотрите также size().
Возвращает true, если строка нулевая; иначе возвращает false.
Пример:
QString().isNull(); // возвращает true QString("").isNull(); // возвращает false QString("abc").isNull(); // возвращает false
Qt делает различия между нулевой и пустой строками по историческим причинам. Для большинства приложений важно, содержит строка данные или нет, и это можно определить с помощью функции isEmpty().
Смотрите также isEmpty().
Возвращает индекс позиции последнего вхождения строки str в этой строке, поиск осуществляется назад, начиная с позиции с индексом from. Если from равен -1 (по умолчанию), то поиск начинается с последнего символа; если from равен -2, то с предпоследнего, и т.д. Возвращает -1, если str не найдена.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString x = "crazy azimuths"; QString y = "az"; x.lastIndexOf(y); // возвращает 6 x.lastIndexOf(y, 6); // возвращает 6 x.lastIndexOf(y, 5); // возвращает 2 x.lastIndexOf(y, 1); // возвращает -1
Смотрите также indexOf(), contains() и count().
Возвращает индекс позиции последнего вхождения строки str в этой строке, поиск осуществляется назад, начиная с позиции с индексом from. Если from равен -1 (по умолчанию), то поиск начинается с последнего символа; если from равен -2, то с предпоследнего, и т.д. Возвращает -1, если str не найдена.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString x = "crazy azimuths"; QString y = "az"; x.lastIndexOf(y); // возвращает 6 x.lastIndexOf(y, 6); // возвращает 6 x.lastIndexOf(y, 5); // возвращает 2 x.lastIndexOf(y, 1); // возвращает -1
Эта функция была введена в Qt 4.5.
Смотрите также indexOf(), contains() и count().
Эта функция перегружает функцию lastIndexOf().
Возвращает индекс позиции последнего вхождения символа ch, поиск осуществляется назад, начиная с позиции from.
Эта функция перегружает функцию lastIndexOf().
Возвращает индекс позиции последнего соответствия регулярного выражения rx в строке, поиск осуществляется назад, начиная с позиции с индексом from. Возвращает -1, если соответствия rx не найдено.
Пример:
QString str = "the minimum";
str.lastIndexOf(QRegExp("m[aeiou]")); // возвращает 8
Эта функция перегружает функцию lastIndexOf().
Возвращает индекс позиции последнего соответствия регулярного выражения rx в строке, поиск осуществляется назад, начиная с позиции с индексом from. Возвращает -1, если соответствия rx не найдено.
Если соответствие найдено, то регулярное выражение rx будет содержать найденное соответствие (смотрите QRegExp::matchedLength, QRegExp::cap).
Пример:
QString str = "the minimum";
str.lastIndexOf(QRegExp("m[aeiou]")); // возвращает 8
Эта функция была введена в Qt 4.5.
Возвращает подстроку, которая содержит n первых символов строки.
Строка будет возвращена полностью, если n больше, чем size(), или меньше, чем ноль.
QString x = "Pineapple";
QString y = x.left(4); // y == "Pine"
Смотрите также right(), mid() и startsWith().
Возвращает строку размером width, которая содержит исходную строку, дополненную символом fill.
Если truncate равно false и размер size() строки больше, чем width, то возвращается копия этой строки.
QString s = "apple";
QString t = s.leftJustified(8, '.'); // t == "apple..."
Если truncate равно true и размер size() строки больше, чем width, то возвращается копия строки, у которой символы после позиции width отсечены.
QString str = "Pineapple";
str = str.leftJustified(5, '.', true); // str == "Pinea"
Смотрите также rightJustified().
Возвращает ссылку на подстроку из n первых символов строки.
Если n больше, чем size(), или меньше, чем ноль, то будет возвращена ссылка на всю строку.
QString x = "Pineapple";
QStringRef y = x.leftRef(4); // y == "Pine"
Эта функция была введена в Qt 4.4.
Смотрите также left(), rightRef(), midRef() и startsWith().
Возвращает количество символов в этой строке. Эквивалентно size().
Смотрите также setLength().
Сравнивает s1 с s2 и возвращает целое число, меньшее, равное или большее нуля, если s1 меньше, равно или больше, чем s2, соответственно.
Результат сравнения зависит от локали и платформы. Используйте эту функцию для предоставления отсортированных строк пользователю.
В Mac OS X с Qt 4.3 эта функция производит сравнение в зависимости от значения опции "Порядок сортировки списков" ("Order for sorted lists") в панели "Региональные установки" ("International").
Смотрите также compare() и QTextCodec::locale().
Эта функция перегружает функцию localeAwareCompare().
Сравнивает эту строку с другой строкой other и возвращает целое число, меньшее, равное или большее нуля, если эта строка меньше, равна или больше другой строки other.
Результат сравнения зависит от локали и платформы. Используйте эту функцию для предоставления отсортированных строк пользователю.
Смотрите также localeAwareCompare(*this, other).
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию localeAwareCompare().
Сравнивает s1 с s2 и возвращает целое число, меньшее, равное или большее нуля, если s1 меньше, равно или больше, чем s2, соответственно.
Результат сравнения зависит от локали и платформы. Используйте эту функцию для предоставления отсортированных строк пользователю.
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию localeAwareCompare().
Сравнивает эту строку с другой строкой other и возвращает целое число, меньшее, равное или большее нуля, если эта строка меньше, равна или больше другой строки other.
Результат сравнения зависит от локали и платформы. Используйте эту функцию для предоставления отсортированных строк пользователю.
Смотрите также localeAwareCompare(*this, other).
Возвращает строку, которая содержит n символов этой строки, начиная с позиции с указанным индексом position.
Возвращает нулевую строку, если индекс позиции position превышает длину строки. Если в строке доступно меньше, чем n символов, начиная с заданной позиции position, или если n равно -1 (по умолчанию), то функция возвращает все доступные символы, начиная с указанной position.
Пример:
QString x = "Nine pineapples"; QString y = x.mid(5, 4); // y == "pine" QString z = x.mid(5); // z == "pineapples"
Смотрите также left() и right().
Возвращает ссылку на подстроку из n символов строки, начиная с указанной позиции position.
Если позиция position превышает длину строки, то будет возвращена пустая ссылка.
Если в строке доступно меньше, чем n символов, начиная с заданной позиции position, или если n равно -1 (по умолчанию), то функция возвращает все символы, начиная с указанной position.
Пример:
QString x = "Nine pineapples"; QStringRef y = x.midRef(5, 4); // y == "pine" QStringRef z = x.midRef(5); // z == "pineapples"
Эта функция была введена в Qt 4.4.
Смотрите также mid(), leftRef() и rightRef().
Возвращает строку в заданном режиме mode нормализации Unicode.
Это перегруженная функция.
Возвращает строку в заданном режиме mode нормализации Unicode, в соответствии с указанной версией version стандарта Unicode.
Возвращает строку, эквивалентную числу n по указанному основанию base.
Основание по умолчанию равно 10 и должно быть между 2 и 36. Для оснований, отличных от 10, n рассматривается как целое число без знака.
long a = 63; QString s = QString::number(a, 16); // s == "3f" QString t = QString::number(a, 16).toUpper(); // t == "3F"
Смотрите также setNum().
Возвращает строку, эквивалентную числу n, отформатированному в соответствии с указанным форматом format и точностью precision. Для получения подробной информации смотрите Форматы аргументов.
В отличие от QLocale::toString(), эта функция не обращает внимания на пользовательские настройки локали.
Смотрите также setNum() и QLocale::toString().
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Добавляет строку str к началу этой строки и возвращает ссылку на строку.
Пример:
QString x = "ship";
QString y = "air";
x.prepend(y);
// x == "airship"
Смотрите также append() и insert().
Эта функция перегружает функцию prepend().
Добавляет строку str в кодах Latin-1 к началу этой строки.
Эта функция перегружает функцию prepend().
Добавляет массив байт ba к началу этой строки. Массив байт преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию prepend().
Добавляет строку str к началу этой строки. Указатель на константный char преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию prepend().
Добавляет символ ch к началу этой строки.
Эта функция предназначена для совместимости с STL, добавляя полученную строку other в конец этой строки. Это эквивалентно append(other).
Смотрите также append().
Это перегруженная функция.
Добавляет данный символ ch в конец этой строки.
Эта функция предназначена для совместимости с STL, добавляя полученную строку other в начало этой строки. Это эквивалентно prepend(other).
Смотрите также prepend().
Это перегруженная функция.
Добавляет данный символ ch в начало этой строки.
Удаляет n символов из строки, начиная с позиции с индексом position, и возвращает ссылку на строку.
Если указанная позиция с индексом position находится в пределах строки, а position + n за пределами конца строки, то строка обрезается до указанной позиции position.
QString s = "Montreal";
s.remove(1, 4);
// s == "Meal"
Смотрите также insert() и replace().
Удаляет все вхождения символа ch в этой строке и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString t = "Ali Baba";
t.remove(QChar('a'), Qt::CaseInsensitive);
// t == "li Bb"
Это то же самое, что и replace(ch, "", cs).
Смотрите также replace().
Удаляет все вхождения указанной строки str в этой строке и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Это то же самое, что и replace(str, "", cs).
Смотрите также replace().
Удаляет все вхождения регулярного выражения rx в эту строку и возвращает ссылку на строку. Например:
QString r = "Telephone";
r.remove(QRegExp("[aeiou]."));
// r == "The"
Смотрите также indexOf(), lastIndexOf() и replace().
Возвращает копию этой строки, повторенной заданное количество times раз.
Если количество повторов times меньше 1, то возвращается пустая строка.
Пример:
QString str("ab");
str.repeated(4); // возвращает "abababab"
Эта функция была введена в Qt 4.5.
Заменяет n символов, начиная с позиции с индексом position, строкой after и возвращает ссылку на эту строку.
Пример:
QString x = "Say yes!";
QString y = "no";
x.replace(4, 3, y);
// x == "Say no!"
Смотрите также insert() и remove().
Эта функция перегружает функцию replace().
Заменяет n символов, начиная с позиции с индексом position, первыми size символами QChar массива unicode и возвращает ссылку на эту строку.
Эта функция перегружает функцию replace().
Заменяет n символов, начиная с позиции с индексом position, символом after и возвращает ссылку на эту строку.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Пример:
QString str = "colour behaviour flavour neighbour";
str.replace(QString("ou"), QString("o"));
// str == "color behavior flavor neighbor"
Замечание: Заменяющий текст не проверяется заново после вставки.
Пример:
QString equis = "xxxxxx";
equis.replace("xx", "x");
// equis == "xxx"
Эта функция перегружает функцию replace().
Заменяет в этой строке каждое вхождение первых blen символов из before первыми alen символами из after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение символа ch в строке на after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение символа before символом after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Замечание: Текст не проверяется заново после замены.
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Замечание: Текст не проверяется заново после замены.
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Замечание: Текст не проверяется заново после замены.
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение символа c строкой after и возвращает ссылку на эту строку.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
Замечание: Текст не проверяется заново после замены.
Эта функция была введена в Qt 4.5.
Эта функция перегружает функцию replace().
Заменяет каждое вхождение регулярного выражения rx в строке на after. Возвращает ссылку на строку. Например:
QString s = "Banana";
s.replace(QRegExp("a[mn]"), "ox");
// s == "Boxoxa"
Для регулярных выражений, содержащих захватывающие скобки, вхождения \1, \2, ... в after заменяются на rx.cap(1), cap(2), ...
QString t = "A <i>bon mot</i>.";
t.replace(QRegExp("<i>([^<]*)</i>"), "\\emph{\\1}");
// t == "A \\emph{bon mot}."
Смотрите также indexOf(), lastIndexOf(), remove() и QRegExp::cap().
Попытка зарезервировать место в памяти размером, по крайней мере, size символов. Если вы знаете наперёд, насколько большой будет строка, вы можете вызвать эту функцию, и, если вы часто изменяете размер строки, то, возможно, получите лучшую производительность. Если size меньше, чем необходимо, то худшее, что может произойти, - это то, что QString будет немного медленнее.
Единственная цель этой функции - обеспечить оптимальное использование памяти в QString. Вообще, у вас крайне редко возникнет необходимость вызывать эту функцию. Если вы хотите изменить размер строки, вызывайте resize().
Эта функция полезна в коде, где необходимо создать длинную строку и желательно избежать повторного перераспределения. В этом примере мы хотим добавлять строки, пока истинно некоторое условие, и мы достаточно уверены, что размер достаточно большой, чтобы позволить себе использовать reserve():
QString result; int maxSize; bool condition; QChar nextChar; result.reserve(maxSize); while (condition) result.append(nextChar); result.squeeze();
Смотрите также squeeze() и capacity().
Устанавливает размер строки в size символов.
Если размер size больше, чем текущий размер, то строка увеличивается до size символов с добавлением дополнительных символов в конец. Новые символы ничем не инициализированы.
Если размер size меньше, чем текущий размер, то удаляются символы из конца строки.
Пример:
QString s = "Hello world"; s.resize(5); // s == "Hello" s.resize(8); // s == "Hello???" (где ? обозначает любой символ)
Если вы хотите добавить определённое количество одинаковых символов к строке, используйте не resize(), а operator+=() следующим образом:
QString t = "Hello";
t += QString(10, 'X');
// t == "HelloXXXXXXXXXX"
Если вы хотите увеличить строку до определённой длины и заполнить новые позиции определённым символом, используйте функцию leftJustified():
Если размер size отрицателен, то это эквивалентно передаче нуля.
QString r = "Hello";
r = r.leftJustified(10, ' ');
// r == "Hello "
Смотрите также truncate() и reserve().
Возвращает подстроку, которая содержит n последних символов строки.
Строка будет возвращена полностью, если n больше, чем size(), или меньше, чем ноль.
QString x = "Pineapple";
QString y = x.right(5); // y == "apple"
Смотрите также left(), mid() и endsWith().
Возвращает строку размером width, которая содержит символ-заполнитель fill, за которым следует строка. Например:
QString s = "apple";
QString t = s.rightJustified(8, '.'); // t == "...apple"
Если truncate равно false и размер size() строки больше, чем width, то возвращается копия этой строки.
Если truncate равно true и размер size() строки больше, чем width, то возвращается строка, усечённая в позиции width.
QString str = "Pineapple";
str = str.rightJustified(5, '.', true); // str == "Pinea"
Смотрите также leftJustified().
Возвращает ссылку на подстроку из n последних символов строки.
Если n больше, чем size(), или меньше, чем ноль, то будет возвращена ссылка на всю строку.
QString x = "Pineapple";
QStringRef y = x.rightRef(5); // y == "apple"
Эта функция была введена в Qt 4.4.
Смотрите также right(), leftRef(), midRef() и endsWith().
Эта функция возвращает часть строки.
Эта строка рассматривается как последовательность полей, разделённых символом sep. Возвращаемая строка содержит поля от позиции start до позиции end включительно. Если end не указан, то включаются все поля от позиции start до конца строки. При подсчёте слева направо поля нумеруются 0, 1, 2 и т.д., при подсчёте справа налево -1, -2 и т.д..
Аргумент flags может быть использован для влияния на некоторые аспекты поведения функции, например, необходимость учёта регистра, пропуска пустых полей и обработки первого и последнего разделителей; смотрите SectionFlags.
QString str; QString csv = "forename,middlename,surname,phone"; QString path = "/usr/local/bin/myapp"; // Первое поле пустое QString::SectionFlag flag = QString::SectionSkipEmpty; str = csv.section(',', 2, 2); // str == "surname" str = path.section('/', 3, 4); // str == "bin/myapp" str = path.section('/', 3, 3, flag); // str == "myapp"
Если начало start или конец end отрицательные, то подсчёт полей ведётся с конца строки, самое правое поле имеет номер -1, перед ним - номер -2 и т.д.
str = csv.section(',', -3, -2); // str == "middlename,surname" str = path.section('/', -1); // str == "myapp"
Смотрите также split().
Эта функция перегружает функцию section().
QString str; QString data = "forename**middlename**surname**phone"; str = data.section("**", 2, 2); // str == "surname" str = data.section("**", -3, -2); // str == "middlename**surname"
Смотрите также split().
Эта функция перегружает функцию section().
Эта строка рассматривается как последовательность полей, разделённых регулярным выражением reg.
QString line = "forename\tmiddlename surname \t \t phone"; QRegExp sep("\\s+"); str = line.section(sep, 2, 2); // s == "surname" str = line.section(sep, -3, -2); // s == "middlename surname"
Предупреждение: Использование этой версии функции, с QRegExp, более дорогое, чем перегруженных версий со строкой и символом.
Смотрите также split() и simplified().
Устанавливает строку в печатное представление числа n по основанию base и возвращает ссылку на строку.
Основание по умолчанию равно 10 и должно быть между 2 и 36. Для оснований, отличных от 10, n рассматривается как целое число без знака.
QString str;
str.setNum(1234); // str == "1234"
Форматирование всегда использует QLocale::C, например, English/UnitedStates. Для получения локализованного строкового представления числа используйте QLocale::toString() с соответствующей локалью.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Это перегруженная функция.
Устанавливает строку в печатное представление числа n, отформатированного в соответствии с заданным форматом format и точностью precision, и возвращает ссылку на строку.
format может быть 'f', 'F', 'e', 'E', 'g' или 'G' (смотрите документацию на функцию arg() для получения объяснений по форматам).
В отличие от QLocale::toString() эта функция не обращает внимания на пользовательские настройки локали.
Это перегруженная функция.
Устанавливает строку в печатное представление числа n, отформатированного в соответствии с заданным форматом format и точностью precision, и возвращает ссылку на строку.
Изменяет размер строки до size символов и копирует unicode в строку.
Если unicode равен 0, то ничего не копируется, но размер всё равно изменяется на size.
Смотрите также unicode() и setUtf16().
Изменяет размер строки до size символов и копирует unicode в строку.
Если unicode равен 0, то ничего не копируется, но размер всё равно изменяется на size.
Заметьте, что в отличие от fromUtf16() эта функция не учитывает BOM и возможный разный порядок байт.
Смотрите также utf16() и setUnicode().
Возвращает строку, у которой пробельные символы удалены в начале и в конце, а все последовательные пробельные символы заменены одиночным пробелом.
Пробельными символами являются любые символы, для которых QChar::isSpace() возвращает true. Они включают ASCII символы '\t', '\n', '\v', '\f', '\r' и ' '.
Пример:
QString str = " lots\t of\nwhitespace\r\n ";
str = str.simplified();
// str == "lots of whitespace";
Смотрите также trimmed().
Возвращает количество символов в этой строке.
Последний символ в строке находится в позиции size() - 1. Кроме того, QString гарантированно всегда содержит в позиции size() символ '\0', так что вы можете использовать значение, возвращаемое функциями data() и constData() в качестве аргумента для функций, требующих строки, оканчивающиеся нулем ('\0').
Пример:
QString str = "World"; int n = str.size(); // n == 5 str.data()[0]; // возвращает 'W' str.data()[4]; // возвращает 'd' str.data()[5]; // возвращает '\0'
Смотрите также isEmpty() и resize().
Разделяет строку на подстроки по разделителю sep и возвращает список этих строк. Если sep не встретился нигде в строке, split() вернёт список, состоящий из одного элемента, содержащего всю строку.
cs указывает, должен ли sep быть регистрозависимым или нет.
Если behavior равно QString::SkipEmptyParts, то пустые записи не включаются в результат. По умолчанию, пустые записи сохраняются.
Пример:
QString str = "a,,b,c"; QStringList list1 = str.split(","); // list1: [ "a", "", "b", "c" ] QStringList list2 = str.split(",", QString::SkipEmptyParts); // list2: [ "a", "b", "c" ]
Смотрите также QStringList::join() и section().
Это перегруженная функция.
Это перегруженная функция.
Разделяет строку на подстроки по разделителям, соответствующим регулярному выражению rx, и возвращает список этих строк. Если rx не соответствует ничему в строке, то split() вернёт список, состоящий из одного элемента, содержащего всю строку.
Вот пример, где мы извлекаем слова из предложения, используя один или более пробельный символ в качестве разделителя:
QString str;
QStringList list;
str = "Some text\n\twith strange whitespace.";
list = str.split(QRegExp("\\s+"));
// list: [ "Some", "text", "with", "strange", "whitespace." ]
Вот аналогичный пример, но на этот раз мы используем в качестве разделителя любую последовательность символов, не входящих в слова:
str = "This time, a normal English sentence.";
list = str.split(QRegExp("\\W+"), QString::SkipEmptyParts);
// list: [ "This", "time", "a", "normal", "English", "sentence" ]
Вот третий пример, в котором мы используем утверждение нулевой длины, \b (граница слова), для разделения строки на чередующуюся последовательность лексем "не-слово" и "слово":
str = "Now: this sentence fragment.";
list = str.split(QRegExp("\\b"));
// list: [ "", "Now", ": ", "this", " ", "sentence", " ", "fragment", "." ]
Смотрите также QStringList::join() и section().
Безопасно создаёт отформатированную строку из строки формата cformat и произвольного списка аргументов.
Управляющая последовательность %lc ожидает unicode-символ типа ushort (как возвращает QChar::unicode()). Управляющая последовательность %ls ожидает указатель на нуль-терминальный массив unicode-символов типа ushort (как возвращает QString::utf16()).
Замечание: Эта функция ожидает строку в кодах UTF-8 для %s и в кодах Latin-1 для строки формата.
Строка формата поддерживает большинство спецификаторов преобразования, обеспечиваемых printf() в стандартной библиотеке C++. Она не учитывает модификаторы длины (например, h для short, ll для long long). Если они вам необходимы, используйте вместо этого стандартный snprintf():
size_t BufSize; char buf[BufSize]; ::snprintf(buf, BufSize, "%lld", 123456789LL); QString str = QString::fromAscii(buf);
Предупреждение: Мы не рекомендуем использовать QString::sprintf() в новом коде Qt. Вместо этого рассмотрите возможность использования QTextStream или arg(), оба из которых легко и безопасно с точки зрения типов поддерживают Unicode-строки. Вот пример, который использует QTextStream:
QString result;
QTextStream(&result) << "pi = " << 3.14;
// result == "pi = 3.14"
Для перевода, особенно если строки содержат несколько управляющих последовательностей, вы должны рассмотреть возможность использования вместо этого функции arg(). Это позволяет оставить под контролем переводчика порядок замещающих элементов.
Смотрите также arg().
Освобождает любую память, не требующуюся для хранения символьных данных.
Единственная цель этой функции - обеспечить оптимальное использование памяти в QString. Вообще, у вас крайне редко возникнет необходимость вызывать эту функцию.
Смотрите также reserve() и capacity().
Возвращает true, если строка начинается с s; иначе возвращает false.
Если cs равен Qt::CaseSensitive (по умолчанию), то поиск происходит с учётом регистра; в противном случае поиск регистронезависимый.
QString str = "Bananas"; str.startsWith("Ban"); // возвращает true str.startsWith("Car"); // возвращает false
Смотрите также endsWith().
Эта функция перегружает функцию startsWith().
Эта функция перегружает функцию startsWith().
Возвращает true, если строка начинается с c; иначе возвращает false.
Возвращает 8-битное ASCII-представление строки как QByteArray.
Если при помощи QTextCodec::setCodecForCStrings() был установлен кодек, то он используется для преобразования Unicode в 8-битные символы; иначе эта функция делает то же самое, что и toLatin1().
Смотрите также fromAscii(), toLatin1(), toUtf8(), toLocal8Bit() и QTextCodec.
Возвращает приведённый к одному регистру эквивалент строки. Для большинства Unicode-символов это тоже самое, что и toLower().
Возвращает строку, преобразованную в значение типа double.
Возвращает 0.0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
QString str = "1234.56";
double val = str.toDouble(); // val == 1234.56
В значения типа double могут быть преобразованы различные строковые представления чисел с плавающей точкой:
bool ok;
double d;
d = QString( "1234.56e-02" ).toDouble(&ok); // ok == true, d == 12.3456
Эта функция пытается интерпретировать строку в соответствии с текущей локалью. Текущая локаль определяется из системы при запуске приложения и может быть изменена путём вызова QLocale::setDefault(). Если строка не может быть интерпретирована в соответствии с текущей локалью, то эта функция возвращается к локали "C".
QLocale::setDefault(QLocale::C); d = QString( "1234,56" ).toDouble(&ok); // ok == false d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56 QLocale::setDefault(QLocale::German); d = QString( "1234,56" ).toDouble(&ok); // ok == true, d == 1234.56 d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56
Из-за неоднозначности между десятичной точкой и разделителем групп разрядов в различных локалях эта функция не обрабатывает разделители групп разрядов. Если вам необходимо преобразовать такое число, смотрите QLocale::toDouble().
QLocale::setDefault(QLocale::C);
d = QString( "1234,56" ).toDouble(&ok); // ok == false
Смотрите также number(), QLocale::setDefault(), QLocale::toDouble() и trimmed().
Возвращает строку, преобразованную в значение типа float.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true. Возвращает 0.0, если преобразование не удалось.
Пример:
QString str1 = "1234.56"; str1.toFloat(); // возвращает 1234.56 bool ok; QString str2 = "R2D2"; str2.toFloat(&ok); // возвращает 0.0, устанавливает ok в false
Смотрите также number(), toDouble() и toInt().
Возвращает строку, преобразованную в значение типа int, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; int hex = str.toInt(&ok, 16); // hex == 255, ok == true int dec = str.toInt(&ok, 10); // dec == 0, ok == false
Смотрите также number(), toUInt() и toDouble().
Возвращает Latin-1 представление строки как QByteArray. Возвращаемый массив байт не определён, если строка содержит не Latin1 символы.
Смотрите также fromLatin1(), toAscii(), toUtf8(), toLocal8Bit() и QTextCodec.
Возвращает локальное 8-битное представление строки как QByteArray. Возвращаемый массив байт не определён, если строка содержит символы, не поддерживаемые локальной 8-битной кодировкой.
Для преобразования из Unicode используется QTextCodec::codecForLocale().
Смотрите также fromLocal8Bit(), toAscii(), toLatin1(), toUtf8() и QTextCodec.
Возвращает строку, преобразованную в значение типа long, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; long hex = str.toLong(&ok, 16); // hex == 255, ok == true long dec = str.toLong(&ok, 10); // dec == 0, ok == false
Смотрите также number(), toULong() и toInt().
Возвращает строку, преобразованную в значение типа long long, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; qint64 hex = str.toLongLong(&ok, 16); // hex == 255, ok == true qint64 dec = str.toLongLong(&ok, 10); // dec == 0, ok == false
Смотрите также number(), toULongLong() и toInt().
Возвращает копию строки в нижнем регистре.
QString str = "Qt by NOKIA";
str = str.toLower(); // str == "qt by nokia"
Смотрите также toUpper().
Возвращает строку, преобразованную в значение типа short, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; short hex = str.toShort(&ok, 16); // hex == 255, ok == true short dec = str.toShort(&ok, 10); // dec == 0, ok == false
Смотрите также number(), toUShort() и toInt().
Возвращает объект std::string с данными, содержащимися в этом QString. Данные в кодировке Unicode конвертируются в 8-битные символы с помощью функции toAscii().
Этот оператор в основном используется для передачи QString в функцию, которая принимает объект std::string.
Если в QString содержатся не ASCII символы в кодировке Unicode, использование этого оператора может привести к потере информации, так как эта реализация вызывает toAscii().
Этот оператор доступен только в том случае, если Qt сконфигурирован с включённой поддержкой совместимости с STL.
Смотрите также toAscii(), toLatin1(), toUtf8() и toLocal8Bit().
Возвращает объект std::wstring с данными, содержащимися в этом QString. std::wstring кодируется в utf16 на тех платформах, на которых размер wchar_t равен 2 байтам (например, windows), и в ucs4 на тех платформах, на которых размер wchar_t равен 4 байтам (большинство Unix-систем).
Этот оператор в основном используется для передачи QString в функцию, которая принимает объект std::wstring.
Этот оператор доступен только в том случае, если Qt сконфигурирован с включённой поддержкой совместимости с STL.
Смотрите также utf16(), toAscii(), toLatin1(), toUtf8() и toLocal8Bit().
Возвращает строку, преобразованную в значение типа unsigned int, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; uint hex = str.toUInt(&ok, 16); // hex == 255, ok == true uint dec = str.toUInt(&ok, 10); // dec == 0, ok == false
Смотрите также number() и toInt().
Возвращает строку, преобразованную в значение типа unsigned long, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; ulong hex = str.toULong(&ok, 16); // hex == 255, ok == true ulong dec = str.toULong(&ok, 10); // dec == 0, ok == false
Смотрите также number().
Возвращает строку, преобразованную в значение типа unsigned long long, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; quint64 hex = str.toULongLong(&ok, 16); // hex == 255, ok == true quint64 dec = str.toULongLong(&ok, 10); // dec == 0, ok == false
Смотрите также number() и toLongLong().
Возвращает строку, преобразованную в значение типа unsigned short, используя систему счисления по основанию base, которая по умолчанию равна 10 и может быть любым числом от 2 до 36 или 0. Возвращает 0, если преобразование не удалось.
Если во время преобразования возникает ошибка, то *ok устанавливается в false; в противном случае *ok будет установлен в true.
Если основание base равно 0, то используются соглашения языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в остальных случаях используется основание 10.
Пример:
QString str = "FF"; bool ok; ushort hex = str.toUShort(&ok, 16); // hex == 255, ok == true ushort dec = str.toUShort(&ok, 10); // dec == 0, ok == false
Смотрите также number() и toShort().
Возвращает UCS-4 представление строки как QVector<uint>.
Эта функция была введена в Qt 4.2.
Смотрите также fromUtf8(), toAscii(), toLatin1(), toLocal8Bit(), QTextCodec, fromUcs4() и toWCharArray().
Возвращает копию строки в верхнем регистре.
QString str = "TeXt";
str = str.toUpper(); // str == "TEXT"
Смотрите также toLower().
Возвращает UTF-8 представление строки как QByteArray.
Смотрите также fromUtf8(), toAscii(), toLatin1(), toLocal8Bit() и QTextCodec.
Заполняет массив array данными, содержащимися в этом объекте QString. Массив кодируется в utf16 на тех платформах, на которых размер wchar_t равен 2 байтам (например, windows), и в ucs4 на тех платформах, на которых размер wchar_t равен 4 байтам (большинство Unix-систем).
Массив array должен быть выделен вызывающей стороной и содержать достаточно места для хранения полной строки (выделения массива той же длины, что и строка, всегда достаточно).
Возвращает фактическую длину строки в массиве array.
Замечание: Эта функция не добавляет нулевой символ в массив.
Эта функция была введена в Qt 4.2.
Смотрите также utf16(), toUcs4(), toAscii(), toLatin1(), toUtf8(), toLocal8Bit() и toStdWString().
Возвращает строку, у которой в начале и в конце удалены пробельные символы.
Пробельными символами являются любые символы, для которых QChar::isSpace() возвращает true. Они включают ASCII символы '\t', '\n', '\v', '\f', '\r' и ' '.
Пример:
QString str = " lots\t of\nwhitespace\r\n ";
str = str.trimmed();
// str == "lots\t of\nwhitespace"
В отличие от simplified(), trimmed() удаляет и одиночные пробельные символы.
Смотрите также simplified().
Обрезает строку в позиции с указанным индексом position.
Если указанная позиция с индексом position находится за пределами конца строки, то ничего не происходит.
Пример:
QString str = "Vladivostok";
str.truncate(4);
// str == "Vlad"
Если position отрицателен, то это эквивалентно передаче нуля.
Смотрите также chop(), resize() и left().
Возвращает нультерминальное Unicode-представление строки. Результат остаётся допустимым, пока строка не изменена.
Смотрите также setUnicode() и utf16().
Возвращает QString как нультерминальный массив unsigned shorts. Результат остаётся допустимым, пока строка не изменена.
Возвращаемая строка имеет порядок байт хоста.
Смотрите также setUtf16() и unicode().
Эквивалентно методу sprintf(), но получает va_list ap вместо списка аргументов-переменных. Смотрите документацию по sprintf() для получения описания cformat.
Этот метод не вызывает макрос va_end, за вызов va_end для ap отвечает вызывающая сторона.
Смотрите также sprintf().
Возвращает true, если эта строка не эквивалентна строке other; иначе возвращает false.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Эта функция перегружает функцию operator!=().
Эта функция перегружает функцию operator!=().
Массив байт other преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator!=().
Указатель other на константный char преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Добавляет строку other в конец этой строки и возвращает ссылку на эту строку.
Пример:
QString x = "free";
QString y = "dom";
x += y;
// x == "freedom"
Обычно, это очень быстрая операция (занимающая постоянное время), потому что QString резервирует в памяти дополнительное место после строковых данных, чтобы иметь возможность не перераспределять память каждый раз, когда требуется увеличить массив.
Смотрите также append() и prepend().
Эта функция перегружает функцию operator+=().
Добавляет строку str в кодах Latin-1 к этой строке.
Эта функция перегружает функцию operator+=().
Добавляет массив байт ba к этой строке. Массив байт преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator+=().
Добавляет строку str к этой строке. Указатель на константный char преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator+=().
Добавляет часть строки, на которую ссылается str, к этой строке.
Эта функция перегружает функцию operator+=().
Добавляет символ ch к этой строке. Символ преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить эту функцию, объявив макрос QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator+=().
Добавляет символ ch к строке.
Возвращает true, если эта строка лексически меньше, чем строка other; в противном случае возвращает false.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Эта функция перегружает функцию operator<().
Эта функция перегружает функцию operator<().
Массив байт other преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator<().
Указатель other на константный char преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Возвращает true, если эта строка лексически меньше или равна строке other; в противном случае возвращает false.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Эта функция перегружает функцию operator<=().
Эта функция перегружает функцию operator<=().
Массив байт other преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator<=().
Указатель other на константный char преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Присваивает other этой строке и возвращает ссылку на эту строку.
Эта функция перегружает функцию operator=().
Присваивает Latin-1 строку str этой строке.
Эта функция перегружает функцию operator=().
Присваивает ba этой строке. Массив байт преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator=().
Присваивает str этой строке. Указатель на константный char преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator=().
Присваивает символ ch этой строке. Символ преобразуется в Unicode при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator=().
Делает строку содержащей один символ ch.
Возвращает true, если строка other равна этой строке; в противном случае возвращает false.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Эта функция перегружает функцию operator==().
Эта функция перегружает функцию operator==().
Массив байт other преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator==().
Указатель other на константный char преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Возвращает true, если эта строка лексически больше, чем строка other; в противном случае возвращает false.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Эта функция перегружает функцию operator>().
Эта функция перегружает функцию operator>().
Массив байт other преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator>().
Указатель other на константный char преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Возвращает true, если эта строка лексически больше или равна строке other; в противном случае возвращает false.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Эта функция перегружает функцию operator>=().
Эта функция перегружает функцию operator>=().
Массив байт other преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Эта функция перегружает функцию operator>=().
Указатель other на константный char преобразуется в QString при помощи функции fromAscii().
Вы можете отключить этот оператор, объявив макрос QT_NO_CAST_FROM_ASCII перед компиляцией приложения. Это может быть полезно, если вы, например, хотите удостовериться, что все видимые пользователем строки проходят через QObject::tr().
Возвращает символ в указанной позиции position в строке как изменяемую ссылку.
Пример:
QString str; if (str[0] == QChar('?')) str[0] = QChar('_');
Возвращаемое значение имеет тип QCharRef, вспомогательный класс для QString. Когда вы получаете объект типа QCharRef, вы можете использовать его так же, как если бы он был QChar &. Если вы присваиваете ему, то присваивание будет применяться к символу в QString, на который вы получили ссылку.
Смотрите также at().
Эта функция перегружает функцию operator[]().
Эта функция перегружает функцию operator[]().
Возвращает символ в указанной позиции position в строке как изменяемую ссылку. Эквивалентно at(position).
Эта функция перегружает функцию operator[]().
Возвращает true, если s1 не равно s2; в противном случае возвращает false.
При s1 != 0 это эквивалентно compare( s1, s2 ) != 0. Заметьте, что ни одна строка не будет равна s1, являющейся 0.
Смотрите также QString::compare().
Возвращает строку, которая является результатом конкатенации s1 и s2.
Возвращает строку, которая является результатом конкатенации s1 и s2 (s2 преобразуется в Unicode при помощи функции QString::fromAscii()).
Смотрите также QString::fromAscii().
Возвращает строку, которая является результатом конкатенации s1 и s2 (s1 преобразуется в Unicode при помощи функции QString::fromAscii()).
Смотрите также QString::fromAscii().
Возвращает строку, которая является результатом конкатенации символа ch и строки s.
Возвращает строку, которая является результатом конкатенации строки s и символа ch.
Возвращает true,если s1 лексически меньше, чем s2; в противном случае возвращает false. При s1 != 0 это эквивалентно compare(s1, s2) < 0.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Смотрите также QString::compare().
Записывает заданную строку string в указанный поток stream.
Смотрите также Формат операторов QDataStream.
Возвращает true, если s1 лексически меньше или равна s2; в противном случае возвращает false. При s1 != 0 это эквивалентно compare(s1, s2) <= 0.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью QString::localeAwareCompare().
Смотрите также QString::compare().
Эта функция перегружает функцию operator==().
Возвращает true, если s1 равно s2; в противном случае возвращает false. Заметьте, что ни одна строка не будет равна s1, являющейся 0.
Эквивалентно s1 != 0 && compare(s1, s2) == 0.
Смотрите также QString::compare().
Возвращает true, если s1 лексически больше, чем s2; в противном случае возвращает false. Эквивалентно compare(s1, s2) > 0.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Смотрите также QString::compare().
Возвращает true, если s1 лексически больше или равна s2; в противном случае возвращает false. При s1 != 0 это эквивалентно compare(s1, s2) >= 0.
Сравнение базируется исключительно на числовых Unicode-значениях символов массива и проводится очень быстро, но не всегда соответствует желаниям человека. Рассмотрите сортировку строк пользовательского интерфейса с помощью localeAwareCompare().
Считывает строку из указанного потока stream в заданную строку string.
Смотрите также Формат операторов QDataStream.
Отключает автоматическое преобразование из 8-битной строки (char *) в Unicode-строку QStrings
Смотрите также QT_NO_CAST_TO_ASCII и QT_NO_CAST_FROM_BYTEARRAY.
Отключает автоматическое преобразование из QString в 8-битную ASCII-строку (char *)
Смотрите также QT_NO_CAST_FROM_ASCII и QT_NO_CAST_FROM_BYTEARRAY.
Авторские права © 2010 Nokia Corporation и/или её дочерние компании | Торговые марки | Qt 4.6.4 |
Попытка перевода Qt документации. Если есть желание присоединиться, или если есть замечания или пожелания, то заходите на форум: Перевод Qt документации на русский язык... Люди внесшие вклад в перевод: Команда переводчиков |