Тема : Основы программирования на С++.

1.Введение

2.Структура программы

3. Директивы препроцессора и комментарии

4.Стандартные типы данных в C++

5.Операции ввода и вывода данных в C++

6.Преобразования типов данных в C++

7.Арифметические операции

8.Пользовательские типы данных в C++: структуры

1.Введение

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

В данной теме рассматриваются основы C++:

· структура программы

· переменные

· базовые операции ввода/вывода

· комментарии

· арифметические операции

· операции инкремента

· преобразование типов

· библиотечные функции.

2.Структура программы

Рассмотрим самый простой, пример программы на C++, которая просто выводит текст сообщения на экран.

#include <iostream>

using namespace std;

int main()

{

cout << "Я учусь программировать в C++\n";

return 0;

}

Несмотря на свой небольшой размер, этот пример демонстрирует типичную структуру программы на C++. Рассмотрим эту структуру в деталях. Функции представляют собой основу, на которой строится любая программа C++. Данная программа состоит из единственной функции с названием main ().

В состав этой функции не входят две первые строчки кода, начинающиеся со слов #include и using. Как известно, функция может входить в состав класса, и в этом случае она называется методом класса. Функции могут существовать и отдельно от классов. Пока будем рассматривать лишь функции, которые являются независимыми, как функция main() в примере.

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

Тело функции. Тело функции заключено в фигурные скобки. Они определяют границы блока операторов программы. Фигурные скобки, обрамляющие тело функции, обязательны. В примере тело функции состоит всего лишь из двух операторов: один из них начинается словом cout, другой - словом return.

Функция main(). Когда программа на языке C++ запускается на выполнение, первым исполняемым оператором становится первый оператор функции main(). Программа может состоять из множества функций, классов и прочих элементов, но при ее запуске управление всегда передается функции main(). Если в программе не содержится функции с именем main(), то при попытке запустить такую программу будет выведено сообщение об ошибке. В программах на C++ реальные действия, выполняемые этими программами, сводятся к вызову функцией main() методов различных объектов. Кроме того, функция main() может вызывать другие, независимые функции.

Операторы. Оператор является структурной единицей программы на C++. В примере содержатся 2 оператора:

1. cout << "Я учусь программировать в C++\n";

2. return 0;

Первый оператор задает действие по выводу фразы, заключенной в кавычки, на экран. Большинство операторов являются указаниями компьютеру совершить какое-либо действие. Окончание оператора обозначается знаком «точка с запятой» - является обязательным. Оператор return 0; является указанием функции main() возвратить значение 0 вызывающему окружению; в данном случае это может быть компилятор или операционная система. К разделяющим знакам относятся пробелы, символы возврата каретки и перехода на другую строку и др.Эти символы не обрабатываются компилятором. Можно записать несколько операторов на одной строке, разделить их любым количеством пробелов, табуляций или пустых строк, и компилятор во всех случаях обработает их одинаково. Есть несколько исключений из общего правила, когда компилятор обрабатывает разделяющие символы. Первое исключение - строка #include программного кода, являющаяся директивой препроцессора и записывающаяся в одну строку. Строковые константы, такие, как "Я учусь программировать в C++\n", нельзя разбивать на несколько строк кода.

3 Директивы препроцессора и комментарии

Первые две строки, с которых начинается пример, являются директивами. Директивы нельзя считать частью языка C++, однако их использование является необходимым. Строка #include <iostream> называется директивой препроцессора - указанием компилятору включить в компилируемый файл содержимое другого файла. Препроцессором называется специальная часть компилятора, обрабатывающая подобные директивы перед началом процесса компиляции кода.#include является одной из многих директив препроцессора, каждая из которых предваряется символом #. Файл, включаемый с помощью директивы #include, обычно называют заголовочным файлом.

Заголовочные файлы. В примере директива #include является указанием включить в исходный текст содержимое файла iostream перед компиляцией кода. iostream является примером заголовочного файла - содержит описания, необходимые для работы с переменной cout и операцией <<. Без этих описаний компилятору не будет известно, что значит имя cout, а употребление операции << будет воспринято как некорректное. Существует множество заголовочных файлов. В C++ заголовочные файлы не имеют расширения.

