Занимался я сегодня написанием некоторого демонстрационно-тестового приложения с использованием Qt . Приложение это должно выполнять роль GUI-обертки над объектами некой специализированной библиотеки, которую я написал в boost для некоторой прикладной области.

Работа выполняется в Linux. Дистрибутив Ubuntu 11.10. Локаль - UTF-8.

И вот возникла у меня проблема. Средствами boost::system::error_code , в ядре моей библиотеки формировалось некоторое локализованное сообщение (т.е. на русском языке), которое мне понадобилось отобразить средствами Qt в экземпляре класса QTextEdit .

Вообще, надо бы давно запретить использование национальных языков в системных сообщениях. Однако, видимо, это кому-то кажется недемократичным, поэтому программисты ежедневно тысячами подрываются на этих проблемах и мы постоянно в готовых приложениях сталкиваемся с кракозябрами там, где могли бы прочитать нормальный английский текст. Ведь в чем проблема? Домохозяйки не удосуживаются читать даже сообщения прикладного уровня, и представить домохозяйку, которая поймет, что надо делать прочитав системное сообщение из сетевой подсистемы ядра типа "Адрес уже используется" на родном языке, мне кажется невероятным. А раз это не для домохозяйки, то зачем усложнять жизнь специалистам, которые все поголовно умеют читать по английски? К этому еще можно добавить проблему некорректных переводов. Понятно, вопрос риторический. Однако, хочется высказаться.

На самом деле проблемы я не понял и был крайне удивлен, когда преобразовав полученное сообщение из std::string в QString и выведя его потом в окно редактора я увидел кракозябры. Действительно. В чем может быть проблема? Если бы я, не дай бог, работал под Windows, то удивляться бы было не чему. Давно не интересовался как там дела сейчас, но во времена Windows XP меня веселило три одновременно используемые кодовые страницы в русских версиях операционной системы. Вот уж действительно, не операционная система а система заплаток. Но откуда могла взяться проблема в Linux? Если в ней, в используемой мной сборке, используется одна кодовая страница UTF-8 во всех подсистемах ядра и пользовательского пространства.

Проблема решется просто. Приведу ниже максимально подробный вариант решения с комментариями.

