Структура данных. Объединения. Строковые литералы

Размещено на http://www.allbest.ru

Лекция №5. Структура данных. Объединения. Строковые литералы

Содержание

Типы строк в С++

Чтение внутренних пробелов

Считывание нескольких строк

Понятие структуры данных и объединения

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

Строки в С++ позволяют нам работать с символьными данными. Благодаря им мы можем читать с клавиатуры текст, как-то его обрабатывать и затем, например, снова его выводить в консоль.

В С++ существует 2 типа строк.

Первый из них - это массив переменных типа char.

Если кто не помнит, то переменная типа char хранит в себе 1 символ. Размер такой строки равняется размеру массива - 1, т.к. последний элемент содержит NULL (пустая переменная без значения), который обозначает символ конца строки.

Например:

char name[50];

cin>>name;

cout<<"Hello "<<name<<endl;

Второй из вариантов, более удобный - это специальный класс string

Для его работы необходимо в начале программы подключить заголовочный файл string:

#include <string>

В отличии от типа char, string является классом. Более подробно об классах я расскажу позднее, сейчас вам достаточно знать, что классы содержат в себе сразу несколько вещей: переменные, константы и функции для работы с переменными. Это достаточно грубое объяснение, но на первое время вам хватит.

Для создания строки вам необходимо в начале программы написать using namespace std;

Теперь чтоб создать строку достаточно написать:

string s;

Для записи в строку можно использовать оператор =

s="Hello";

Пример работы с классом string:

string name;

cout<<"Enter your name"<<endl;

cin>>name;

cout<<"Hi "<<s<<"!"<<endl;

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

s.append(str) - добавляет в конец строки строку str. Можно писать как s.append(переменная), так и s.append("строка");

s.assign(str) - присваивает строке s значение строки str. Аналогично записи s=str;

int i=s.begin() - записывает в i индекс первого элемента строки

int i=s.end() - аналогично, но последнего

s.clear() - как следует из названия, отчищает строку. Т.е. удаляет все элементы в ней

s.compare(str) -сравнивает строку s со строкой str и возвращает 0 в случае совпадение (на самом деле сравнивает коды символов и возвращает из разность)

s.copy(куда, сколько, начиная с какого) - копирует из строки s в куда (там может быть как строка типа стринг, так и строка типа char). Последние 2 параметра не обязательные (можно использовать функцию с 1,2 или 3 параметрами)

bool b=s.empty() - если строка пуста, возвращает true, иначе false

s.erase(откуда, сколько) удаляет n элементов с заданной позиции

s.find(str,позиция) - ищет строку str начиная с заданной позиции

s.insert(позиция,str, начиная, beg, count) - вставляет в строку s начиная с заданной позиции часть строки str начиная с позиции beg и вставляя count символов

int len=s.length() - записывает в len длинну строки

s.push_back(symbol) - добавляет в конец строки символ

s.replace(index, n,str) - берет n первых символов из str и заменяет символы строки s на них, начиная с позиции index

str=s.substr(n,m) - возвращает m символов начиная с позиции n

s.swap(str) меняет содержимое s и str местами.

s.size() - возвращает число элементов в строке.

Вот собственно большинство необходимых функция для работы со строками в с++. Набор достаточно неплохой, больше вам пока не понадобится.

Теперь немного примеров и затем практика. Постарайтесь сами понять, что делает каждый пример

string name,surname,text,fullname,s1,s2,s3,user;

user="Petya Petrov";

cout<<"Enter your name"<<endl;

cin>>name;

cout<<"Enter your surname"<<endl;

cin>>surname;

fullname=name;

fullname+=" "; // добавляем пробел

fullname.append(surname);

if (fullname.compare(user)==0)

cout<<"Your are good user"<<endl;

else

cout<<"Bad user"<<endl;

cout<<"enter s1"<<endl;

cin>>s1;

cout<<"enter s2"<<endl;

cin>>s2;

s1.swap(s2);

cout<"new s1: "<<s1<<endl<<"new s2: "<<s2<<endl;

cout<<"Enter big text with your name"<<endl;

cin>>text;

int i=0;

i=text.find("name");

while (i!=-1)