Директива using. Каждую программу на C++ можно разбить на несколько так называемых пространств имен. Пространством имен называется область программы, в которой распознается определенная совокупность имен. Эти имена неизвестны за пределами данного пространства имен. Директива using namespace std; означает, что все определенные в программе имена будут относиться к пространству имен с именем std. Различные элементы программы описаны с использованием пространства имен std, например переменная cout. Если не использовать директиву using, то к этим элементам программы придется каждый раз добавлять имя std: std::cout << "Я учусь программировать в C++\n";

Директива using. Каждую программу на C++ можно разбить на несколько так называемых пространств имен.

Пространством имен называется область программы, в которой распознается определенная совокупность имен.Эти имена неизвестны за пределами данного пространства имен. Директива using namespace std; означает, что все определенные в программе имена будут относиться к пространству имен с именем std.Если не использовать директиву using, то к этим элементам программы придется каждый раз добавлять имя std:

std::cout << "Я учусь программировать в C++\n";

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

Дополним пример комментариями.

#include <iostream> //директива препроцессора

using namespace std; //директива using

int main() //функция с именем main

{ //начало тела функции

cout << "У каждой эпохи свой язык\n«; //оператор

return 0; //оператор

} //конец тела функции

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

Комментарии рекомендуется использовать, чтобы человек, читающий листинг программы, понимал механизм работы программы. Задача комментариев - дать общие пояснения функционирования отдельных блоков программы.

4 Стандартные типы данных в C++

Переменные являются фундаментальной частью любого языка. Каждая переменная имеет имя и может принимать различные значения. Переменные хранятся в определенных участках памяти. Когда переменной присваивается значение, оно записывается в ячейку памяти, связанную с данной переменной. Большинство языков программирования поддерживают определенный набор типов переменных, в который входят целые, вещественные и символьные типы.

Нужно четко знать разницу между терминами определение переменной и объявление переменной. Объявление переменной предполагает указание имени переменной (например, var1) и ее типа (int и т. д.). Если при объявлении переменной одновременно выделяется память под нее, то происходит определение переменной. Операторы int var1; int var2; являются и объявлениями, и определениями, поскольку выделяется память под переменные var1 и var2. В программах чаще употребляют определения.

Имя переменной. В приведенном примере используются переменные с именами var1 и var2. Имена, даваемые переменным и другим элементам программы, называются идентификаторами.

При составлении идентификатора используются буквы и нижнего и верхнего регистров, цифры от 0 до 9, и символ подчеркивания _.

Первый символ идентификатора должен быть либо буквой, либо символом подчеркивания. Длина идентификатора теоретически не ограничивается, но большинство компиляторов не распознают идентификаторы длиной более 64 символов. Компилятор различает буквы верхнего и нижнего регистра, поэтому имена Var и VAR будут восприниматься как различные. В качестве имен переменных в C++ нельзя использовать ключевые слова. Ключевое слово - это зарезервированное слово, имеющее особое значение. Примерами ключевых слов могут служить int, class, if, while. Желательно, чтобы имя переменной отражало смысл ее содержимого.

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

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

Распространенным является тип int, размер переменной этого типа является системно-зависимым.

В 32-разрядных ОС размер переменной int равен 4 байтам (32 битам), что позволяет хранить в переменной типа int значения от -2 147 483 648 до 2 147 483 647.

Фрагмент программы, использующей переменные типа int:

int var1; //описание переменной var1

int var2; //описание переменной var2

var1 =20; //присвоение значения переменной var1

var2 = var1 +10; //присвоение значения переменной var2

cout << "var1+10 равно "; //вывод строки

cout << var2 << endl; //вывод значения переменной var2

Операторы int var1; int var2; определяют две целые переменные var1 и var2. Ключевое слово int определяет тип переменной. Подобные операторы, называемые объявлениями, должны разделяться точкой с запятой (;), как и любые другие операторы программы. Перед тем как воспользоваться переменной, обязательно нужно объявить ее. Объявления переменных могут располагаться в любом месте программы. Не обязательно делать все объявления переменных до появления первого исполняемого оператора. Тем не менее, объявления наиболее часто употребляемых переменных целесообразно производить в начале программы, чтобы обеспечить ее удобочитаемость. Операция присваивания. Операторы