QTextCodec *codec = QTextCodec::codecForName("UTF8"); if (codec) { std::string str = boost_lib->getLastError(); // Get string from a boost library QByteArray ba(str.c_str()); // Convert to QByteArray QString msg = codec->toUnicode(ba); // Qt magic !!! m_pteLog->append(msg); // Append msg to a QTextEdit object }

В общем, заплатку я нашел, но в проблеме разбираться не стал. Видимо, по умолчанию, текст получаемый в Qt из строковых однобайтовых типов воспринимаются в кодировке Latin1, поэтому и возникала, в моем случае, неприятная неправильная перекодировка.

В заключении этой короткой заметки я бы хотел выразить надежду, что если кто-нибудь из читателей знает подробности затрагиваемого здесь механизма трансляции кодов символов, то пусть он его объяснит в комментариях или письмом мне, а я сделаю дополнение.

Обычные строки С довольно просты в использовании, но работать с ними не очень удобно в ряде случаев. Один из них, это поддержка выбора кодировок для текста. Ведь, как известно, существует много разных стандартов кодирования символов текста, которые отличаются поддержкой разного диапазона кодируемых символов.

В Qt для работы со строками есть мощный и специализированный класс - QString . Он имеет поддержку Unicode, возможность преобразования текста между разными кодировками и в обычные строки С и std::string . А также он имеет хорошее быстродействие и богатый набор инструментов для работы. Поддержка Unicode позволяет работать с текстом на любом языке мира, что очень важно при локализации графического интерфейса программы.

Рассмотрим методы работы с текстовыми строками в Qt . Перед началом работы с текстом в Qt нужно подключить файл описания QString :

#include

Как и почти для всех классов Qt , название класса совпадает с названием файла описания класса, который необходимо подключить с помощью директивы #include .

Существует большое количество разных способов добавления строк и символов к существующей строке:

QString lMainStr = " string "; // lMainStr == " string " lMainStr += " "; // lMainStr == " string " (lMainStr += " is ") += " "; // lMainStr == " string is " QString lHelperStr1 (" composed "); lMainStr += lHelperStr1; // lMainStr == " string is composed" QString lHelperStr2 = + " " +QString(" from ") + " "; lMainStr.append (lHelperStr2); // lMainStr == " string is composited from " lMainStr.push_back (" fragments "); // lMainStr == " string is composited from fragments " lMainStr.prepend (" This "); // lMainStr == "This string is composited from fragments " lMainStr.insert (lMainStr.length (), "."); // lMainStr == "This string is composited from fragments." lMainStr += QString(2, "."); // lMainStr == "This string is composited from fragments..." lMainStr= lMainStr.rightJustified (lMainStr.length () + 8, " "); // lMainStr=="This string is composited from fragments..."

Также есть возможность выделения части строки либо разделения её на части:

QString lQuote= "This is sentence one. This is sentence two. "; //Новая строка из пяти символов QString lFragment1 = lQuote.left (5); // lFragment1 == "This " qDebug () << " lFragment1 is: " << lFragment1; //Первое предложение: Все символы до первой точки QString lSentence= lQuote.section (".", 0, 0); qDebug () << " lSentenceis: " << lSentence; // lsentence == "This is sentence one" //Список слов в строке QStringList lWordsList = lSentence.split (" ", QString::SkipEmptyParts); qDebug () << lWordsList; // lWordsList == (" This ", " is ", " sentence ", "one ", "This " , // " is ", " sentence ", " two ")

Для проверки на пустую строку используют метод isEmpty() . Его не следует путать с методом isNull() , который возвращает значение true только для ещё не инициализированной строки. Например:

QString().isNull (); // true (нулевая строка) QString().isEmpty (); // true (нулевая строка тоже пустая) QString("").isNull (); // false (пустая строка не является нулевой) QString("").isEmpty (); // true QString("abc").isNull (); // false QString("abc").isEmpty (); // false

QString имеет инструменты для преобразования из std::string и наоборот. Например:

QString lQtstringInitial = " I am a standard STL string. "; std::string lStdstring = lQtstringInitial.toStdString (); QString lQtString = QString::fromStdString (lStdString);

Также QString имеет средства для работы с числовой информацией:

//преобразование целого числа в строку int x = 16; QString lXStr = QString::number (x); // x = 7; lXStr = 7 //преобразование строки в целое число int y = lXStr.toInt (); //преобразование дробного числа в строку double teta = 12099.10012021210102109991; QString lTetaStr = QString::number (teta); // lTetaStr == 12099.1 lTetaStr.setNum (teta); // lTetaStr == 12099.1 //вывод с 4-мя знаками после запятой lTetaStr = QString::number (teta, "f", 4); // lTetaStr == 12099.1001 //форматирование с использованием символа "e" lTetaStr = QString::number (teta, "e"); // lTetaStr == 1.209910e+04 //Запись числа в строку в разных системах счисления lXStr = QString("int %1 is %L2 in decimal system, %L3 in binary system, and % L4 in hexadecimal") .arg(x) .arg(x, 0, 10) .arg(x, 0, 2) .arg(x, 0, 16);

Для работы со списком строк в Qt предусмотрен специализированный тип QStringList. QStringList относят к контейнерным классам Qt . Подробнее классы-контейнеры мы рассмотрим в следующем параграфе.

Для демонстрации того, что работа с другими контейнерами может быть организована аналогично, изменим только наполнение метода doFile() . В показанном ниже коде вводимые пользователем строки вида "ключ:значение", где "ключ" – целое число, а "значение" – строка, записываются в мультихэш (ассоциативный массив, в котором одному ключу может соответствовать несколько значений).

Полученный мультихэш выводится в консоль отладки. В реальной задаче после его формирования можно выполнять любые требуемые действия с данными, например, получить список всех значений, соответствующих ключу "0", мы можем так:

QList lst=hash.values(0);

Пример пользовательского ввода для формирования хэша:

1:345 1 2 3:44 1:567 1:789 string

И вывод в отладочной консоли QT для него:

Element: "1" Element: "1:345" Element: "1:567" Element: "1:789" Element: "2" Element: "3:44" Element: "string" Key= 0 Value= "1" Key= 1 Value= "2" Key= 1 Value= "789" Key= 1 Value= "567" Key= 1 Value= "345" Key= 2 Value= "string" Key= 3 Value= "44"

Вот изменённый метод doFile() , также длинным комментарием пояснено первое регулярное выражение:)

