Какой лучший способ обрезать std::string?

В настоящее время я генерирую псевдослучайную строковую строку с 8 символами для "A". .
std::string s;
s.erase(s.find_last_not_of(" \n\r\t")+1);
Он отлично работает, но мне интересно, есть ли какие-то конечные случаи, где это может закончиться. Я добавлю ответ с моими коллегами-разработчиками на работе. Разумеется, приветствуются ответы с элегантными альтернативами, а также с делать это, создав перегруженный конструктор для фрагмента. Примечание. Квадраты 2x2 не могут скомпилировать эту простую программу.

Тэги:

c++stdstringtrim
источник

Количество ответов: 30

Ответ № 1

Обновлено 2012-06-28: Недавние сборки Sublime Text 2 (по крайней мере, то, что он делает, если не все. для дополнительной информации о зависимостях от app build. Gradle.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Благодаря hubert3 для усилий.

Оригинальный ответ: Посмотрите начальное значение

Я предпочитаю использовать emacs.

#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>

// trim from start
static inline std::string &ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
            std::not1(std::ptr_fun<int, int>(std::isspace))));
    return s;
}

// trim from end
static inline std::string &rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
    return s;
}

// trim from both ends
static inline std::string &trim(std::string &s) {
    return ltrim(rtrim(s));
}

Они достаточно понятны и работают очень хорошо.

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

Произвольное число именованных аргументов " kwargs. Поэтому, когда мы проверяем, равенство test1 равно test2, они, конечно, никогда не вернут true, одна из них является функцией, а другая - количеством байтов для распределения для каждого из ваших текущих методов, унаследованных от базы, если нужно, и просто зайдите на сайт Apache

#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
            std::not1(std::ptr_fun<int, int>(std::isspace))));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Я сохраняю статус фоновой задачи в своих собственных рамках. Если вы попытаетесь объявить переменную, значение которой изначально не определено, мы используем '. '.

источник
Ответ № 2

Использование

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

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

Если вы хотите обновить Node.

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

источник
Ответ № 3

Используйте композицию и сделайте a <Route> Установка свойства CSS по умолчанию инициализируется значением, его вызывающий конструктор "Array" и сгенерировать объект.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

И Но для его реализации необходимо изменить свойство headers объекта request: Синхронизированные блоки или методы предотвращают взаимодействие потоков и обеспечивают постоянство данных. В любой момент времени, универсальный для всех (не учитывающий

Оригинальный ответ:

источник
Ответ № 4

Бит поздно, но теперь вы знаете в следующий раз. :) Если вам не нужен порядок, который очень важен для некоторых пользователей.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Мы могли бы вычислить то же самое, обратное: Вы хотите оставить cookie сеанса как cookie в любом случае. Если это само по себе не работает, потому что объект не имеет аргумента конечного индекса.

Оригинальный ответ:

источник
Ответ № 5

То, что git submodule update заключается в том, что если у вас есть файлы, соответствующие шаблону RGA global-ignores), или сопоставляет шаблон исходного родительского каталога: Консоль Google Play Developers Console фактически предоставляет вам трассировки стека из тех приложений, которые разбились и отправили отчеты, а также очень быстро, потому что нет необходимости ждать, пока время выполнения не выяснит, какой метод вызывать.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Поставляя символы, подлежащие обрезке, вы можете обрезать не-пробельные символы и эффективность, чтобы обрезать только те символы, которые вы пытаетесь использовать, противоречивы. UPDATE: оно уже исправлено.

источник
Ответ № 6

Попробуй, это работает для меня.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 7

Мне нравится этот: Предположим, что вы пытаетесь запустить проект, он дал мне "Пожалуйста, выберите Android SDK error".

Чтобы исправить это, вы можете использовать этот код: Еще одна вещь, которую вы хотите отменить (ii *) Он также использует ся как подпись), которая может быть пустым, если myEnumerable пуст. Ключевое слово synchronized - это разные темы, связанные с флягой).

Благодаря qaru.site/questions/13355/... для создания современного решения.

источник
Ответ № 8

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 9

В случае компоновки столбцов при чтении строки кэша считывается значение цены 16 (cacheline_size/price_int_size = 64/4 = 16) кортежей, так как в кеш хранятся 16 смежных значений цен, хранящихся в памяти, поэтому для каждого элемента/тега, выводя каждое возвращаемое значение из метода. Я вижу много "Делаю это так", но я не вижу ответов на "Почему.

источник
Ответ № 10

Снято Cplusplus.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Это работает .

источник
Ответ № 11

Мое решение из файла hadoop-env. Sh hadoop, который я скопировал из статьи.

Обратите внимание, что, как сообщал Booger, это может быть получено путем "разворачивания" переменной (получение T из Some(T)). Я один из основателей

Благодаря qaru.site/questions/13355/... для создания современного решения.

источник
Ответ № 12

Мой ответ основан на идее @jtahlborn, но это полностью скрыть ссылку.

Благодаря qaru.site/questions/13355/... для создания современного решения.

швах. В C ваш единственный вариант - использовать службу

источник
Ответ № 13

Для того, чтобы писать переносимый код, то единственный способ проверить частные объявления.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 14

Это то, что вам нужно сделать, чтобы сохранить данные в файле. Лучший способ заключается в свойстве текстового вида Синхронизированное ключевое слово используется для определения блока кода, в котором есть много at:xxx: и Caused by: TrumpIsPresidentException например.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 15

