Урок 14.
План занятия.
Строки
Строковые массивы
Строки и указатели
Функции работы со строками
Строки.
Строки
Строка — это серия символов, сохраненная в расположенных последовательно байтах памяти. Это предполагает хранение строки в массиве char, где каждый элемент содержится в отдельном элементе массива. Строки предоставляют удобный способ хранения текстовой информации, такой как сообщения для пользователя или его ответы. Строки в стиле С обладают специальной характеристикой: последним в каждой такой строке является нулевой символ. Этот символ, записываемый как \0, служит меткой конца строки. Например, рассмотрим два следующих объявления:
char dog [8] = { 'b', 'e', 'a', 'u', 'х1, ' ', 'I', 'I'}; // это не строка
char cat [8] = {'f, 'а', ' t', 'е', 's', 's', 'a', '\0'}; // а это - строка
Нулевой символ играет фундаментальную роль в строках стиля С. Существует более простой способ инициализации массива с помощью строки. Для этого просто используйте строку в двойных кавычках, которая называется строковой константой или строковым литералом, как показано ниже:
char bird[11] = "Mr. Cheeps"; // наличие символа \0 подразумевается
char fish[] = "Bubbles"; // позволяет компилятору подсчитать
// количество элементов
Строки в двойных кавычках всегда неявно включают ограничивающий нулевой символ, поэтому указывать его явно не требуется.
Использование строк в массивах.
Применяется стандартная библиотечная функция strlen() для получения длины строки. Стандартный заголовочный файл cstring (или string.h в более старых реализациях) предоставляет объявления для этой и многих других функций, работающих со строками.
Примеры функций cstring:
Прототип функции strcpy:
char * strcpy( char * destptr, const char * srcptr ); Описание
Функция копирует Си-строку srcptr, включая завершающий нулевой символ в строку назначения, на которую ссылается указатель destptr.
Чтобы избежать переполнения, строка, на которую указывает destptr должна быть достаточно длинной, чтобы в неё поместилась копируемая строка (включая завершающий нулевой символ). Копируемая строка и строка назначения не должны перекрываться в памяти.
char str1[] = "Я программист";
char str2[40];
char str3[80];
strcpy (str2, str1); // копируем строку str1 в str2
strcpy (str3, "копирование выполнено успешно\n"); // копируем строку во втором параметре в str3
std::cout << "str1: " << str1
<< "\nstr2: " << str2
<< "\nstr3: " << str3;
Прототип функции strcat:
char * strcat( char * destptr, const char * srcptr );
Объединение строк. Функция добавляет копию строки srcptr в конец строки destptr. Нулевой символ конца строки destptr заменяется первым символом строки srcptr, и новый нуль-символ добавляется в конец уже новой строки, сформированной объединением символов двух строк в строке destptr
char str[100];
strcpy( str, "Эти " ); // скопировать строку "Эти" в str
// добавить к строке str строку, передаваемую во втором параметре
strcat( str, "строки " );
strcat( str, "объединены " );
strcat( str, "операцией " );
strcat( str, "конкатенации." );
std::cout << str << std::endl;
Задача: сохранение строк в массиве.
Cstrings.cpp
#include <iostream>
#include <cstring>
using namespace std;
void main()
{
setlocale (LC_CTYPE, "russian");
const int size=20;
char name1[size]; //пустой массив name1
char name2[size]="C++owboy"; //инициализация массива name2
cout << "Как дела!Я " << name2 << "! Как тебя зовут?" << endl;
cin >> name1;
cout << "Хорошо " << name1 << " ,Твое имя имеет " << strlen (name1);
cout << " символов и занимает в памяти " << sizeof (name1) << " байт." << endl;
cout << "Первая буква твоего имени: " << name1[0] << ".\n";
name2[3]='\0'; //установка нулевого символа
cout << "Первые три буквы моего имени: " << name2 << endl;
cin.get(); cin.get();
}
Поскольку namel и name2 — массивы, для доступа к отдельным символам в этих массивах можно использовать индексы. Например, в программе для поиска первого символа массива name1 применяется name1[0]. Кроме того, программа присваивает элементу name2[3] нулевой символ. Это завершает строку после трех символов, хотя в массиве остаются еще символы.
Риски связанные с вводом строк:
При запуске Cin следует вводить последовательность символов без использования знаков пробела, знаков табуляции и символов новой строки – последующие символы не будут считаться строкой! В сin пробелы используются для разделения строк!
Вводимая строка может быть длиннее чем целевой массив! Нет никакой защиты от помещения 30-символьной строки в 20-символьный массив.
Построчное чтение ввода
У класса istream, экземпляром которого является сіп, есть функции-члены, предназначенные для строчно-ориентированного ввода: getline() и get(). Оба читают полную строку ввода — т.е. вплоть до символа новой строки. Однако getline() затем отбрасывает символ новой строки, в то время как get () оставляет его во входной очереди.
Строчно-ориентированный ввод с помощью getline ()
Функция getline () читает целую строку, используя символ новой строки, который передан клавишей <Enter>, для обозначения конца ввода. Этот метод инициируется вызовом функции cin.getline(). Функция принимает два аргумента. Первый аргумент — это имя места назначения (т.е. массива, который сохраняет введенную строку), а второй — максимальное количество символов, подлежащих чтению. Если, скажем, установлен предел 20, то функция читает не более 19 символов, оставляя место для автоматически добавляемого в конец нулевого символа. Функция-член getline () прекращает чтение, когда достигает указанного предела количества символов или когда читает символ новой строки — смотря, что произойдет раньше.
Например, предположим, что вы хотите воспользоваться getline () для чтения имени в 20-элементный массив name. Для этого следует указать такой вызов:
cin.getline(name,20);
Он читает полную строку в массив name, предполагая, что строка состоит не более чем из 19 символов. Таким образом можно примененять cin.getline() вместо простого сіn и решить вопрос с наличием пробелов в имени.
Пример: Запрос имени заказчика и заказываемого десерта. Информация вводится, а после выводится в предложении.
desert.cpp
#include <iostream>
using namespace std;
void main()
{
setlocale (LC_CTYPE, "russian");
const int size=20;
char name[size];
char dessert[size];
cout << "Введите Ваше имя: ";
cin.getline(name, size); //Вводим вместо cin для ввода полного имени с пробелами
cout << "Введите название заказываемого десерта: ";
cin.getline(dessert, size); //Вводим вместо cin для ввода полного названия с пробелами
cout << "Ваш любимый десерт " << dessert << " подан для Вас, мистер " << name << endl;
cin.get(); cin.get();
}
cin.getline() читает символ новой строки, сгенерированный клавишей Enter, и заменяет его нулевым символом, обозначая конец строки.
Строчно-ориентированный ввод с помощью get()
Функция-член get() работает почти так же, как getline(). Он принимает те же аргументы, интерпретирует их аналогичным образом, и читает до конца строки. Но вместо того, чтобы прочитать и отбросить символ новой строки, get () оставляет его во входной очереди. Без посторонней помощи get () вообще не может преодолеть этот символ новой строки.
cin.get(name, ArSize);
cin.get(dessert, Arsize); // проблема
Решение:
cin.get(name, ArSize); // чтение первой строки
cin.get () ; // чтение символа новой строки
cin.get(dessert, Arsize) // чтение второй строки
Другой способ применения get () состоит в конкатенации, или соединении, двух вызовов функций-членов класса, как показано в следующем примере:
cin.get(name, ArSize).get(); // конкатенация функций-членов
аналогично записи
cin.get(name, ArSize);
cin.get () ;
объединять можно и cin.getline ():
cin.getline(name, size).getline(dessert, size);
Зачем вообще может понадобиться вызывать get () вместо getline ()? get () позволяет проявлять большую осторожность. Предположим, например, что вы воспользовались get (), чтобы прочитать строку в массив. Как вы определите, была прочитана полная строка или же чтение прервалось в связи с заполнением массива? Для этого нужно посмотреть на следующий в очереди символ. Если это символ новой строки, значит, была прочитана вся строка. В противном случае строка была прочитана не полностью и еще есть что читать. Короче говоря, getline () немного проще в применении, но get () упрощает проверку ошибок. Вы можете использовать любую из этих функций для чтения ввода; просто учитывайте различия в их поведении.
Пустые строки и другие проблемы
После того, как функция get() (но не getline ()) прочитает пустую строку, она устанавливает флажок, который называется failbit. Влияние этого флажка состоит в том, что последующий ввод блокируется, но вы можете восстановить его следующей командой:
cin.clear();
Другая потенциальная проблема связана с тем, что входная строка может быть длиннее, чем выделенное для нее пространство. Если входная строка длиннее, чем указанное количество символов, то и getlineO, и get() оставляют избыточные символы во входной очереди. Однако getlineO дополнительно устанавливает failbit и отключает последующий ввод.
Смешивание строкового и числового ввода
Смешивание числового и строкового ввода может приводить к проблемам.
#include <iostream>
int main()
{
using namespace std;
cout << "What year was your house built?\n";
int year;
cin >> year;
cout << "What is its street address?\n";
char address[80] ;
cin.getline(address, 80);
cout « "Year built: " « year « endl;
cout « "Address: " « address « endl;
cout « "Done!\n";
return 0;
}
В результате выполнения программы получаем следующий вывод:
What year was your house built?
1966
What is its street address?
Year built: 1966
Address:
Done!
Вы так и не получили возможности ввести адрес. Проблема в том, что когда сіn читает год, то оставляет символ новой строки, сгенерированный нажатием <Enter>, во входной очереди. Затем cin.getline () читает символ новой строки просто как пустую строку, после чего присваивает массиву address нулевую строку. Чтобы исправить это, нужно перед чтением адреса прочитать и отбросить символ новой строки. Это может быть сделано несколькими способами, включая вызов get() без аргументов.
cin » year;
cin.get( ); // или cin.get(ch);
или (cin >> year), get (); // или (cin » year).get(ch) ;
Введение в класс string
Вместо использования символьных массивов для хранения строк можно применять переменные типа string (или, пользуясь терминологией C++, объекты). Класс string проще в использовании, чем массив, и к тому же предлагает более естественное представление строки как типа.
Для работы с классом string в программе должен быть включен заголовочный файл string. Класс string является частью пространства имен std, поэтому вы должны указать директиву using или объявление либо же ссылаться на класс как std: : string.
Class_string.cpp
#include <iostream>
#include <string>
using namespace std;
void main()
{
setlocale (LC_CTYPE, "russian");
char name1[20]; //создание пустого массива
char name2[20]="jaguar"; //создание инициализированного массива
string str1; //создание пустого объекта строки
string str2="panther"; //создание инициализированного объекта строки
cout << "Введите животное из семейства кошачих: ";
cin >> name1;
cout << "Введите другое животное из семейства кошачих: ";
cin >> str1; //использование cin для ввода
cout << "Животные из семейства кошачих: " << name1 << " " << name2;
cout << " " << str1 << " " << str2 << endl;
cout << "Третья буква в " << name2 << ": " << name2[2] << endl;
cout << "Третья буква в " << str2 << ": " << str2[2] << endl;
cin.get();
}
Объект string можно использовать так же, как символьный массив.
• Объект string можно инициализировать строкой в стиле С.
• Чтобы сохранить клавиатурный ввод в объекте string, можно использовать сіn.
• Для отображения объекта string можно применять cout.
• Можно использовать нотацию массивов для доступа к индивидуальным символам, хранящимся в объекте string.
Главное отличие между объектами string и символьными массивами, заключается в том, что объект string объявляется как обычная переменная, а не массив:
string str1; // создание пустого объекта строки
string str2 = "panther"; // создание инициализированного объекта строки
Программа может автоматически обрабатывать изменение размера строк. Например, объявление str1 создает объект string нулевой длины, но при чтении ввода в str1 программа автоматически его увеличивает:
cin » str1; // str1 увеличен для того, чтобы вместить ввод
Это делает использование объекта string более удобным и безопасным по сравнению с массивом. Концептуально важным является то, что массив строк — это коллекция единиц хранения отдельных символов, служащих для сохранения строки, а класс string — единая сущность, представляющая строку.
Следующий код читает строку в объект string (возможность ввода строки с пробелами и др. символами):
getline (cin,str);
данная функция getline () не является методом класса. Поэтому она принимает объект сіп как аргумент, сообщающий о том, где искать ввод. К тому же нет аргумента, задающего размер строки, потому что объект string автоматически изменяет свой размер, чтобы вместить строку.
Инициализация строк
Как и можно было ожидать, C++11 позволяет осуществлять списковую инициализацию для строк в стиле С и объектов string:
char first_date[] = {"Le Chapon Dodu"};
char second_date[] {"The Elegant Plate"};
string third_date = {"The Bread Bowl"};
string fourth_date {"Hank's Fine Eats"};
Присваивание, конкатенация и добавление
Некоторые операции со строками класс string выполняет проще, чем это возможно в случае символьных массивов. Например, просто присвоить один массив другому нельзя. Однако один объект string вполне можно присвоить другому:
char charrl[20]; // создание пустого массива
char charr2[20] = "jaguar"; // создание инициализированного массива
string str1; // создание пустого объекта string
string str2 = "panther"; // создание инициализированной строки
charrl = charr2; // НЕ ПРАВИЛЬНО, присваивание массивов не разрешено
str1 = str2; // ПРАВИЛЬНО, присваивание объектов допускается
Класс string упрощает комбинирование строк. С помощью операции + можно сложить два объекта string вместе, а посредством операции += можно добавить строку к существующему объекту string. В отношении предшествующего кода у нас есть следующие возможности:
string str3;
str3 = strl + str2; // присвоить str3 объединение строк
strl += str2; // добавить str2 в конец strl
задача: сложение и добавление к объектам string других объектов string и строк в стиле С.
String_plus.cpp
#include <iostream>
#include <string>
using namespace std;
void main()
{
setlocale (LC_CTYPE, "russian");
string s1="пингвин";
string s2, s3;
//присваивание одного объекта другому
cout << "Вы можете присвоить один объект другому: s2=s1\n";
s2 = s1;
cout << "s1 = " << s1 << " , s2 = " << s2 << endl;
//присваивание строки в стиле С объекту string
cout << "Вы можете присвоить строку в стиле С объекту string\n";
cout << "s2 = \"попугай\"\n";
s2 = "попугай";
cout << "s2 = " << s2 << endl;
//Конкатенация строк
cout << "Вы можете объединить строки: s3=s1+s2\n";
s3 = s1+s2;
cout << "s3: " << s3 << endl;
//Добавление строк
cout << "Вы можете добавлять строки\n";
s1 += s2;
cout << "s1 = s1 + s2: " << s1 << endl;
s2 += " привет";
cout << "s2 = s2 + \" привет\": " << s2 << endl;
cin.get();
cin.get();
}
Дополнительные сведения об операциях класса string
Для строк в стиле С используются функции из стандартной библиотеки С. Эти функции поддерживаются заголовочным файлом cstring (бывший string.h). Например, вы можете применять функцию strcpy () для копирования строки в символьный массив, а функцию strcat () — для добавления строки к символьному массиву:
strcpy(charr1, charr2); // копировать charr2 в charrl
strcat(charr1, charr2); // добавить содержимое charr2 к charr1
#include <iostream>
#include <string> // обеспечение доступа к классу string
#include <cstring> // библиотека обработки строк в стиле С
int main ()
{
using namespace std;
char charr1[20];
char charr2[20] = "jaguar";
string str1;
string str2 = "panther";
// Присваивание объектов string и символьных массивов
strl = str2; // копирование str2 в str2
strcpy(charrl, charr2); // копирование charr2 в charrl
// Добавление объектов string и символьных массивов
strl += " paste"; // добавление " paste" в конец strl
strcat(charrl, " juice"); // добавление " juice" в конец charrl
// Определение длины объекта string и строки в стиле С
int lenl = str1.sizeO; // получение длины str1
int len2 = strlen(charr1); // получение длины charrl 1
cout « "The string " « strl « " contains " « len1 « " characters. \n";
cout << "The string " << charrl << " contains " « len2 « " characters. \n";
return 0;
}
Обратите внимание, что для получения количества символов в строкеиспользуется разный синтаксис:
int lenl = strl.sizeO; // получение длины strl
int Ien2 = strlen(charrl); // получение длины charrl
strlen () — это стандартная функция, которая принимает в качестве аргумента строку в стиле С и возвращает количество символов в ней. Функция size () обычно делает то же самое, но синтаксис ее вызова отличается. Вместо передачи аргумента ее имени предшествует имя объекта strl, отделенное точкой.
В данном конкретном случае str1 — объект string, a size () — метод класса string. Метод — это функция, которая может быть вызвана только объектом, принадлежащим классу, в котором определен данный метод.
Синтаксис работы с объектами string выглядит проще, чем использование строковых функций С. Это особенно проявляется при более сложных операциях. Например, эквивалент из библиотеки С следующего оператора:
str3 = strl + str2;
будет таким:
strcpy(charrЗ, charr1);
strcat(charrЗ, charr2);
Более того, при работе с массивами всегда существует опасность, что целевой массив окажется слишком малым для того, чтобы вместить всю информацию.
Например:
char site[10] = "house";
strcat(site, " of pancakes"); // проблема с нехваткой памяти
Функция strcat () пытается скопировать все 12 символов в массив site, таким образом, переполняя выделенную память. Это может вызвать аварийное завершение программы, или же программа продолжит работать, но с поврежденными данными. Класс string, с его автоматическим расширением при необходимости, позволяет избегать проблем подобного рода. Библиотека С предлагает функции, подобные strcat () и strcpy (), которые называются strncat () и strncpy (). Эти функции работают более безопасно, принимая третий параметр, который задает максимально допустимый размер целевого массива, но их применение усложняет написание программ.
Указатели и строки
Рассмотрим следующий код:
char flower[10] = "rose";
cout << flower << "s are red\n";
Имя массива — это адрес его первого элемента, потому flower в операторе cout представляет адрес элемента char, содержащего символ r. Объект cout предполагает, что адрес char — это адрес строки, поэтому печатает символ, расположенный по этому адресу, и затем продолжает печать последующих символов до тех пор, пока не встретит нулевой символ (\0). Короче говоря, вы сообщаете cout адрес символа, он печатает все, что находится в памяти, начиная с этого символа и до нулевого.
На заметку!
С объектом cout, как и в большинстве других выражений C++, имя массива char, указатель на char, а также строковая константа в кавычках — все интерпретируются как адрес первого символа строки.
// ptrstr.cpp -- использование указателей на строки
#include <iostream>
#include <cstring> // объявление strlen(), strcpy()
int main()
{
using namespace std;
char animal[20] = "bear"; // animal содержит bear
const char * bird = "wren"; // bird содержит адрес строки
char * ps; //не инициализировано
cout « animal << " and "; // отображение bear
cout « bird << "\n"; // отображение wren
// cout << ps << "\n"; // может отобразить мусор, но может вызвать и аварийное завершение программы
cout « "Enter a kind of animal: ";
cin » animal; // нормально, если вводится меньше 20 символов
// cin >> ps; очень опасная ошибка, чтобы пробовать; ps не указывает на выделенное пространство
ps = animal; // установка ps в указатель на строку
cout « ps « "!\n"; // нормально; то же, что и применение animal
cout « "Before using strcpy():\n";
cout << animal << " at " << (int *) animal << endl;
cout « ps « " at " « (int *) ps « endl;
ps = new char[strlen(animal) +1]; // получение нового хранилища
strcpy(ps, animal); // копирование строки в новое хранилище
cout « "After using strcpy():\n";
cout << animal << " at " << (int *) animal << endl;
cout « ps « " at " « (int *) ps « endl;
delete [] ps;
return 0;
}
Вывод:
bear and wren
Enter a kind of animal: fox
fox!
Before using strcpyO :
fox at 0x0065fd30
fox at 0x0065fd30
After using strcpyO :
fox at 0x0065fd30
fox at 0x004301c8
Инициализация указателя на char строкой:
const char * bird = "wren"; // bird содержит адрес строки
Вспомните, что "wren" на самом деле представляет собой адрес строки, поэтому приведенный выше оператор присваивает адрес "wren" указателю bird. Это значит, что указатель bird можно применять так же, как использовалась бы строка "wren", например:
cout << "A concerned " « bird « " speaks\n";
Строковые литералы являются константами; именно поэтому в объявлении присутствует ключевое слово const. Применение const, таким образом, означает, что вы можете использовать bird для доступа к строке, но не можете изменять ее.
Неинициализированный указатель не может указывать ни на какую строку!
Нельзя применять для ввода указатель! Строковые литералы являются константами! Не использовать для ввода строковые константы и неинициализированные указатели!
Внимание!
При вводе строки внутри программы всегда необходимо использовать адрес ранее распределенной памяти. Этот адрес может иметь форму имени массива либо указателя, инициализированного с помощью операции new.
Далее обратите внимание на то, что делает следующий код:
ps = animal; // установить в ps указатель на строку
…..
cout « animal « " at " « (int *) animal << endl;
cout « ps « " at " « (int *) ps « endl;
Он генерирует следующий вывод:
fox at 0x0065fd30
fox at 0x0065fd30
Обычно если объекту cout передается указатель, он печатает адрес. Но если указатель имеет тип char *, то cout отображает строку, на которую установлен указатель. Если вы хотите увидеть адрес строки, для этого потребуется выполнить приведение типа к указателю на другой тип, такой как int *, что и делает показанный код. Поэтому ps отображается как строка "fox", но (int *) ps выводится как адрес, по которому эта строка находится. Присваивание animal переменной ps не копирует строку; оно копирует только адрес. В результате два указателя (animal и ps) указывают на одно и то же место в памяти — т.е. на одну строку.
Ролучение копии строки с помощью операции new, такой подход позволяет точно настроить размер хранилища для строки:
ps = new char[strlen(animal) + 1]; // получить новое хранилище
Здесь же мы видим использование strlen () для нахождения длины строки, а затем к найденной длине прибавляется единица, чтобы получить длину, включающую нулевой символ. Далее программа применяет new для выделения достаточного пространства под хранение строки.
strcpy(ps, animal); // скопировать строку в новое хранилище
Функция strcpy () принимает два аргумента. Первый представляет собой целевой адрес, а второй — адрес строки, которую следует скопировать. Ваша обязанность — обеспечить, чтобы место назначения действительно смогло вместить копируемую строку. Здесь это достигается использованием функции strlen () для определения корректного размера и применением операции new для получения свободной памяти. За счет использования strlen () и new получены две отдельных копии "fox":
fox at 0x0065fd30
fox at 0x004301c8
Копирование строки в массив
Вы уже видели функцию strcpy (); она работает следующим образом:
char food[20] = "carrots"; // инициализация
strcpy(food, "flan"); // альтернатива
Обратите внимание, что следующий подход может послужить причиной проблем, если массив food окажется меньше, чем строка:
strcpy(food, "a picnic basket filled with many goodies");
Чтобы избежать такой проблемы, вместо strcpy () вы должны применять strncpy (). Эта функция принимает третий аргумент — максимальное количество копируемых символов. Однако при этом имейте в виду, что если данная функция исчерпает свободное пространство еще до достижения конца строки, то нулевой символ она не добавит. Потому применять ее нужно так:
strncpy(food, "a picnic basket filled with many goodies", 19) ;
food[19] = ' \0';
Этот код копирует до 19 символов в массив, после чего устанавливает последний элемент массива в нулевой символ. Если строка короче, чем 19 символов, то strncpy () добавит нулевой символ ранее, пометив им действительный конец строки.
На заметку!
Для копирования строки в массив применяйте strcpy () или strncpy (), а не операцию присваивания
«ШАГ»
Строковая константа - это последовательность из нуля или более символов, заключенных в кавычки. Кавычки не являются частью строковой константы, а служат только для ее ограничения.
Строки представляются в виде массива элементов типа char. Это означает, что символы строки можно представить расположенными в соседних ячейках памяти - по одному символу в ячейке. Но массив символов - не всегда строка!
В качестве примера рассмотрим следующую строку: "Символьная строка". Кавычки не являются частью строки. Они вводятся для того, чтобы отметить ее начало и конец, то есть играют ту же роль, что и апострофы в случае одиночного символа (каждая ячейка - 1 байт).
Необходимо отметить, что на рисунке последним элементом массива является символ '\0'. Это нуль-символ: в языке C он используется для того, чтобы отмечать конец строки. Нуль-символ - не есть цифра 0; он не выводится на печать и в таблице кодов ASCII имеет номер 0. Наличие нуль-символа означает, что количество ячеек массива должно быть, по крайней мере на одну больше, чем количество символов, которые необходимо размещать в памяти.
Не следует путать символьную константу со строкой, содержащей один символ: 'Х' - это не то же самое, что "Х". В первом случае - это отдельный символ. Во втором случае - это строка, состоящая из одного символа (буквы Х) и символа конца строки '\0'.
Правила инициализации строковых массивов.
Приведем пример инициализации строкового массива:
#include <iostream> using namespace std; int n=5; // Инициализация строкового массива.
char line[5] = { 'C','a','t','!','\0' }; void main () { cout << "Word: "; for (int i=0; i<n; i++) cout << line[i]; } |
Вышеописанный пример не слишком удобен для создания длинных строк. Кроме того, вывод строки побуквенно в цикле выглядит довольно странно, не так ли? Для символьных массивов существует специальный способ инициализации. Вместо фигурных скобок и запятых можно прямо использовать строку символов, заключенных в кавычки. При этом в описании не обязательно задавать размеры массива, поскольку компилятор "сам" определяет его длину, подсчитывая число начальных значений. А операция вывода cout настроена таким образом, что достаточно указать только имя строкового массива и он тут же отобразится на экране.
#include <iostream> using namespace std; int n=5; char line[] = "Cat!"; // Инициализация строкового массива.
void main () { cout << "Word: "; // Показ на экран строкового массива. cout <<line; } |