Массив для работы с символьными строками. Копаем глубоко
Как массив строк можно использовать vector<string>, но в этой статье более низкоуровневые коды.
- Используются: массив символьных строк, массив указателей и указатель на указатель.
Каждую из этих трёх сущностей можно выдавать за массив строк и работать с ними как с обычным массивом.
Массив строк — это в самом примитивном случае двумерный массив символов. Поскольку строки сами по себе одномерные символьные массивы, то получится, что массив строк — это массив символьных массивов. Массив массивов — это и есть двумерный массив.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
//clang Массив строк Листинг #1 #include <iostream> using namespace std; int main(){ const int str_len = 256; //Максимальная длина строки const int str_count = 5; //Количество строк char arr_str[str_count][str_len]; cout << "input " << str_count << "strings" << '\n'; /*ВВОД СТРОК В СТРОКОВЫЙ МАССИВ*/ for (int i=0; i<str_count; i++){ cout << i+1: << ' '; cin.getline(arr_str[i], str_len); } /*КОНЕЦ ВВОДА СТРОК В МАССИВ*/ /*ВЫВОД СТРОК НА ЭКРАН*/ for (int i=0; i<str_count; i++){ cout << arr_str[i] << '\n'; } /*КОНЕЦ ВЫВОДА СТРОК НА ЭКРАН*/ cin.get(); } |
Для массива в квадратных скобках указываете сколько массивов, т. е. строк всего надо хранить. Во вторых скобках указываете максимальную длину строки. При работе с {массивом указателей на символы} как с {массивом строк} для всех строк длина будет одинаковой, ибо массивы хранят однотипные элементы. Дальше происходит обычный обход массива со считыванием значений посредством клавиатуры и обход для вывода введённых в массив строк строк.
Чуть более сложным для освоения являетcя массив указателей:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
//clang Массив строк Использование массива указателей как массива строк Листинг #2 #include <iostream> using namespace std; int main(){ const int str_len = 256; //Максимальная длина строки const int str_count = 5; //Количество строк char *arr_str[str_len]; /*МАССИВ УКАЗАТЕЛЕЙ, ГДЕ КАЖДЫЙ УКАЗАТЕЛЬ, //ХРАНИМЫЙ В МАССИВЕ, УКАЗЫВАЕТ НА СИМВОЛЬНУЮ СТРОКУ*/ for (int i=0; i<str_count; i++){ //Выделение памяти вручную arr_str[i] = new char[str_len]; //Выделение памяти указателю под символьную строку } for (int i=0; i<str_count; i++){ cin.getline(arr_str[i],str_len); //Считывание строк посредством клавиатуры } /*Примеры вывода*/ /*ВЫВОД ПОЭЛЕМЕНТНО*/ cout << "\nOutput:"; cout << "arr[0] == " << arr_str[0] << '\n'; cout << "arr[1] == " << arr_str[1] << '\n'; /*КОНЕЦ ВЫВОДА ПОЭЛЕМЕНТНО*/ /*ВЫВОД ВСЕХ СТРОК ЗА РАЗ*/ cout << "all strings: " << '\n'; for (int i=0; i<str_count; i++){ cout << arr_str[i] << '\n'; } /*КОНЕЦ ВЫВОДА ВСЕХ СТРОК ЗА РАЗ*/ for (int i=0;i<str_count;i++){ delete []arr_str[i]; } cin.get(); } |
Для освоения этого примера требуется немного понимать указатели и немного понимать массивы. Указатели схожи с массивами. Показанный листинг хорош тем, что можно задавать количество строк в ходе работы программы, чего нельзя сделать, используя обычный двухмерный массив:
- В показываемом ниже примере всё, что не будет вмещаться в строку, проигнорируется.
При работе программы нужно будет задавать длину для каждой вновь вводимой строки и количество символов для той строки. Каждая строка будет создаваться с указанной для неё длиной. Некоторые подробности я объяснить не смогу, не смогу рассказать про момент с вводом, где ипользуется cin.clear(), не смогу, потому что это мне помогли сделать, а я сам не знаю пока что, что происходит, и объяснить правильным образом, легко и понятно тот кусочек пока что не в моих силах.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
//Borland C++ 3.1 Листинг №3/1 Указатель на массив Работает как массив строк //Строкам можно задавать разные длины #include <iostream.h> #include <conio.h> int main(){ clrscr(); const int str_count = 5; //Количество строк int str_len = 0; //Длина строки, задаваемая во время работы программы char *arr_str[str_count]; //Массив указателей, умеющий хранить str_count указателей. //Каждый указатель будет указывать на символьную строку, //т. е. всего str_count строк for (int i = 0; i<str_count; i++) { //Обрабатываем массив строк str_len = 0; //Максимальная длина строки (будет задаваться во время работы программы) cout << "input max length new string: "; //Диалог с пользователем: введите максимальную длину строки cin >> str_len; //Ввод максимальной длины строки arr_str[i] = new char[str_len]; //Для каждого очередного указателя в нашем массиве //выделяется память, чем и задаётся длина строки cout << "input string: "; //Диалог с пользователем: введите строку /*Чтобы ввод работал исправно*/ //Это я пока не смогу объяснить, простите cin.clear(); cin.ignore(9999,'\n'); cin.getline(arr_str[i], str_len); cin.clear(); cin.ignore(9999,'\n'); /*КОНЕЦ ИСПРАВНОГО ВВОДА*/ } /*ВЫВОД СТРОК НА ЭКРАН*/ cout << "output:\n"; for (i=0; i<str_count; i++){ cout << arr_str[i] << '\n'; } cout << '\n'; /*Можно по индексу*/ cout << arr_str[0] << '\n'; cin.get(); } |
Число 9999 — это некоторое число, которое обозначит максимально возможную длину строки в принципе. В современных компиляторах (поставляемых после 2011г.) этот же код лучше писать так:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
//clang Массив строк Листинг #3/2 #include <iostream> #include <limits> //numeric_limits using namespace std; int main() { const int str_count = 5; //Количество строк char *arr_str[str_count]; //Массив указателей, умеющий хранить str_count указателей //Каждый указатель будет выполнять роль строки int str_len = 0; //Максимальная длина строки (будет вводиться в ходе работы программы) for (auto& target : arr_str) { cout << "input max length new string: "; //Диалог с пользователем cin >> str_len; //Ввод длины строки target = new char[str_len]; //Для каждого указателя внутри массива //выделяется память, // т. е. создаётся строка в str_len символов cout << "input string: "; //Диалог с пользователем cin.getline(target, str_len); //чтение строки с клавиатуры в массив cin.clear(); cin.ignore(numeric_limits<streamsize>::max(),cin.widen('\n')); } /*ОБХОД МАССИВА СТРОК*/ for (const auto &i:arr_str) cout << i << '\n'; cin.get(); } |
Ещё один вариант работы с массивом строк — это создание указателя на указатель, указывающего на символьный массив.
|
1 |
char** str_arr; |
Такой указатель по природе похож на двумерный массив, и работать с ним можно как с двумерным массивом, но в отличие от обычных массивов, эта штуковина позволяет хранить массивы, в которых хранятся строки с разным количеством максимальных для себя длин. Поскольку указатель на указатель по природе похож на двумерный массив, то за исключением выделения и очистки памяти, работать с таким указателем можно как с обычным двумерным массивом.
Использование указателя на указатель как массива строк:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
//clang Указатель на указатель в качестве массива строк Листинг #4 #include <iostream> #include <limits> using namespace std; int main(){ char **arrays_strings = 0; //указатель на указатель на символ int str_num = 0; //номер строки как индекс массива int str_count = 5; //количество строк int str_len = 0; //длина для строки (будет задаваться во время работы програмы) /*ВЫДЕЛЕНИЕ ПАМЯТИ*/ arrays_strings = new char*[str_count]; //Выделение памяти для count_of_string_arrays указателей. for (int i = 0; i< str_count; i++){ //Выделение памяти для длины строки arrays_strings[i] = new char[255]; } /*КОНЕЦ ВЫДЕЛЕНИЯ ПАМЯТИ*/ for (int i=0; i<str_count; i++){ cout << "input max length new string: "; //Просьба сообщить максимальную длину вводимой строки cin >> str_len; //Ввод количества символов для строки cin.sync(); //Для неполомки cin.ignore(); cout << "input string [" << str_num << "]"; while (!cin.getline(arrays_strings[i],str_len)){ cerr << "error\n"; //Сообщаем об этом cin.clear(); //Сбрасываем флаги cin.sync(); //Очищаем буфер стандартного ввода cout << "input string [" << str_num << "]"; } str_num++; //двигаем курсор по массиву вперёд на ячейку } /*ВЫВОД СТРОК ПУТЁМ ОБХОДА МАССИВА*/ cout << "all strings: " << '\n'; for (int i=0; i<str_count; i++){ cout << arrays_strings[i] << '\n'; } /*КОНЕЦ ВЫВОДА СТРОК*/ /*ОЧИСТКА ПАМЯТИ*/ for (int i=0; i<str_count; i++){ delete []arrays_strings[i]; } delete arrays_strings; /*КОНЕЦ ОЧИСТКИ ПАМЯТИ*/ cin.get(); } |
Если вспомнить об ограничении массивов, что нельзя задавать количество элементов, умещающихся в массив, в ходе работы программы, то несложно понять, что указатель на указатель можно использовать в том случае, если есть необходимость задавать количество строк непосредственно в ходе работы программы. При этом указатель на указатель оказывается чуть гибче, чем массив указателей. Можно, например, сделать эффект довыделения памяти к массиву строк. В случае с массивом указателей довыделять или, наоборот, сужать массив указателей на символьные строки — не выйдет, а вот в случае с указателем на указатель такое возможно. Но в этой теме примера подобного приводится не будет. Если вы очень упорный человек, то можете попробовать сделать такое сами. Для особо любознательных и любящих самостоятельно разбираться, могу подсказать алгоритм. Во-первых, нужно взять весь контроль памятью в свои руки. Нужно создать новый указатель на указатель, использовать его в качестве двумерного массива, сохранить в него все нужные значения из того массива, который требуется расширить или сузить, после чего очистить память, с которой связан указатель, который выступает в роли расширяемого/сужаемого массива, и перенаправить этот очищенный указатель на выделенную память, куда копировались значения. Я не хочу это показывать в этой статье, потому что многие новички должны понять то, что уже показано, а ещё один пример может им помешать быстрее разобраться. Но с такими вещами, как расширение/сужение памяти начать разбираться имеет смысл на самом обычном указателе, не на двойном, а на одинарном.
Делаем выводы: в качестве массива строк можно использовать обычный двумерный массив символов, массив указателей на символьные массивы и указатель на указатель на символьный массив. Массив указателей на символьные массивы ближе к обычному двумерному массиву символов.
2 комментария на «“Массив для работы с символьными строками. Копаем глубоко”»
Добавить комментарий
Случайная книга в электронном формате
Листинг 4
Почему Вы выделили память на 3 стргоки (count_of_string_arrays = 3) по 255 символов, а вводим 5 (str_count = 5) строк?
Ошибка. Исправлена. Спасибо!