Void Widget::doFile(void) { QString String = this->textEdit->toPlainText(); QStringList list = String.split("\n"); list.removeDuplicates(); //Убрали дублирующие друг друга строки list.sort(Qt::CaseInsensitive);//Отсортировали с игнорированием регистра букв QRegExp regExp("^(?!\\s*$).+"); //^ (?! \\s * $) .+ //нач негативная разделитель ноль кон любой символ // проверка или более хотя бы один //Получается: //"если в строке есть хоть один символ - не надо разделителей слева от него" list = list.filter(regExp); //убрали строки только из разделителей list.replaceInStrings(QRegularExpression("\\s+")," "); //убрали лишние разделители между словами list.replaceInStrings(QRegularExpression("^\\s+|\\s+$"),""); //убрали лишние разделители в начале или конце строк //Пользовательская часть виджета QMultiHash hash; //Ключ - число, значения - строки QStringList::iterator it = list.begin(); int key=0; //Ключ для элементов, которым его не дал пользователь for (;it!=list.end();++it) { //Пройти по списку элементов "ключ:значение" QStringList item = (*it).split(":",QString::SkipEmptyParts); //разбить элемент по разделителю ":" if (item.size()<2) hash.insertMulti(key++,item.at(0)); else hash.insertMulti(item.at(0).toInt(),item.at(1)); //Добавили в хэш ключ (наш или заданный пользователем) и значение qDebug() << "Element: " << (*it); } //Вывести в консоль отладки мультихэш QMultiHash::iterator i = hash.begin(); for (;i!=hash.end();++i) qDebug() << "Key=" << i.key() << "Value=" << i.value(); //конец пользовательской части this->textEdit->clear(); this->textEdit->append(list.join("\n")); }

Символьные строки

Основной способ представления символьных строк в С++ заключается в применении массива символов char, завершаемого нулевым байтом ("\0"). Следующие четыре функции демонстрируют работу таких строк:

01 void hello1()

03 const char str = {

04 "H", "e", "l", "l", "o", " ", "w", "o", "r" "l", "d", "\0"

08 void hello2()

10 const char str = "Hello world!";

13 void hello3()

17 void hello4()

19 const char *str = "Hello world!";

В первой функции строка объявляется как массив и инициализируется посимвольно. Обратите внимание на символ в конце "\0", обозначающий конец строки. Вторая функция имеет аналогичное определение массива, но на этот раз для инициализации массива используется строковый литерал. В С++ строковые литералы - это просто массивы символов const char, завершающиеся символом "\0", который не указывается в литерале. В третьей функции строковый литерал используется непосредственно без придания ему имени. После перевода на инструкции машинного языка она будет идентична первым двум функциям.

Четвертая функция немного отличается, поскольку создает не только массив (без имени), но и переменную-указатель с именем str, в которой хранится адрес первого элемента массива. Несмотря на это, семантика данной функции идентична семантике предыдущих трех функций, и оптимизирующий компилятор удалит лишнюю переменную str.

Функции, принимающие в качестве аргументов строки С++, обычно объявляют их как char * или const char *. Ниже приводится короткая программа, иллюстрирующая оба подхода:

03 using namespace std;

04 void makeUppercase(char *str)

06 for (int i = 0; str[i] != "\0"; ++i)

07 str[i] = toupper(str[i]);

09 void writeLine(const char *str)

13 int main(int argc, char *argv)

15 for (int i = 1; i

16 makeUppercase(argv[i]);

17 writeLine(argv[i]);

В С++ тип char обычно занимает 8 бит. Это значит, что в массиве символов char легко можно хранить строки в кодировке ASCII, ISO 8859-1 (Latin-1) и в других 8-битовых кодировках, но нельзя хранить произвольные символы Unicode, если не прибегать к многобайтовым последовательностям. Qt предоставляет мощный класс QString, который хранит строки Unicode в виде последовательностей 16-битовых символов QChar и при их реализации использует оптимизацию неявного совмещения данных («копирование при записи»). Более подробно строки QString рассматриваются в главе 11 («Классы-контейнеры») и в главе 17 («Интернационализация»).