var1 = 20;

var2 = var1 + 10;

- присваивают значения переменным var1 и var2.

- знак = означает присваивание значения, стоящего в правой его части, переменной, стоящей в левой части.

- переменной var1, до этого не имевшей значения, присваивается значение 20.

- константы сохраняют свое значение на протяжении всего выполнения программы.

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

- оператор cout << "var1+10 равно "; выводит на экран строковую константу, а оператор cout << var2 << endl; отображает значение переменной var2.

- операция << и объект cout знают, каким образом отличать целое число от строки и как обрабатывать каждое из них.

- если выводится на экран целое число, то оно отображается в числовом формате, а при выводе строки она отображается в виде текста.

- это кажется очевидным, но за этими действиями стоит механизм перегрузки операций, типичный для C++.

Пример программы

#include <iostream.h>

int main()

int year_now, age_now, another_year, another_age;

cout << "Введите текущий год и нажмите ENTER.\n";

cin >> year_now;

cout << "Введите свой возраст (в годах).\n";

cin >> age_now;

cout << "Введите год, для которого вы хотите узнать свой возраст.\n";

cin >> another_year;

another_age = another_year - (year_now - age_now);

if (another_age >= 0)

{

cout << "В " << another_year << " году вам будет ";

cout << another_age << "\n";

}

else {

cout << "В " << another_year << " вы еще не родились!\n"; }

return 0;

}

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

После компиляции программы ее можно запустить на выполнение. Результат выполнения на экране будет выглядеть примерно так:

• Введите текущий год и нажмите ENTER.

• 2008

• Введите свой возраст (в годах).

• 21

• Введите год, для которого вы хотите узнать свой возраст.

• 2017

• В 2017 году вам будет 29

Другие целые типы

Существует также еще несколько целых типов: long и short. Переменные типов long и short имеют фиксированный размер, не зависящий от используемой системы. Размер типа long всегда равен 4 байтам и совпадает с размером типа int в случае 32-разрядных систем. Тип long может быть описан как long int: между двумя такими описаниями нет разницы. Тип short имеет размер, равный двум байтам. Диапазон значений типа short - от -32 768 до 32 767. Обработка переменных типа int происходит быстрее по сравнению с типом short. Если необходимо описать константу типа long, то после ее значения следует указать символ L: long var = 7678L; // описание константы var типа long

Символьные переменные хранят целые числа, содержащиеся в диапазоне от -128 до 127. Размер памяти, занимаемый такими переменными, равен 1 байту.

Иногда символьные переменные используют для представления целых чисел, заключенных в указанном диапазоне, но гораздо чаще в таких переменных хранятся ASCII-коды символов.

Таблица ASCII-кодов предназначена для интерпретации символов как чисел. Эти числа заключены в диапазоне от 0 до 127.

Операционные системы Windows расширяют верхнюю границу этого диапазона до 255 для того, чтобы включить в ASCII-таблицу символы национальных алфавитов и псевдографические символы.

Переменные типа "char" существенно отличаются от "int" при выполнении ввода данных с клавиатуры и вывода на экран.

Символьный тип

Программа для печати фрагмента таблицы ASCII (от 32-го символа (пробел) до 126-го (символ '~')):

#include <iostream.h>

int main()

{

int number; char character;

for (number = 32; number <= 126; number = number + 1 )

{

character = number;

cout << "Символ '" << character;

cout << "' имеет код ";

cout << dec << number << " (дес.) или ";

cout << hex << number << " (шестнд.).\n";

}

return 0;

}

Приведенный код программы выводит на экран:

Символ ' ' имеет код 32 (дес.) или 20 (шестнд.).

Символ '!' имеет код 33 (дес.) или 21 (шестнд.).

…

Символ '}' имеет код 125 (дес.) или 7D (шестнд.).