{

text.replace(i,name.length(),name);

s3=text.substr(i,name.length());

cout<<"Replaced: "<<s3<<endl;

i=text.find("name");

}

cout<<"New text:"<<endl<<text<<endl;

text.clear();

cout<<"text: "<<text<<endl;



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

Чтение внутренних пробелов

#include <iostream.h>

main()

{

char s[150];

cout<<"Vvedite stroky"<<endl;

cin>>s;

cout<<"Vu vveli"<<endl;

cout<<s<<endl;

}

#include <iostream.h>

main()

char s[]="Ya pamyatnik, sebe vozdvig nerykotvornui";

cout<<s<<endl;

}

Если мы введем строку, содержащую больше одного слова, то вы увидите только первое слово, а остальных не будет. Оказывается, что операция >> считает пробел нулевым символом. Таким образом, он считывает строки, состоящие из одного слова, и что-либо, напечатанное после пробела, отбрасывается.

Для считывания строк, содержащих пробелы, используем метод - cin.get(). Этот синтаксис означает использовать метод get() класса stream для его объекта cin.

#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////

int main ( )

{

const int MAX = 80; // максимальная длина строки

char str [ MAX]; // сама строка

cout << "\nVvedite stroky: ";

cin.get ( str, MAX );

cout << "Vu vveli: " << str << endl;

return 0;

}

При использовании этого метода строка сохранится полностью.

Считывание нескольких строк