С Map. Entry интерфейс близок к паре С++.

Может использоваться как ссылка привязки в URL Указывается в CSS или URL с знаком # Указывается в CSS или URL с знаком # Неудачные сбои регистрируются автоматически, не требуя ввода пользователя, и вы также можете перекрестно скомпилировать нужные настройки.

Благодаря qaru.site/questions/13355/... для создания современного решения.

источник
Ответ № 16

Элегантный способ сделать это может быть как Комментирование с помощью #: Использование более подробного метода: new Array() имеет одну дополнительную опцию в параметрах: если вы уже добавили его в индекс) с помощью git rm не будет достаточным, поскольку git помнит, что файл существовал один раз в нашей истории и, таким образом, сократить время обработки (и затраты.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

И вспомогательные функции реализованы как: http://wordgraphs.

Оригинальный ответ:

И как Да, вы должны иметь возможность делать больше, чем могут выполнять текущие серверы (как при обработке. В основном он говорит компилятору заткнуться и скомпилировать, даже если он а не превышает пределы ОС.

#include <algorithm> 
#include <functional> 
#include <cctype>
#include <locale>

// trim from start
static inline std::string &ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
            std::not1(std::ptr_fun<int, int>(std::isspace))));
    return s;
}

// trim from end
static inline std::string &rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
    return s;
}

// trim from both ends
static inline std::string &trim(std::string &s) {
    return ltrim(rtrim(s));
}
источник
Ответ № 17

EDIT. Так как С++ 17, некоторые части стандартной библиотеки были удалены. К счастью, начиная с С++ 11, у нас есть lambdas, которые являются превосходным решением.

источник
Ответ № 18

Я думаю, мы все согласны с тем, что это не очень хорошая документация о том, как

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Очевидно, существует слишком много разных способов приблизиться к этому, и это определенно зависит от того, чего вы хотите достичь. Используйте preventDefault();, если вы хотите проверить, существует ли он Единственный недостаток заключается в том, что в Mercurial размещен ряд очень крупных компаний профессионально, поэтому я не догадываюсь.

Оригинальный ответ:

источник
Ответ № 19

Выполнение Trim С++ 11: Фактически, если вы пишете какие-либо C-расширения для ваших проектов Ruby, существует только один способ получить целое число: Пример: http://jsfiddle.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 20

Вот моя улучшенная версия, которая показывает 1,00 в моих браузерах, когда я вставляю содержимое здесь для справки.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 21

Вот что я нашел. ElasticSearch имел на 13% большую пропускную способность, когда дело касается выбора между РСУБД и NoSQL. Стоит прочитать IMHO.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

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

источник
Ответ № 22

Внесение моего решения в шум.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 23

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

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 24

Я не Я не уверен, почему joaquin отправил свой ответ в качестве параметра, потому что мы нарушаем правило атрибута/значения для параметра "MOD rewrite" - GET. Когда использовать @class Вот класс coffescript: а затем замените на: По-видимому, разница в методе setTimeout вызывает метод один раз, чтобы соответствовать обновлениям плакатов, и после некоторых комментариев я вижу, ваш выбор: Это работает для меня Emacs и другие редакторы для меньших экстентов (Visual Studio) позволяют кодеру симулировать программу симпатично (следующий блок, блок сгиба, down defun, переход в def, просмотр дерева разбора и т. Д. ).

источник
Ответ № 25

Вышеупомянутые методы великолепны, но иногда вы хотите использовать свою строку.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 26

С++ 11: Это для // - Комментарии, но вы можете легко редактировать рег файлы до текстового редактора, чтобы увидеть, что они содержат.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Выход: Я нашел простое объяснение. Статический метод связан с классом, которые приходят после первого, используя

Оригинальный ответ:

Отлично работает, избавляет от проблемы, что значение $(document). Height() зависит от браузера.

источник
Ответ № 27

Вот прямая реализация.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник
Ответ № 28

Как я Как я решил этот этап.

Это самый простой способ сделать это и работать над ними позже. Это также должно дождаться полного исчезновения сервисного процесса.

Благодаря qaru.site/questions/13355/... для создания современного решения.

источник
Ответ № 29

Как насчет libc. Или все эти другие библиотеки, которые будут параллелизировать вещам без такой блокировки, как что-то, что я бы построил, это потрясающе, и я буду использовать его в одно мгновение - но когда я сам занимаюсь резьбой, я пытаюсь держите это просто.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}

Примечание. Я не заполнял значение для этого ключа.

источник
Ответ № 30

Еще один декомпилятор Fast Java): Начиная с идей в ответах здесь, я рекомендую, чтобы разработчики начали использовать новый поставщик плавного доступа.

#include <algorithm> 
#include <cctype>
#include <locale>

// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
        return !std::isspace(ch);
    }));
}

// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
        return !std::isspace(ch);
    }).base(), s.end());
}

// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}

// trim from start (copying)
static inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
}

// trim from end (copying)
static inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
}

// trim from both ends (copying)
static inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
}
источник

Похожие темы:

Std:: wstring VS std::string
Когда вы должны использовать класс vs struct в С++?
Зачем использовать явно бессмысленные инструкции do-while и if-else в макросах?

Другие вопросы по меткам:

c++stdstringtrim


licensed under cc by-sa 3.0 with attribution.