Символ '~' имеет код 126 (дес.) или 7E (шестнд.).Символьные константы записываются в одиночных кавычках: 'а', 'V' и т. д., а строковые константы - в двойных. Когда компилятор встречает символьную константу, он заменяет ее на соответствующий ASCII-код. Например, константа 'а' будет заменена числом 97. Символьным переменным можно присваивать значения символьных констант.

Пример работы с символьными переменными и константами.

char charvar1 ='A'; // символьная переменная со значением 'А'

char charvar2 ='\t '; // символьная переменная со значением символа табуляции cout <<chvar1; // вывод переменной на экран

cout <<chvar2; // вывод переменной на экран

charvar1 ='B';

cout <<charvar1; // вывод переменной на экран

cout <<’\n '; // переход на следующую строку

Вещественная переменная и константа

Переменные вещественного типа хранят числа в десятичной форме представления, например 3.1415927, 0.0000625, -10.2. У таких чисел есть как целая часть, стоящая слева от десятичной точки, так и дробная часть, стоящая справа от нее.

Переменные вещественного типа предназначены для хранения вещественных чисел.

В C++ имеются три вещественных типа: float, double и long double.

Тип float. Тип float способен хранить числа, содержащиеся в интервале от -3.4*10³⁸ до 3.4* 10³⁸, с точностью до семи знаков после запятой. Размер типа float равен 4 байтам.

Пример с вещественными числами.

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

float rad; // переменная вещественного типа

const float pi =3.14159F; // вещественная константа

cout << "Введите радиус окружности: "; // запрос

cin >> rad; // получение радиуса

float area = pi *rad *rad; // вычисление площади круга

cout <<"Площадь круга равна " << area << endl; // вывод результата на экран

Типы double и long double. Два более крупных вещественных типа данных - double и long double - аналогичны типу float и отличаются от него лишь размерами занимаемой памяти, диапазонами значений и точностью представления. Тип double занимает 8 байтов памяти и хранит значения с точностью до 15 знаков после запятой. Характеристики типа long double зависят от компилятора, но чаще всего они совпадают с характеристиками типа double.

#include <iostream.h>

#include <math.h>

int main()

{

float number;

cout << "Введите вещественное число.\n";

cin >> number;

cout << "Корень из ";

cout.setf(ios::fixed); cout.precision(2);

cout << number;

cout << " примерно равен " << sqrt( number ) << ".\n";

return 0;

} Программа напечатает на экране:

Введите вещественное число.

200

Корень из 200.00 примерно равен 14.14.

Если строку cout.setf(ios::fixed); заменить на "cout.setf(ios::scientific);", то вид результата изменится:

Введите вещественное число.

200

Корень из 2.00e+02 примерно равен 1.41e+01.

При выводе на экран численных значений типа "float", "double" или "long double" возможно указание точности представления данных на экране и задание некоторых дополнительных параметров отображения, например, отображение значений в формате с фиксированной или плавающей точкой.

В приведенном примере программы вещественное число отображается в формате с фиксированной точкой и двумя десятичными знаками после запятой.

Идентификатор "sqrt" является именем библиотечной функции извлечения квадратного корня.

Описание библиотеки математических функций содержится в заголовочном файле "math.h«.Число 3.14159F - пример вещественной константы.

Наличие . говорит о том, что тип этой константы вещественный, а суффикс F указывает ее тип - float. Форма представления значения константы - нормализованная десятичная. Вещественные константы типа double являются значениями по умолчанию. Для констант типа long double необходимо указывать суффикс L.

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

Префикс const.

Программа также демонстрирует использование префикса const, используется в операторе const float PI = 3.14159F;Ключевое слово const предшествует описанию типа переменной и означает, что во время выполнения программы запрещено изменять значение этой переменной. Любая попытка изменить значение переменной, описанной с таким префиксом, приведет к выдаче компилятором сообщения об ошибке. Префикс const информирует о том, что значение переменной не будет изменяться в ходе выполнения программы.

Префикс const может применяться и к другим элементам программы.

Тип bool

1.Тип bool может иметь всего два значения - true и false.

2.Размер переменной типа bool равен 1 байту.

3.Переменные типа bool чаще всего используются для хранения результатов различных сравнений.

