Как считать целую строку в с

Ввод и вывод символьных строк в Си

Итак, строки в языке Си. Для них не предусмотрено отдельного типа данных, как это сделано во многих других языках программирования. В языке Си строка – это массив символов. Чтобы обозначить конец строки, используется символ ‘\0’ , о котором мы говорили в прошлой части этого урока. На экране он никак не отображается, поэтому посмотреть на него не получится.

Создание и инициализация строки

Так как строка – это массив символов, то объявление и инициализация строки аналогичны подобным операциям с одномерными массивами.

Следующий код иллюстрирует различные способы инициализации строк.

char str[10]; char str1[10] = ; char str2[10] = "Hello!"; char str3[] = "Hello!";

Рис.1 Объявление и инициализация строк

В первой строке мы просто объявляем массив из десяти символов. Это даже не совсем строка, т.к. в ней отсутствует нуль-символ \0 , пока это просто набор символов.

Вторая строка. Простейший способ инициализации в лоб. Объявляем каждый символ по отдельности. Тут главное не забыть добавить нуль-символ \0 .

Третья строка – аналог второй строки. Обратите внимание на картинку. Т.к. символов в строке справа меньше, чем элементов в массиве, остальные элементы заполнятся \0 .

Четвёртая строка. Как видите, тут не задан размер. Программа его вычислит автоматически и создаст массив символов нужный длины. При этом последним будет вставлен нуль-символ \0 .

Как вывести строку

Дополним код выше до полноценной программы, которая будет выводить созданные строки на экран.

#include int main(void) < char str[10]; char str1[10] = ; char str2[10] = "Hello!"; char str3[] = "Hello!"; for(int i = 0; i

Рис.2 Различные способы вывода строки на экран

Как видите, есть несколько основных способов вывести строку на экран.

• использовать функцию printf со спецификатором %s
• использовать функцию puts
• использовать функцию fputs , указав в качестве второго параметра стандартный поток для вывода stdout .

Единственный нюанс у функций puts и fputs . Обратите внимание, что функция puts переносит вывод на следующую строку, а функция fputs не переносит.

Как видите, с выводом всё достаточно просто.

Ввод строк

С вводом строк всё немного сложнее, чем с выводом. Простейшим способом будет являться следующее:

#include int main(void)

Функция gets приостанавливает работу программы, читает строку символов, введенных с клавиатуры, и помещает в символьный массив, имя которого передаётся функции в качестве параметра.
Завершением работы функции gets будет являться символ, соответствующий клавише ввод и записываемый в строку как нулевой символ.
Заметили опасность? Если нет, то о ней вас любезно предупредит компилятор. Дело в том, что функция gets завершает работу только тогда, когда пользователь нажимает клавишу ввод. Это чревато тем, что мы можем выйти за рамки массива, в нашем случае — если введено более 20 символов.
К слову, ранее ошибки переполнения буфера считались самым распространенным типом уязвимости. Они встречаются и сейчас, но использовать их для взлома программ стало гораздо сложнее.

Итак, что мы имеем. У нас есть задача: записать строку в массив ограниченного размера. То есть, мы должны как-то контролировать количество символов, вводимых пользователем. И тут нам на помощь приходит функция fgets :

#include int main(void)

Функция fgets принимает на вход три аргумента: переменную для записи строки, размер записываемой строки и имя потока, откуда взять данные для записи в строку, в данном случае — stdin . Как вы уже знаете из 3 урока, stdin – это стандартный поток ввода данных, обычно связанный с клавиатурой. Совсем необязательно данные должны поступать именно из потока stdin , в дальнейшем эту функцию мы также будем использовать для чтения данных из файлов.

Если в ходе выполнения этой программы мы введем строку длиннее, чем 10 символов, в массив все равно будут записаны только 9 символов с начала и символ переноса строки, fgets «обрежет» строку под необходимую длину.

Обратите внимание, функция fgets считывает не 10 символов, а 9 ! Как мы помним, в строках последний символ зарезервирован для нуль-символа.

