Массив для работы с символьными строками. Копаем глубоко

Опубликовано 28.06.2012 | Автор: admin

Как массив строк можно использовать vector<string>, но в этой статье более низкоуровневые коды.

Используются: массив символьных строк, массив указателей и указатель на указатель.

Каждую из этих трёх сущностей можно выдавать за массив строк и работать с ними как с обычным массивом.

Массив строк — это в самом примитивном случае двумерный массив символов. Поскольку строки сами по себе одномерные символьные массивы, то получится, что массив строк — это массив символьных массивов. Массив массивов — это и есть двумерный массив.

//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();
}

//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я массив указателей:

//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();
}

//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(), не смогу, потому что это мне помогли сделать, а я сам не знаю пока что, что происходит, и объяснить правильным образом, легко и понятно тот кусочек пока что не в моих силах.

//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();
}

//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г.) этот же код лучше писать так:

//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();
}

//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();

}

Ещё один вариант работы с массивом строк — это создание указателя на указатель, указывающего на символьный массив.

    char** str_arr;

1	char** str_arr;

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

Использование указателя на указатель как массива строк:

//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();
}

//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();

}

Если вспомнить об ограничении массивов, что нельзя задавать количество элементов, умещающихся в массив, в ходе работы программы, то несложно понять, что указатель на указатель можно использовать в том случае, если есть необходимость задавать количество строк непосредственно в ходе работы программы. При этом указатель на указатель оказывается чуть гибче, чем массив указателей. Можно, например, сделать эффект довыделения памяти к массиву строк. В случае с массивом указателей довыделять или, наоборот, сужать массив указателей на символьные строки — не выйдет, а вот в случае с указателем на указатель такое возможно. Но в этой теме примера подобного приводится не будет. Если вы очень упорный человек, то можете попробовать сделать такое сами. Для особо любознательных и любящих самостоятельно разбираться, могу подсказать алгоритм. Во-первых, нужно взять весь контроль памятью в свои руки. Нужно создать новый указатель на указатель, использовать его в качестве двумерного массива, сохранить в него все нужные значения из того массива, который требуется расширить или сузить, после чего очистить память, с которой связан указатель, который выступает в роли расширяемого/сужаемого массива, и перенаправить этот очищенный указатель на выделенную память, куда копировались значения. Я не хочу это показывать в этой статье, потому что многие новички должны понять то, что уже показано, а ещё один пример может им помешать быстрее разобраться. Но с такими вещами, как расширение/сужение памяти начать разбираться имеет смысл на самом обычном указателе, не на двойном, а на одинарном.

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