4.Подобные переменные часто называют булевыми.

Беззнаковый тип данных

Беззнаковые типы данных применяются в тех случаях, когда нет необходимости хранить в переменных отрицательные значения. Чтобы сделать тип беззнаковым, нужно добавить перед его названием ключевое слово unsigned. Например, определение беззнаковой переменной типа char будет выглядеть следующим образом:

unsigned char uchvar; Выход за рамки допустимых для данного типа значений, как правило, приводит к трудно обнаруживаемым ошибкам. В следующем фрагменте программы переменным svar типа int и unsvar типа unsigned int присваивается одно и то же значение, равное 1 500 000 000:

int svar = 1500000000;

unsigned int unsvar = 1500000000;

svar = (svar *2) / 3;

unsvar = (unsignvar *2) / 3;

cout<<"Знаковая переменная равна “<<svar<<endl;

cout<< "Беззнаковая переменная равна "<<unsvar << endl;

Обе переменные умножают на 2, а затем делят на 3. Несмотря на то, что правильный результат должен получиться меньше исходного значения, промежуточное вычисление приводит к результату, большему, чем исходное число. Такая ситуация стандартна, но зачастую она приводит к ошибкам. Так, например, в обеих переменных в итоге будет содержаться одно и то же значение, составляющее 2/3 от исходного и равное 1 000 000 000. Но результат умножения вышел за допустимый верхний предел для переменной svar. Поэтому результат работы будет выглядеть следующим образом: Знаковая переменная равна 431655765, а беззнаковая переменная равна 1000000000Теперь в переменной со знаком содержится неверное значение, в то время как переменная без знака, которая имела достаточный диапазон для представления результата умножения, содержит корректный результат. Отсюда следует вывод: необходимо следить за тем, чтобы все значения, которые вычисляются в программе, соответствовали диапазонам значений тех переменных, которым они присваиваются.

5.Операции ввода и вывода данных в C++

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

int ftemp; // температура по Фаренгейту

cout << "Введите температуру по Фаренгейту: ";

cin >> ftemp;

int ctemp = (ftemp-32)*5/9;

cout<<"Температура по Цельсию равна»<<ctemp<<'\n';

Оператор cin >> ftemp; запрашивает ввод числа от пользователя. Введенное значение присваивается переменной ftemp. Ключевое слово cin является объектом, определенным в C++ для работы со стандартным потоком ввода.

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

Вывод с использованием cout. Оператор cout << "Температура по Цельсию равна " << ctemp << '\n '; выводит на экран строку, заключенную в кавычки и вслед за ней значение переменной ctemp (<<ctemp) и после этого выполняет перевод на следующую строку (<< '\n ').

cout объект C++, предназначен для работы со стандартным потоком вывода.

Операция << называется операцией вставки, копирует содержимое переменной, стоящей в правой ее части, в объект, содержащийся в левой ее части. Операция << направляет значения, указанные в потоке, в объект cout, который выводит их на экран. Символ '\n' в конце строковой константы является примером управляющей или escape-последовательности.

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

Определение переменных при первом использовании.

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

Выражение. Любая комбинация переменных, констант и операций, приводящая к вычислению некоторого значения, называется выражением: alpha+12 или (alpha-37)*beta/2. Результатом выполнения всех операций, входящих в состав выражения, является значение. Выражения сами могут входить в состав других выражений. В примере alpha-37 и beta/2 являются выражениями. Фактически каждую переменную и константу, например alpha и 37, можно считать частным случаем выражения.

6. Преобразования типов данных в C++

Язык C++ свободнее обращается с выражениями, включающими в себя различные типы данных.

В качестве примера рассмотрим следующий фрагмент:

int count = 7;

float avgw = 155.5F;

double totalw = count *avgw;

cout <<"Вес равен " << totalw << endl;

Здесь переменная типа int умножается на переменную типа float, а результат присваивается переменной типа double. Компиляция происходит без ошибок, поскольку компиляторы допускают возможность выполнения арифметических операций с операндами разных типов. C++ предполагает, что смешивание типов данных произошло сознательно и является задумкой программиста, и поэтому не мешает ему реализовывать свои идеи. Подобный подход отчасти объясняет популярность C++, и, соответственно, дает программисту большую свободу.

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