Давайте это проверим. Запустим программу из последнего листинга. И введём строку 1234567890 . На экран выведется строка 123456789 .

Рис.3 Пример работы функции fgets

Возникает вопрос. А куда делся десятый символ? А я отвечу. Он никуда не делся, он остался в потоке ввода. Выполните следующую программу.

#include int main(void)

Вот результат её работы.

Рис.4 Непустой буфер stdin

Поясню произошедшее. Мы вызвали функцию fgets . Она открыла поток ввода и дождалась пока мы введём данные. Мы ввели с клавиатуры 1234567890\n ( \n я обозначаю нажатие клавиша Enter ). Это отправилось в поток ввода stdin . Функция fgets , как и полагается, взяла из потока ввода первые 9 символов 123456789 , добавила к ним нуль-символ \0 и записала это в строку str . В потоке ввода осталось ещё 0\n .

Далее мы объявляем переменную h . Выводим её значение на экран. После чего вызываем функцию scanf . Тут-то ожидается, что мы можем что-то ввести, но т.к. в потоке ввода висит 0\n , то функция scanf воспринимает это как наш ввод, и записывается 0 в переменную h . Далее мы выводим её на экран.

Это, конечно, не совсем такое поведение, которое мы ожидаем. Чтобы справиться с этой проблемой, необходимо очистить буфер ввода после того, как мы считали из него строку, введённую пользователем. Для этого используется специальная функция fflush . У неё всего один параметр – поток, который нужно очистить.

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

#include int main(void) < char str[10]; fgets(str, 10, stdin); fflush(stdin); // очищаем поток ввода puts(str); int h = 99; printf("do %d\n", h); scanf("%d",&h); printf("posle %d\n", h); return 0; >

Теперь программа будет работать так, как надо.

Рис.4 Сброс буфера stdin функцией fflush

Подводя итог, можно отметить два факта. Первый. На данный момент использование функции gets является небезопасным, поэтому рекомендуется везде использовать функцию fgets .

Второй. Не забывайте очищать буфер ввода, если используете функцию fgets .

На этом разговор о вводе строк закончен. Идём дальше.

Сохрани в закладки или поддержи проект.

Практика

Решите предложенные задачи:

Для удобства работы сразу переходите в полноэкранный режим

Исследовательские задачи для хакеров

1. Проверьте как ведет себя ваш компилятор в случае переполнения буфера.

Дополнительные материалы

1. пока нет

Типы данных

Строки Прежде чем пользоваться строковыми операциями и вообще иметь возможность описывать переменные типа string необходимо включить в заголовок программы описание:

Также во всех примерах предполагается, что в начале программы подключено пространство имен std:
using namespace std;
Описание строки полностью аналогично описанию любой другой переменной. Например:
string example_str;

• Присваивание
• Сравнение
• Ввод
• Запрос длины строки (size, length)
• Соединение (+)
• Удаление фрагмента (erase)
• Вставка фрагмента (insert)
• Копирование фрагмента (substr)
• Поиск фрагмента (find)
• Преобразование к числу (sscanf, sstream)
• Преобразование числа к строке (sprintf, sstream)
• Строка как массив символов
• Примечание(*)

Присваивание строк

Примеры с комментариями:

string example_str = «Do bats eat cats?»; // присваивание при описании example_str = «»; // присваивание пустой строки — // две кавычки рядом, без пробелов work_str = example_str; // присваивание между строками

Помимо этого возможно вот такое присваивание:

char a[50]; example_str = a;

Сравнение строк

Две строки равны друг другу, если у них одинаковые длины и символы на соответствующих местах полностью совпадают (то есть 1-й символ строки A равен 1-му символу строки B, 2-й символ строки A равен 2-му символу строки B и так далее)

Например строка «abc» равна строке «abc», но не равна строке «abcd».

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

Строку также можно сравнивать с пустой (обозначается двумя кавычками подряд, без пробелов).