Оказывается метод cin.get() может иметь третий аргумент, который пригодится нам в этой ситуации. Этот аргумент определяет символ, на котором метод завершает считывание строки. Установленным по умолчанию значением этого аргумента является символ новой строки (`\n'), но если вы вызовете метод с другим аргументам, то это значение заменится на введенный вами символ

В нашем следующем примере, мы вызовем этот метод с символом доллара `$' в качестве третьего аргумента:

#include <iostream>

using namespace std;

const int MAX = 2000; // максимальная длина строки

char str [ MAX ]; // сама строка

///////////////////////////////////////////////////////////

int main ( )

{

cout << "\nВведите строку:\n";

cin.get ( str, MAX, '$' );

cout << "Вы ввели:\n" << str << endl;

return 0;

}

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

Копирование строк

#include <iostream>

#include <cstring>

using namespace std;

///////////////////////////////////////////////////////////

int main ( )

{

/ исходная строка

char str1 [ ] = "Маленькой елочке холодно зимой.";

const int MAX = 80; // максимальная длина строки

char str2 [ MAX ]; // сама строка

for ( int j = 0; j < strlen ( str1 ); j++ ) // копируем strlen ( str1 )

str2 [ j ] = str1 [ j ]; // символов из str1 в str2

str2 [ j ] = '\0'; // завершаем строку нулем

cout << str2 << endl; // и выводим на экран

return 0;

}

Понятие структуры данных и объединения

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

Объявление структуры имеет вид:

struct [имя типа] {

поле №1;

поле №2;

...

поле №N;

} [список переменных];

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

ПРИМЕЧАНИЕ: Объявление полей структуры возможно только без инициализации. Если несколько полей следующих друг за другом в описании структуры имеют один и тот же тип, то для их описания можно использовать синтаксис объявления нескольких переменных одного и того же типа. Типом поля может быть любой тип (как системный, так и пользовательский), описанный ранее.

Примеры структур:

Структура, содержащая информацию о точке в двумерном пространстве (координаты):

struct Point{double x,y;};

Структура, содержащая информацию об окружности (координаты центра и радиус):

struct Circle{

double x, y, radius;

};

Структура, содержащая информацию о студенте (фамилия, имя, отчество, номер зачетной книжки, средний балл):

struct Student{

char surname[15], name[15], patronymic[15];

unsigned number;

double rate;

};

Структура, содержащая информацию о группе студентов (название группы, количество студентов, список студентов (максимально 30)):

struct Group{

char name[10];

unsigned number;

struct Student list[30];

};

Объявление переменной определенной структуры осуществляется после описания данной структуры в следующем виде:

struct тип имя №1[= значение №1][,...];

Объявление начинается с ключевого слова struct, за которым указывается имя типа структуры, описанной ранее. Затем указывается имя переменной и, необязательно, инициализирующее значение. Далее через запятую указываются имена и инициализирующие значения переменных данной структуры. После последнего объявления ставится точка с запятой. Инициализирующее значение указывается в следующем виде: в фигурных скобках приводится список инициализирующих значений полей структуры в том порядке, в котором они указаны при объявлении самой структуры.

Например:

struct Point pnt[3] = {{0,0},{1,0},{0,1}};

struct Circle c1 = {10.0,10.0,5.0},

c2 = {0.0,0.0,25.0};

struct Student st

= {“Иванов”,”Иван”,”Иванович”,959623,7.5};

struct Group gr ={

“97-BC”, 3, {

{“Иванов”, ”Иван”, ”Иванович”, 979601,8.0},

{“Петров”, ”Петр”, ”Петрович”, 979602,6.5},

{“Сидоров”,”Сидор”,”Сидорович”,979603,9.0}

}

};

Как уже показано в примерах структур Student и Group поля структур могут быть сложными типами данных, в том числе и вложенными структурами. На практике обычно используются не более двух вложений структур.

От обязательно использования ключевого слова struct можно отказаться, если описывать структуру, используя оператор объявления типа typedef в следующем виде:

typedef struct [первичное имя типа] {...} имя типа;

ПРИМЕЧАНИЕ: Первичное имя типа, указываемое перед перечнем полей структуры является необязательным и указывается редко. Как правило, первичное имя типа имеет тот же идентификатор, что и основное имя типа, но начинается со знака подчеркивания.

Например, структура, содержащая информацию о книге (ФИО автора, название книги, год издания):

typedef struct {

char author[20], title[50];

unsigned year;

} BOOK;

Объявление переменной данного типа:

BOOK book = {“А. Дюма”,”Три мушкетера”, 1986};

Обращение к полям структуры осуществляется в следующем виде:

имя_переменной.имя_поля

Сначала указывается имя переменной структуры, а затем, через точку, имя поля. С точки зрения языка С при таком обращении к полю его значение может выступать как LValue, так и RValue значения.

Например:

Вычисление длины окружности, заданной переменной cir типа Circle:

double length = 2.0*3.1415*cir.radius;

Ввод информации о студенте в переменную st типа Student:

scanf(“%s %s %s %u %lf”, &st.surname, &st.name,

&st.patronymic, &st.number, &st.rate);

Вывод на экран списка группы, заданной в переменой gr типа Group:

printf(“Группа: %s\n”,gr.name);

for(unsigned i=0;i<gr.number;i++)

printf(“%2u: %15s %15s %15s %6u %.1lf\n”,

i+1, gr.list[i].surname, gr.list[i].name,

gr.list[i].patronymic, gr.list[i].number,

gr.list[i].rate);

Для определения размера переменной структурного типа в байтах используется оператор определения типа sizeof. Например:

unsigned size = sizeof(struct Student); //size == 57

Объединение - это сложный тип данных представляющий собой множество элементов различного типа, хранящихся по одному адресу. Каждый элемент в объединении имеет свое имя и называется полем. Элементы в объединении располагаются на одном и том же пространстве памяти, перекрывая друг друга. Размер объединения определяется размером самого большого по размеру элемента.

Объявление объединения имеет вид:

union [имя типа] {

поле №1;

поле №2;

...

поле №N;

} [список переменных];

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

Объявление переменных объединения имеет тот же синтаксис, что и для объявления переменных структур. Отличие состоит в том, что инициализировать значение объединения можно только значением первого поля. Например:

union VALUE{

unsigned num;

double val;

char str[20];

};

union VALUE val = {0};

структура данные строка

Так же как и со структурами, для объединения можно создать свой тип данных, используя оператор typedef:

typedef union [первичное имя типа] {...} имя типа;

Обращение к полям объединения имеет тот же синтаксис, что и обращение к полям структуры. При обращении к полю объединения данная конструкция может рассматриваться и как LValue и как Rvalue значения.

Определение размера памяти, занимаемого значением типа объединение, осуществляется оператором sizeof. Например:

unsigned size = sizeof(union VALUE); //size == 20

Как правило, объединения используются совместно со структурами. Рассмотрим, например, структуру для хранения одного из значений (символ, незнаковый символ, короткое целое число, короткое целое незнаковое число, целое число, целое незнаковое число, длинное целое, длинное незнаковое целое, вещественное число одинарной точности, вещественное число двойной точности):

typedef enum {

INT_8 = 0, //символ

UINT_8, //незнаковый символ

INT_16, //короткое целое

UINT_16, //короткое незнаковое целое

INT_32, //целое

UINT_32, //незнаковое целое

INT_64, //длинное целое

UINT_64, //длинное незнаковое целое

FLOAT_32, //одинарное вещественное

FLOAT_64, //двойное вещественное

FLOAT_80 //длинное вещественное

} TYPE;

typedef union{

char int8; //символ

unsigned char uint8; //незнаковый символ

short int16; //короткое целое

unsigned short uint16; //короткое незнаковое целое

int int32; //целое

unsigned uint32; //незнаковое целое

long long int64; //длинное целое

unsigned long long uint64;//длинное незнаковое целое

float float32; //одинарное вещественное

double float64; //двойное вещественное

long double float80; //длинное вещественное

} VALUE;

typedef struct {

TYPE type;

VALUE value;

} VARIANT;

В приведенном примере сначала в перечислении TYPE задаются возможные типы хранимых значений. Далее описывается объединение VALUE, в котором содержатся поля всех перечисленных типов. И в завершении описывается структура VARIANT, которая содержит два элемента: тип хранимого значения type (перечисление TYPE) и само значение value (объединение VALUE). Таким образом, переменная типа VARIANT позволяет хранить значение любого типа из системы базовых типов языка С. Размер данной переменной составляет 14 байт: 4 байта поле type, 10 байт поле value (10 байт - размер самого большого поля типа long double). Если при реализации типа VARIANT не использовать объединение, а все поля описывать внутри структуры, то размер переменной данного типа будет составлять 52 байта, что значительно больше.

ПРИМЕЧАНИЕ: Тип VARIANT широко используется в программировании на основе технологии COM (Component Object Model) для передачи данных различного типа между компонентами.

Работа с переменной типа VARIANT осуществляется в два действия:

обращение к полю type (тип TYPE) для установления типа хранимого значения;

обращение к элементу объединения VALUE (поле value) установленного типа.

Например, запись в переменную val типа VARIANT целого числа 150 будет иметь вид:

val.type = INT_32;

val.value.int32 = 150;

Более сложный пример, вывести на экран значение переменной val типа VARIANT:

switch(val.type){

case INT_8: printf("%d",val.value.int8); break;

case UINT_8: printf("%u",val.value.uint8); break;

case INT_16: printf("%hd",val.value.int16); break;

case UINT_16: printf("%hu",val.value.uint16); break;

case INT_32: printf("%d",val.value.int32); break;

case UINT_32: printf("%u",val.value.uint32); break;

case INT_64: printf("%lld",val.value.int64); break;

case UINT_64: printf("%llu",val.value.uint64); break;

case FLOAT_32: printf("%f",val.value.float32); break;

case FLOAT_64: printf("%lf",val.value.float64);break;

case FLOAT_80: printf("%Lf",val.value.float80);break;

}

В приведенном примере используется оператор switch для определения типа хранимого значения. В каждом операторе case осуществляется вывод значения в соответствии с его типом.

Битовое поле - последовательность бит длиной до 32 бит. В языке С битовое поле может быть только элементом структуры или объединения. С точки зрения значения битовое поле рассматривается как целочисленная величина соответствующего размера.

Описание битового поля имеет вид:

[unsigned | int] имя:размер;

Объявление битового поля начинается с типа: целое (int) или незнаковое целое (unsigned). Другие типы запрещены. Далее указывается имя поля (идентификатор уникальный в пределах данной структуры) и через знак двоеточия указывается размер (или ширина) битового поля (число от 1 до 32).

В зависимости от того, какой тип данных был указан (int или unsigned) битовое поле будет знаковым или незнаковым. Например, объявим следующую структуру с двумя битовыми полями:

typedef struct{ typedef struct{

int a:4; int a:24;

unsigned b:4; unsigned b:24;

} BITFIELD1; } BITFIELD2;

Диапазон значений принимаемых полем a структуры BITFIELD1 - [-8,7], а поля b - [0,15]. Диапазон значений принимаемых полем a структуры BITFIELD2 - [-8388608, 8388607], а поля b - [0, 16777216].

Следует учитывать, что сумма длин всех битовых полей следующих в описании структуры друг за другом округляется до числа кратного четырем. Например, размер приведенной структуры BITFIELD1 равняется не одному, а четырем байтам. Размер структуры BITFIELD2 - 8 байтам.

На практике битовые поля в основном применяются для эффективного хранения информации. Рассмотрим, например, структуру содержащую информацию о человеке:

фамилия, имя, отчество (строки по 15 символов);

дата рождения (в формате дд.мм.гггг);

пол (М | Ж);

номер мобильного телефона (семизначное число);

номер домашнего телефона (шестизначное число);

почтовый индекс города (шестизначное число);

названия города и улицы (строки по 15 символов);

номера дома и квартиры (целые числа).

Приведем две реализации данной структуры: слева - без использования битовых полей, справа - с использованием.

typedef struct{ typedef struct{

char surname[15], char surname[15],

name[15], name[15],

patronymic[15]; patronymic[15];

char sex; unsigned sex:1;

unsigned char day, month; unsigned day:5, month:4;

unsigned short year; unsigned year:14;

unsigned char mobile[7], unsigned mobile:24,

home_tel[6]; home_tel:20;

unsigned short house, unsigned house:10,

flat; flat:10;

unsigned char index[6]; unsigned index:20;

char town[15], street[15]; char town[15], street[15];

} MAN1; } MAN2;

Поля surname, name и patronymic - фамилия, имя и отчество соответственно. Поля town и street - названия города и улицы соответственно. Поле sex - пол человека, для его кодирования достаточно одного бита (например, 0 - мужской, 1 - женский). Поле day - число месяца (от 1 до 31), для его кодирования достаточно 5 бит. Поле month - месяц (от 1 до 12), для его кодирования достаточно 4 бита. Поле year - год (от 1 до 9999), для его кодирования достаточно 14 бит. Поле mobile - номер мобильного телефона (число от 1 до 9999999), для его кодирования достаточно 24 бит. Поле home_tel - номер домашнего телефона (число от 1 до 999999), для его кодирования достаточно 20 бит. Поле house - номер дома (число от 1 до разумного предела, например 1000), для его кодирования достаточно 10 бит. Поле flat - номер квартиры (число от 1 до разумного предела, например 1000), для его кодирования достаточно 10 бит. Таким образом, размер структуры MAN1 (без использования полей бит) составляет 104 байта, а структуры MAN2 (с использованием полей бит) - 96 байт.

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

Ну а теперь, как всегда, немного практики;)