Иерархия типов данных. Арифметические операции, подобные + и *, действуют следующим образом: если их операнды имеют различные типы, то операнд с более «низким» типом будет преобразован к более «высокому» типу. Подобные преобразования типов данных происходят неявно. Однако в ряде случаев компилятор не столь понятно проводит преобразования типов. Особенно это касается при работе с объектами. Здесь фактически будем оперировать собственными типами данных. В этом случае нужно создавать средства, выполняющие необходимые преобразования типов, поскольку компилятор не сможет преобразовывать пользовательские типы данных так, как он делал это со стандартными типами. Явные преобразования типов совершаются самим программистом, необходимы в тех случаях, когда компилятор не может безошибочно преобразовать типы автоматически. В C++ существует несколько различных операций приведения типов.

Явные приведения типов в C++ ведут себя весьма требовательно.

int var =1500000000;

var = (var*10)/10; // слишком большой результат

cout<<"Значение var равно"<<var<<endl; // неверный результат

var = 1500000000; // приведение к типу double

var = (static_cast<double>(var)*10)/10;

cout << "Значение var равно " << var << endl; // верный результат

При умножении переменной var на 10, получаемый результат равен 15 000 000 000 и его нельзя хранить даже с помощью типа unsigned int.

Оператор static_cast<double>(var) создает временную переменную типа double, содержащую значение, равное значению var. Эта временная переменная умножается на 10, и поскольку результат также имеет тип double, переполнения не происходит. Затем временная переменная делится на 10, и результат присваивается обычной целой переменной var.

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

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

7.Арифметические операции

В C++ используются четыре основные арифметические операции: сложения, вычитания, умножения и деления, обозначаемые соответственно +,-,*, /. Эти операции применимы как к целым типам данных, так и к вещественным. Существуют также и другие арифметические операции, использование которых не столь очевидно. Существует еще одна арифметическая операция, которая применяется только к целым числам типа char, short, int и long.

Эта операция называется операцией остатка от деления и обозначается знаком процента %.

Результатом этой операции, иногда также называемой «взятием по модулю», является остаток, получаемый при делении ее левого операнда на правый.

Например, результатом выполнения оператора: a=10%8; является число 2.

Язык C++ располагает средствами для того, чтобы сократить размер кода и сделать его наглядным. Одним из таких средств являются арифметические операции с присваиванием.

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

var1 = var1 + var2;

В данном случае производится сложение с замещением уже существующего значения одного из слагаемых. В C++ существует способ сократить подобные операторы, применяя арифметические операции с присваиванием.

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

Предыдущий оператор можно записать следующим образом: var1 += var2;

С присваиванием комбинируется и другие арифметические операции: -=, *=, /=, %= и т. д.

Пример использования арифметических операций с присваиванием:

int ans = 27;

ans += 10; // то же самое, что ans = ans +10;

cout << ans << ",";

ans -= 7; // то же самое, что ans = ans -7;

cout << ans << ",";

ans *=2 ; // то же самое, что ans = ans *2;

cout << ans << ",";

ans /= 3; // то же самое, что ans = ans /3;

cout << ans << ",";

ans %= 3; // то же самое, что ans = ans %3;

cout << ans << endl;

Инкремент.

В C++ имеется одна операция, которая является более специфичной, нежели предыдущие. При программировании часто приходится иметь дело с увеличением какой-либо величины на единицу.

Это можно сделать «в лоб», используя оператор

count=count+1;

или с помощью сложения с присваиванием:

count += 1; //увеличение count на 1

Но есть еще один, более сжатый, чем предыдущие, способ:

++count; // увеличение count на 1

Операция ++ инкрементирует, или увеличивает на 1, свой операнд.

8 . Пользовательские типы данных в C++: структуры.

До этого были рассмотрены только переменные стандартных типов, таких, как float, char и int.

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

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

В C++ конструкциями, реализующими объединение разнородных данных, являются массивы, структуры, классы. Структура является объединением простых переменных. Эти переменные могут иметь различные типы: int, float и т. д. В C++, структуры являются одной из составляющих главных концепций языка - объектов и классов.