while (example_str != «») < // какие-то команды >

Для ввода строк рекомендуется использовать функцию getline(). Данная функция читает строку целиком (с пробелами и прочими символами) до знака перевода строки.

getline(cin, example_str);

Длина строки

Функции size() или length() возвращают целое число — количество символов, которое сейчас находится в строке.

example_str = «Password»; int x = example_str.size(); // после этого фрагмента x = 8
example_str = «»; if (example_str.length() > 0) < // команды этого блока сейчас не выполнятся, // так как длина пустой строки равна 0 >;

Соединение строк

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

example_str = «password»; article = «The » comment_str = «anyone can guess it.» example_str = article + example_str + » is so simple, so » + comment_str; // example_str = «The password is so simple, so anyone can guess it.»

Удаление фрагмента

Функция erase() удаляет указанный фрагмент строки (если это возможно). Первым параметром указывается начальный символ (с него начнется удаление), вторым — количество символов. Символы в строке нумеруются, начиная с 0.

example_str = «The star is so distant»; example_str.erase(3, 6); // example_str = «Theis so distant» // будет удалено слово star вместе с обоими пробелами

example_str = «The star is so distant»; example_str.erase(3, 80); // example_str = «The» // будет удалено столько символов, сколько возможно

Вставка фрагмента

С помощьью функции insert() можно добавить заданный фрагмент в любое место строки. Первым параметром функции является номер начальной позиции для фрагмента (нумерация начинается с 0), вторым — фрагмент. Функция изменяет исходную строку.

example_str = «123456»; example_str.insert(3, «+»); // теперь example_str = «123+456»

Копирование фрагмента

Функция substr() возвращает фрагмент строки (который тоже является строкой). Первым параметром указывается номер начального символа, вторым — количество. Символы нумеруются, начиная с 0. Функция не оказывает влияния на исходную строку.

example_str = «Do bats eat cats?»; new_str = example_str.substr(3, 5); // new_str = «bats » // будет скопировано слово «bats» вместе с последуюшим пробелом

example_str = «Do bats eat cats?»; new_str = example_str.substr(12, 100); // new_str = «cats?» // в строке нет 100 символов, поэтому будет скопировано сколько есть

Поиск фрагмента

С помощью функции find() можно определить, встречается ли данный фрагмент в строке. Функция возвращает специальное значение string::npos, если фрагмент не найден или номер первого (начиная слева) места, откуда начинается подобный фрагмент

example_str = «comandante@cia.dark.org»; x = example_str.find(«z»); // в этом примере x равно string::npos, // так как в строке нет ни одной буквы z

example_str = «comandante@cia.dark.org»; x = example_str.find(«a»); // в этом примере x равно 3, // символов «а» в строке несколько, но find // вернет номер только для первого слева

example_str = «comandante@cia.dark.org»; if (example_str.find(«te») != string::npos) < // команды этого блока выполнятся, так как // в строке есть фрагмент "te" >

Преобразование к числу

1. Ввод/вывод в stringstream. Требуется создать специальный поток ввода/вывода, который будет вводить или выводить данные в некоторый буффер в памяти. При этом операции будут сходны со стандартным вводом/выводом.

#include stringstream container; // создали специальный поток ввода/вывода, // который «работает» в некоторой области памяти string data = «918»; int x; container.clear(); // на случай, если в container что-то лежало, чтобы // случайно не попало в результат преобразования container > x; // достаем из потока это же число в виде int

2. Функция sscanf() (scan from string as fromatted). Данная функция также из обычного C (не C++) поэтому «умеет» работать только с символьными массивами. В грубом приближении у функции 3 параметра: символьный массив, строка формата и переменная (или переменные), куда следует поместить результаты преобразования.

#include string some_value = 825; x = sscanf(some_value.data(), «%d», &x); // в x записано число типа int, извлеченное из строки // функция data() позволяет получить символьный массив // в формате языка C (не C++), с таким же содержанием, // что и строка