Упражнения

Задачи для строк типа char:

Подсчитать количество символов с строке (строка кончается элементом 0: c=0 if(c==0) cout<<"end"<<endl;

Выяснить находится ли в строке символ «к», если есть, то сколько их находиться в строке.

#include <iostream.h>

main()

{

char s[150];

cout<<"Vvedite ctroky na konce 0"<<endl;

cin>>s;

int k=0;

for(int i=0; s[i]; i++)

{

if(s[i]!=0)

k=k+1;

}

cout<<k<<endl;

}

#include <iostream.h>

main()

{

char s[150];

cout<<"Vvedite ctroky"<<endl;

cin>>s;

int k=0;

for(int i=0; s[i]; i++)

{

if(s[i]=='k')

k=k+1;

}

if (k==0)

cout<<"Takix bykv net"<<endl;

cout<<k<<endl;

}

Задачи для строк типа string:

Вводят текст и два слова, заменить все слова 1 на слова 2 и все слова 2 на слова 1

Вводят имя и текст, вывести все вхождения имени в текст (имя + 5 символов до и 5 символов после него)

Вводят 2 текста. Сравнить их, объединить, вывести все пробелы, точки, запятые, двоеточия. Затем вывести размер каждого текста и общий размер. Затем поменять все буквы «а» на «о» и «к» на «х». Потом вывести количество замен.

Размещено на www.allbest.ru