Синтаксис структуры фактически идентичен синтаксису класса.

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

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

Простая структура.

Начнем рассмотрение со структуры, содержащей три поля, два поля имеют целый тип и одно поле - вещественный тип.

Эта структура предназначена для хранения информации о комплектующих деталях изделий, выпускаемых фабрикой.

В приведенном фрагменте программы определяется структура part и переменная part1 типа part.

Затем полям переменной part присваиваются значения и выводятся на экран.

struct part // объявление структуры

{

int modelnum; // номер модели изделия

int partnum; // номер детали

float cost; // стоимость детали

};

int main()

{

part part1; // определение структурной переменной

part1.modelnum = 6244; // инициализация полей

part1.partnum = 373; // переменной part1

part1.cost - 217.55F;

cout << "Модель " << part1.modelnum;

cout << " деталь " << part1.partnum;

cout << " стоимость $" << part1.cost << endl;

return 0;

}

В примере присутствуют три основных аспекта работы со структурами:

• определение структуры

• определение переменной типа этой структуры

• доступ к полям структуры.

Подробно рассмотрим каждый из этих аспектов.

Определение структуры задает ее внутреннюю организацию, описывая поля, входящие в состав структуры:

struct part

{

int modelnum;

int partnum;

float cost;

};

Определение структуры начинается с ключевого слова struct.

Затем следует имя структуры.

Объявления полей структуры заключаются в {}.

После } следует точка с запятой (;) - символ, означающий конец определения структуры

Определение структуры необходимо для того, чтобы создавать на его основе переменные этого типа. Само определение структуры не создает никаких переменных, т.е. не происходит ни выделения физической памяти, ни объявления переменной. В то же время определение обычной переменной предполагает выделение памяти под эту переменную. Таким образом, определение структуры фактически задает внутреннюю организацию структурных переменных после того, как они будут определены .

Первый оператор функции main() выглядит следующим образом:  part part1;, представляет собой определение переменной part1, имеющей тип part. Определение переменной означает, что под эту переменную выделяется память. Под структурную переменную всегда отводится столько памяти, сколько достаточно для хранения всех ее полей. В примере необходимо выделить по 4 байта для двух полей типа int и 4 байта для поля типа float. В некотором смысле  можно считать структуру part новым типом данных. Определение структурной переменной по своему синтаксису идентично определению переменной стандартного типа:

part part1; int varl;

Такое сходство не является случайным. Одна из целей языка C++ - сделать работу с пользовательскими типами данных максимально похожей на работу со стандартными типами данных. Когда структурная переменная определена, доступ к ее полям возможен с применением операции точки

part1.modelnum = 6244;

Поле структуры идентифицируется с помощью трех составляющих:

• имени структурной переменной part1,

• операции точки (.)

• имени поля modelnum.

Операция точки называется операцией доступа к полю структуры.

Внимание: в выражении с использованием операции точки (.) на первом месте стоит не название структуры (part), а имя структурной переменной (part1), имя переменной нужно для того, чтобы отличать одну переменную от другой. С полями структурной переменной можно обращаться так же, как с обычными простыми переменными. В результате выполнения оператора part1.modelnum = 6244; полю modelnum присваивается значение 6244 при помощи обычной операции присваивания.

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

int main()

{

part part1 = {6244,373,217.55F }; // инициализация перем

part part2; // объявление переменной

cout << "Модель " << part1.modelnum;

cout << ", деталь " << part1.partnum;

cout << ", стоимость $" << part1.cost << endl;

part2 = part1; // присваивание структурных переменных

cout << "Модель " << part2.modelnum;

cout << ", деталь " << part2.partnum;

cout << ", стоимость $" << part2.cost <<endl;

return 0;

}

В примере определены две переменные типа part: part1 и part2.

После того как поля переменной part1 инициализированы, происходит вывод их значений на экран, затем значение переменной part1 присваивается переменной part2, и значения ее полей также выводятся на экран.