Преобразование числа к строке

1. Ввод/вывод в stringstream. Требуется создать специальный поток ввода/вывода, который будет вводить или выводить данные в некоторый буффер в памяти. При этом операции будут сходны со стандартным вводом/выводом.

#include #include #include using namespace std; stringstream container; // создали специальный поток ввода/вывода, // который «работает» в некоторой области памяти string data; int x = 16; container.clear(); // объясняем потоку, что в нем нет данных // чтоб не получить при чтении то, что не клали туда сами container > data; // достаем из потока это же число в виде строки

2. sprintf() (print formatted to string). Эта функция также является функцией из стандартного C, и тоже работает только с массивами из char). Параметры (вкратце): символьный массив, куда будет выведен результат, строка формата, данные.

Подробнее про строку формата см. например, здесь.

#include #include #include int x; string s; char z[100]; x = 92; sprintf(z, «%d», x); s = z;

Строка как массив символов

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

Ввод в языке C++ через cin

Для считывания данных со стандартного ввода используется объект cin , также определенных в заголовочном файле iostream . Его использование похоже на использование объекта cout для вывода. Например, для считывания двух переменных a и b нужно дать команду:

Также как и в случае с cout , нет нужды беспокоиться о типах данных — можно считывать целые и действительные числа, символы и строки.

Особенности считывания символов

Пусть дано время в формате HH:MM. Считать его можно следующим образом:

int h, m;
char c;
cin >> h >> c >> m;

То есть сначала считывается число, затем — символ, затем — число.

При этом при считывании символа пропускаются пробельные символы (пробелы и концы строк) и считывается следующий непробельный символ. Например, если при запуске приведенного выше кода ввести «12 34», то переменная h станет равна 12, переменная с — ‘3’, а переменная m — 4.

Если установить манипулятор noskipws :

то при считывании символов пробельные символы не будут пропускаться. Для восстановления режима пропуска пробельных символов используется манипулятор skipws :

Особенности считывания строк

Считывание строк при помощи cin >> s , где s — объект класса string или C-строка приведет к считыванию строки из непробельных символов, при этом пробельные символы пропускаются.Использовать манипулятор noskipws при чтении строк не следует.

Строку целиком до конца строки, вместе с пробельными символами можно считать следующим образом:

Отметим следующую особенность такого считывания. Пусть входные данные заданы так — сначала число строк n, затем — n строк, возможно, содержащие пробелы. Требуется считать данные строки и сохранить их в массиве строк.

Правильное решение будет таким:

int n;
string s, A[100];
cin >> n;
getline(cin, s);
for (int i = 0; i < n; ++i)
getline(cin, A[i]);

Здесь нужно обратить внимание на «лишний» вызов getline после считывания числа n. Дело в том, что cin >> n не считывает конец строки из потока, поэтому последующий вызов getline вернет пустую строку (но зато считает конец строки), поэтому нужно сделать один «холостой» вызов getline перед считыванием всех остальных строк.

Значение, возвращаемое при считывании

Для проверки успешности считывания можно преобразовать значение, возвращаемое операцией считывания к типу bool . Например, следующим образом:

bool is_correct;
int a;
is_correct = (cin >> a);

Если значение переменной is_correct будет true , то считывание было успешно, иначе — нет.

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

int h, m;
char c;
if (cin >> noskipws >> h >> c >> m)
if (c == ‘:’) .
>

Похожее использование — чтение текста «по словам», с обработкой каждого слова:

string word;
while (cin >> word)
// Обработать слово в переменной word
>

Или считывание текста по строкам:

string line;
while (getline(cin, s))
// Обработать строку в переменной line
>

Как прочитать с консоли строку неизвестной заранее длины не используя string?

