Перевод QString в другие типы Опции

[bigory]

Всем доброе врем суток!
Не знаю, есть ли смысл или нет, но мне нужно перевести тип из QString в String. Дело в том, что мне нужно рассматривать символы, которые записаны в строку как массив символов, т.е. строка а, нужно вывести только символ из строки а[i], или a[от i до i+4]. Почему то на такой код:

QString a="Строка";
Далее, код ображения к a[2], т.е. к символу "р" выдает ошибку.

[maint]

вы чего здесь несете ? С каких это пор к QString стало можно обращаться как к массиву ? Разум есть ? На край можно сделать обращение к букве как

s.toStdString().c_str()[i];

Сообщение отредактировал maint - 12.2.2011, 16:18

[kin63camapa]

вы чего здесь несете ? С каких это пор к QString стало можно обращаться как к массиву ? Разум есть ? На край можно сделать обращение к букве как

s.toStdString().c_str()[i];

С 3 версии точно, раньше хз не застал. Просто помнить надо что там юникод а так оператор [] для чего-то написан а значит можно как и к любым qt шным контйнерам по индексу

Спасибо! Все заработало

а плюсик))))

вы чего здесь несете ? С каких это пор к QString стало можно обращаться как к массиву ? Разум есть ? На край можно сделать обращение к букве как

s.toStdString().c_str()[i];

http://doc.crossplatform.ru/qt/4.3.2/qstri...#operator-5b-5d в догонку

читайте документацию. вхождение подстроки(символа, регвыражения) можно найти с помощью СТАНДАРТНОЙ функции члена.
метод нахождения подстроки возможно рабочий. но оптять же лучше документацию сначала полистать.

Покажите плз, или хотяб линк в доку.


Ну да, ваша взяла qt ищет с учетом регистра и в 2 раза быстрей ибо, насколько я понял, в однобитную кодировку переводит

int qFindString(
    const QChar *haystack0, int haystackLen, int from,
    const QChar *needle0, int needleLen, Qt::CaseSensitivity cs)
{
    const int l = haystackLen;
    const int sl = needleLen;
    if (from < 0)
        from += l;
    if (uint(sl + from) > (uint)l)
        return -1;
    if (!sl)
        return from;
    if (!l)
        return -1;

    if (sl == 1)
        return findChar(haystack0, haystackLen, needle0[0], from, cs);

    /*
        We use the Boyer-Moore algorithm in cases where the overhead
        for the skip table should pay off, otherwise we use a simple
        hash function.
    */
    if (l > 500 && sl > 5)
        return qFindStringBoyerMoore(haystack0, haystackLen, from,
            needle0, needleLen, cs);

    /*
        We use some hashing for efficiency's sake. Instead of
        comparing strings, we compare the hash value of str with that
        of a part of this QString. Only if that matches, we call
        ucstrncmp() or ucstrnicmp().
    */
    const ushort *needle = (const ushort *)needle0;
    const ushort *haystack = (const ushort *)haystack0 + from;
    const ushort *end = (const ushort *)haystack0 + (l-sl);
    const int sl_minus_1 = sl-1;
    int hashNeedle = 0, hashHaystack = 0, idx;

    if (cs == Qt::CaseSensitive) {
        for (idx = 0; idx < sl; ++idx) {
            hashNeedle = ((hashNeedle<<1) + needle[idx]);
            hashHaystack = ((hashHaystack<<1) + haystack[idx]);
        }
        hashHaystack -= haystack[sl_minus_1];

        while (haystack <= end) {
            hashHaystack += haystack[sl_minus_1];
            if (hashHaystack == hashNeedle
                 && ucstrncmp((const QChar *)needle, (const QChar *)haystack, sl) == 0)
                return haystack - (const ushort *)haystack0;

            REHASH(*haystack);
            ++haystack;
        }
    } else {
        const ushort *haystack_start = (const ushort *)haystack0;
        for (idx = 0; idx < sl; ++idx) {
            hashNeedle = (hashNeedle<<1) + foldCase(needle + idx, needle);
            hashHaystack = (hashHaystack<<1) + foldCase(haystack + idx, haystack_start);
        }
        hashHaystack -= foldCase(haystack + sl_minus_1, haystack_start);

        while (haystack <= end) {
            hashHaystack += foldCase(haystack + sl_minus_1, haystack_start);
            if (hashHaystack == hashNeedle && ucstrnicmp(needle, haystack, sl) == 0)
                return haystack - (const ushort *)haystack0;

            REHASH(foldCase(haystack, haystack_start));
            ++haystack;
        }
    }
    return -1;
}

Сообщение отредактировал kin63camapa - 16.2.2011, 11:08