Инициализация полей переменной part1 производится в момент ее определения: part part1 = { 6244, 373, 217.55 };Значения, которые присваиваются полям структурной переменной, заключены в фигурные скобки и разделены запятыми (первая из величин присваивается первому полю, вторая - второму полю и т. д.)

Как видим, можно присваивать значение одной структурной переменной другой структурной переменной: part2 = part1;Значение каждого поля переменной part1 присваивается соответствующему полю переменной part2. Внимание: операция присваивания может быть выполнена только над переменными, имеющими один и тот же тип.

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

Было бы удобно представлять длины в виде двух чисел, одно из которых равнялось бы количеству футов, а другое - количеству дюймов. В следующем примере эта идея реализована с помощью структуры.

#include <iostream>

using namespace std;

struct Mera // длина в английской системе

{

int fut; float dujm;

};

Пример применения структур

int main()

{

Mera d1, d3;

Mera d2 = { 11, 6.25 };

cout << “\nВведите число футов: "; cin >> d1.fut;

cout << "Введите число дюймов: ": cin >> d1.dujm;

d3.dujm = d1.dujm +d2.dujm;

d3.fut =0;

if ( d3.dujm >= 12.0 )

{

d3.dujm -= 12.0; d3.fut++;

}

d3.fut += d1.fut + d2.fut;

cout << d1.fut <<"\'-" << d1.dujm << "\" + ";

cout << d2.fut <<"\’-" << d2.dujm << "\" = ";

cout << d3.fut <<"\'-" << d3.dujm << "\"\n";

return 0;

}

Пример применения структур

Здесь структура Mera состоит из двух полей: fut и dujm. Определены три переменные типа Mera: d1, d2 и d3, причем переменную d2 инициализировали значением 11’-6.25", а переменные d1 и d3 пока оставлены без начального значения. Затем программа запрашивает у пользователя число футов и дюймов, которые используются для инициализации переменной d1. Затем значения d1 и d2 складываются, а результат присваивается переменной d3. Наконец, программа выводит две первоначальные длины и их сумму. Внимание: нельзя сложить две длины следующим образом:

d3 = d1 + d2;

Такое действие вызовет ошибку, в C++ не определены действия, которые необходимо выполнить при сложении переменных типа Mera. Операция + применима для стандартных типов C++, но она не определена для типов данных, которые создаются пользователями ().

Структуры и классы

Надо отметить, что сравнивать между собой структурные переменные, как и складывать их друг с другом, нельзя. Например, для структурных переменных part1 и part2 типа part, конструкция if (part1 == part2) недопустима, потому что операции == ничего не известно о переменных типа part. Однако, как мы увидим позже, данная проблема разрешима с помощью перегрузки операций. Как известно, структуры обычно используются для объединения данных, а классы - для объединения данных и функций.

Тем не менее, в C++ структуры также обладают возможностью включать в себя функции. Различия в синтаксисе между структурами и классами минимальны, поэтому теоретически можно использовать одно вместо другого. Однако структуры обычно используют только для хранения данных, а классы - для хранения данных и функций. Производятся многие действия языка C++. Обеспечивают доступ к файлам, производят математические расчеты, выполняют преобразование данных и др. действия.

Пример использования библиотечной функции sqrt

#include <iostream.h>

#include <cmath.h>

using namespace std;

int main()

{

double num,answ;

cout << "Введите число: ";

cin >> num;

answ = sqrt(numr);

cout << "Квадратный корень равен " << answ << endl; return 0;

}

Сначала программа получает значение от пользователя. Затем полученное значение используется в качестве аргумента для функции sqrt(): answ = sqrt(number); Функция обрабатывает аргумент и возвращает значение - выходные данные функции. Возвращение значения функцией означает возможность присваивания такого значения переменной соответствующего типа, в данном случае - переменной answ. Затем программа отображает значение переменной на экране. Аргументы функций и возвращаемые ими значения должны иметь правильный тип. Информацию об этих типах можно получить с помощью справочной системы компилятора, содержащей описания библиотечных функций. Для функции sqrt() и аргумент, и возвращаемое значение должны иметь тип double, поэтому в программе использованы переменные именно этого типа.