Я прекрасно понимаю, что можно использовать класс string и просто написать cin>> str; а затем получить количество элементов. Я даже видел веселое решение при помощи malloc и realloc функций из C. но все же, интересно, есть ведь какой-то способ при помощи средств C++, а конкретно их потоков ввода и стандартных строк в виде массива символов прочитать из консоли строку, не имея понятия о ее размере, получить впоследствии ее размер и положить в динамически выделенный массив такого размера?? Вопрос не к спеху и не для какого-то задания, все чисто ради интереса, так что ваши ответы, типа «не парься и пользуйся тем, что дают» также приветствуются )

Отслеживать
задан 2 дек 2015 в 19:44
111 1 1 золотой знак 1 1 серебряный знак 6 6 бронзовых знаков

Ну, если вы пишете на C++, то стандартная строка и есть std::string . С ним просто. Если вы принципиально не пользуетесь идиоматическими строками, то вам таки придётся заниматься ручным выделением памяти через new[] / delete[] или тот же malloc/realloc. В C++ специальных других средств нету, т. к. строкой по сути считается std::string .

2 дек 2015 в 20:08

Стандартной функции я не знаю. Можно считывать посимвольно, выделив внутри char *buffer какого-то фиксированнового размера, по достижению предела емеости буфера, выделить, скажем, вдвое больший и т.д. пока не встретится EOF или символ новой строкию

2 дек 2015 в 20:17

Удалось добиться разве что такого ideone.com/nzjJa6, но тут важно, что ввод производиться не с консоли пользователем, а подаётся «напрямую». В консоли считать заново не удавалось ни в какую, все сбрасывается после нажатия enter

2 дек 2015 в 21:31

Можно ещё конечно использовать std::stringstream , но мне кажется что в рамках этой задачи это будет читом 🙂

2 дек 2015 в 21:54

3 ответа 3

Сортировка: Сброс на вариант по умолчанию

cin >> str; запишет только до первого разделителя: http://ideone.com/Y5CJxD.

Если под строкой понимается последовательность, которая заканчивается переводом строки ( ‘\n’ ), то вам: std::getline() нужен: http://www.cplusplus.com/reference/string/string/getline/

А так, std::string это и так стандартное средство в C++. Если же хочется извратиться, то нужно читать блоками, проверять — есть ли перевод строки и агрегировать код, но лишнее нужно как-то хранить между вызовами. Либо, что проще, но медленнее — читать посимвольно, проверяя конец строки, например так:

istream& getline(istream& is, char *&buffer) < std::istream::sentry s(is); if (s) < std::istreambuf_iteratorit(is); std::istreambuf_iterator end; size_t size = 64; size_t grow = 64; size_t len = 0; buffer = new char[size]; while (it != end && *it != '\n') < if (len == (size - 1)) < buffer = buffer_realloc(buffer, size, size + grow); size += grow; >buffer[len++] = *it++; > buffer[len] = '\0'; > return is; > 

Здесь я не привожу функцию buffer_realloc() — она простая. Использовать как-то так:

char *line = nullptr; while (getline(std::cin, line)) < if (line) < cout > 

Либо вот вариант, где использует вектор:

istream& getline(istream& is, vector &buffer) < std::istream::sentry s(is); if (s) < std::istreambuf_iteratorit(is); std::istreambuf_iterator end; const size_t grow = 64; buffer.reserve(grow); while (it != end && *it != '\n') < if (buffer.size() == buffer.capacity() - 1) < buffer.reserve(buffer.size() + grow); >buffer.push_back(*it++); > buffer.push_back('\0'); > return is; > 

Использовать как-то так:

vector line; while (getline(std::cin, line)) < if (!line.empty()) < cout > 

Тут реаллокация памяти ложится на плечи vector’а. От вас только почистить его (а можно и в гетлайн всунуть). Плюс бонусом сразу длинна строки за O(1): line.size() — 1

Вот законченные примеры:

• http://ideone.com/Huj4eQ
• http://ideone.com/CxNfg4

Но повторюсь: std::string стандартны для С++. Я слабо представляю условия, где есть потоки, но нет строк 🙂