Типы данных. Линейные алгоритмы и программы

Типы данных. Линейные алгоритмы и программы

Основные типы данных в C++

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

1. int (целый);

2. char (символьный);

3. wchar_t (расширенный символьный);

4. bool (логический);

5. float (вещественный);

6. double (вещественный с двойной точностью).

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

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

• short (короткий);
• long (длинный);
• signed (знаковый);
• unsigned (беззнаковый).

Целый тип (int)

Размер типа int не определяется стандартом, а зависит от компьютера и компилятора. Для 16-разрядного процессора под величины этого типа отводится 2 байта, для 32-разрядного — 4 байта.

Спецификатор short перед именем типа указывает компилятору, что под число требуется отвести 2 байта независимо от разрядности процессора. Спецификатор long означает, что целая величина будет занимать 4 байта. Таким образом, на 16-разрядном компьютере эквиваленты int и short int, а на 32-разрядном — int и long int.

Внутреннее представление величины целого типа — целое число в двоичном коде. При использовании спецификатора signed старший бит числа интерпретируется как знаковый (0 — положительное число, 1 — отрицательное). Спецификатор unsigned позволяет представлять только положительные числа, поскольку старший разряд рассматривается как часть

 

кода числа. Таким образом, диапазон значений типа int зависит от спецификаторов. Диапазоны значений величин целого типа с различными

 

спецификаторами для IBM PC-совместимых компьютеров приведены в таблице «Диапазоны значений простых типов данных» в конце записи.

По умолчанию все целочисленные типы считаются знаковыми, то есть спецификатор signed можно опускать.

Константам, встречающимся в программе, приписывается тот или иной тип в соответствии с их видом. Если этот тип по каким-либо причинам не устраивает программиста, он может явно указать требуемый тип с помощью суффиксов L, l (long) и U, u (unsigned). Например, константа 32L будет иметь тип long и занимать 4 байта. Можно использовать суффиксы L и U одновременно, например, 0x22UL или 05Lu.

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

Под величину символьного типа отводится количество байт, достаточное для размещения любого символа из набора символов для данного компьютера, что и обусловило название типа. Как правило, это 1 байт. Тип char, как и другие целые типы, может быть со знаком или без знака. В величинах со знаком можно хранить значения в диапазоне от -128 до 127. При использовании спецификатора unsigned значения могут находиться в пределах от О до 255. Этого достаточно для хранения любого символа из 256-символьного набора ASCII. Величины типа char применяются также для хранения целых чисел, не превышающих границы указанных диапазонов.

Расширенный символьный тип (wchar_t)

Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта, например, Unicode. Размер этого типа зависит от реализации; как правило, он соответствует типу short. Строковые константы типа wchar_t записываются с префиксом L, например, L»Gates».

Логический тип (bool)

Величины логического типа могут принимать только значения true и false, являющиеся зарезервированными словами. Внутренняя форма представления значения false — 0 (нуль). Любое другое значение интерпретируется как true. При преобразовании к целому типу true имеет значение 1.

Алгоритмический язык

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

 — разбиение на этапы;

— разработку алгоритма;

 — составление программы решения на алгоритмическом языке;

 — ввод данных;

— отладку программы (возможны ошибки — их надо исправить);

 — выполнение на ПК;

— анализ результатов.

 

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

Свойства алгоритма

Их несколько:

 — конечность. Любой алгоритм должен быть завершённым, а окончание наступает после выполнения определённого числа шагов;

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

— результативность. Итог работы — результат, полученный за конечное число шагов;

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

Линейная структура

Любой алгоритм составляется из ряда базовых структур. Простейшей базовой структурой является следование — структура с линейными характеристиками. Из этого можно сформулировать определение.

Линейный алгоритм — это алгоритм, образуемый командами, которые выполняются однократно и именно в той последовательности, в которой записаны. Линейная структура, по сути, проста. Записать её можно как в текстовой, так и в графической форме.

Представим, что у нас стоит задача пропылесосить ковёр в комнате. В текстовой форме алгоритм будет следующим:

— принести пылесос к месту уборки;

 — включить;

 — пропылесосить;

 — выключить;

— унести пылесос.

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

Пример программы с линейным алгоритмом:

#include <iostream>                                                #Начало

Using namespace std;

Int main()

{

Double a, b;                                                              #Ввод

     

cout << “Введите a: “;                                            #Действие

cin >> a;

cout << ”Введите b: ”;

cin >>> b;

double x = a + b;                         

cout << “Сумма чисел равняется ” << x << endl; #Вывод

Return 0;                                                                   #Конец

}

Цикл for

Если мы знаем точное количество действий (итераций) цикла, то можем использовать цикл for. Синтаксис его выглядит примерно так:

for (действие до начала цикла; условие продолжения цикла; действия в конце каждой итерации цикла) {    инструкция цикла;    инструкция цикла 2;    инструкция цикла N;}

Итерацией цикла называется один проход этого цикла.

Существует частный случай этой записи, который мы сегодня и разберем:

for (счетчик = значение; счетчик < значение; шаг цикла) { тело цикла;}

Счетчик цикла — это переменная, в которой хранится количество проходов данного цикла.

Описание синтаксиса

1. Сначала присваивается первоначальное значение счетчику, после чего ставится точка с запятой.

2. Затем задается конечное значение счетчика цикла. После того, как значение счетчика достигнет указанного предела, цикл завершится. Снова ставим точку с запятой.

3. Задаем шаг цикла. Шаг цикла — это значение, на которое будет увеличиваться или уменьшаться счетчик цикла при каждом проходе.

Пример кода

Напишем программу, которая будет считать сумму всех чисел от 1 до 1000.

# include <iostream> using namespace std; int main (){ int i; // счетчик цикла int sum = 0; // сумма чисел от 1 до 1000. setlocale(0, ""); for (i = 1; i <= 1000; i++) // задаем начальное значение 1, конечное 1000 и задаем шаг цикла - 1. {   sum = sum + i; } cout << "Сумма чисел от 1 до 1000 = " << sum << endl;         return 0;}

Если мы скомпилируем этот код и запустим программу, то она покажет нам ответ: 500500. Это и есть сумма всех целых чисел от 1 до 1000. Если считать это вручную, понадобится очень много времени и сил. Цикл выполнил всю рутинную работу за нас.

Цикл while

Когда мы не знаем, сколько итераций должен произвести цикл, нам понадобится цикл while или do...while. Синтаксис цикла while в C++ выглядит следующим образом.

while (Условие) { Тело цикла;}

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

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

# include <iostream> using namespace std; int main (){ setlocale(0, ""); int i = 0; // инициализируем счетчик цикла. int sum = 0; // инициализируем счетчик суммы. while (i < 1000) {   i++;   sum += i; } cout << "Сумма чисел от 1 до 1000 = " << sum << endl;      return 0;}

После компиляции программа выдаст результат, аналогичный результату работы предыдущей программы. Но поясним несколько важных моментов. Я задал строгое неравенство в условии цикла и инициализировал счетчик i нулем, так как в цикле while происходит на одну итерацию больше, потому он будет выполняться, до тех пор, пока значение счетчика перестает удовлетворять условию, но данная итерация все равно выполнится. Если бы мы поставили нестрогое неравенство, то цикл бы закончился, когда переменная i стала бы равна 1001 и выполнилось бы на одну итерацию больше.

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

В данном случае мы обязательно должны присвоить счетчику цикла какое-либо значение, т.к. в предыдущей программе мы это значение присваивали внутри цикла for, здесь же, если мы не инициализируем счетчик цикла, то в него попадет «мусор» и компилятор в лучшем случае выдаст нам ошибку, а в худшем, если программа соберется — сегфолт практически неизбежен.

 

Затем мы описываем условие цикла — «пока переменная i меньше 1000 — выполняй цикл». При каждой итерации цикла значение переменной-счетчика i увеличивается на единицу внутри цикла.

Когда выполнится 1000 итераций цикла, счетчик станет равным 999 и следующая итерация уже не выполнится, поскольку 1000 не меньше 1000. Выражение sum += i является укороченной записью sum = sum + i.

После окончания выполнения цикла, выводим сообщение с ответом.

Цикл do while

Цикл do while очень похож на цикл while. Единственное их различие в том, что при выполнении цикла do while один проход цикла будет выполнен независимо от условия. Решение задачи на поиск суммы чисел от 1 до 1000, с применением цикла do while.

# include <iostream> using namespace std; int main (){ setlocale(0, ""); int i = 0; // инициализируем счетчик цикла. int sum = 0; // инициализируем счетчик суммы. do { // выполняем цикл.    i++;   sum += i; } while (i < 1000); // пока выполняется условие. cout << "Сумма чисел от 1 до 1000 = " << sum << endl; return 0;}

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

                                                                                

Пример: Вывести числа от 0 до 99, по 10 в каждой строке

 

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf

#include <stdio.h>

int main() {

for(int i=0; i<10; i++) // цикл для десятков

 

{

for (int j = 0; j < 10; j++) // цикл для единиц   

{

printf("%2d ", i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел

}

printf("\n"); // во внешнем цикле переводим строку

}

getchar(); // scanf() не использовался,

return 0; // поэтому консоль можно удержать одним вызовом getchar()

}

Записи (структуры)

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

Обычно все члены структуры связаны друг с другом. Например, информация об имени и адресе, находящаяся в списке рассылки, обычно представляется в виде структуры. Следующий фрагмент кода объявляет шаблон структуры, определяющий имя и адрес. Ключевое слово struct сообщает компилятору об объявлении структуры.

Синтаксис объявления структуры

 

struct <имя>;

 <тип1> <поле1>;

 <тип2> <поле2>;

…

 <типN> <пилеN>;

};

 

Например

 

struct point_t {

int x;

int y;

};

 

Объявление структуры начинается с ключевого слова struct и содержит список объявлений, заключенный в фигурные скобки. За словом struct может следовать имя, называемое тегом структуры (от английского слова tag — ярлык, этикетка. — Примеч. пер.), point в нашем случае. Тег дает название структуре данного вида и далее может служить кратким обозначением той части объявления, которая заключена в фигурные скобки.

Перечисленные в структуре переменные называются элементами (members - В некоторых изданиях, в том числе во 2-м издании на русским языке этой книги structure members переводится как члены структуры. - Примеч. ред). Имена элементов и тегов без каких-либо коллизий могут совпадать с именами обычных переменных (т. е. не элементов), так как они всегда различимы по контексту. Более того, одни и те же имена элементов могут встречаться в разных структурах, хотя, если следовать хорошему стилю программирования, лучше одинаковые имена давать только близким по смыслу объектам.

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

struct {...} x, y, z;

с точки зрения синтаксиса аналогично выражению

int х, у, z;

в том смысле, что и то и другое объявляет x, y и z переменными указанного типа; и то и другое приведет к выделению памяти соответствующего размера.

Объявление структуры, не содержащей списка переменных, не резервирует памяти; оно просто описывает шаблон, или образец структуры. Однако если структура имеет тег, то этим тегом далее можно пользоваться при определении структурных объектов. Например, с помощью заданного выше описания структуры point строка

struct point pt;

определяет структурную переменную pt типа struct point. Структурную переменную при ее определении можно инициализировать, формируя список инициализаторов ее элементов в виде константных выражений:

struct point maxpt = {320, 200};

Инициализировать автоматические структуры можно также присваиванием или обращением к функции, возвращающей структуру соответствующего типа.

 

Доступ к отдельному элементу структуры осуществляется посредством конструкции вида:

имя-структуры. элемент

Оператор доступа к элементу структуры. соединяет имя структуры и имя элемента. Чтобы напечатать, например, координаты точки pt, годится следующее обращение к printf:

printf("%d, %d", pt.x, pt.y);

Другой пример: чтобы вычислить расстояние от начала координат (0,0) до pt, можно написать

double dist, sqrt(double);

 

dist = sqrt((double)pt.x * pt.x + (double)pt.y * pt.y);

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

struct rect {

struct point pt1;

struct point pt2;

};

Структура rect содержит две структуры point. Если мы объявим screen как

struct rect screen;

то

screen.pt1.x

обращается к координате x точки pt1 из screen.

 

 

Механизм вызова функции

Механизм вызова функции является динамическим, т.е. действия, связанные с его реализацией, осуществляются при выполнении программы. Именно поэтому текст программы и его «развертка» во времени представляют для функции «две большие разницы». Это касается двух вещей:

· последовательность выполняемых действий (поток управления) при вызовах функций:

· соответствие между формальными и фактическими параметрами.

Именно поэтому мы и рассмотрим процесс вызова вышеприведенной функции в «исторической перспективе»:

1. результатом трансляции функции является программный код, размещенный в сегменте команд;

2. в вызывающей функции (main) определяются переменные, используемые в качестве фактических параметров вызова функции (массив B);

3. выполняется программный код вызывающей функции, пока в ней не встретится выражение, содержащий вызов функции;

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

Рис. Механизм вызова функции

5. формальный параметр – массив A передается по ссылке - отображается на фактический параметр, аналогичный массив B, определенный в контексте вызывающей функции;

6. формальный параметр n – размерность массива A передается по значению, т.е. копируется, в качестве копируемого значения выступает константа;

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

8. выполняется программный код функции sum;

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

10. оператор return возвращает значение локальной переменной s в качестве переменной – результата в выражение, где находится вызов;

11. одновременно return производит переход в вызывающую функцию main в точку возврата;

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

 

 

Области действия функций. Определения и объявления

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

· имя функции;

· тип результата;

· список формальных параметров (переменные и типы).

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

Теперь перечислим причины такого «незнания» транслятора. Во-первых, трансляторы обычно используют довольно простые алгоритмы просмотра текста программы, «не заглядывая» вперед. Поэтому обычно на данный момент трансляции содержание текста программы за текущим транслируемым оператором ему неизвестно. Во-вторых, функция может быть в библиотеке. В третьих - в другом текстовом файле (модуле), содержащем часть Си-программы. Во всех этих случаях необходимо использовать объявления. Единственный случай, когда этого делать не надо, когда определение функции присутствует ранее по тексту программы.

 

int B[10];

int sum(int s[],int n); // Объявление функции,

// определенной далее по тексту

extern int printf(char *,...); // Объявление библиотечной функции

// с переменным числом параметров

extern int other(void); // Объявление функции без

// параметров из другого

void main() // файла программы

{ sum(B,10); other(); } // Вызовы объявленных функций

 

int sum(int s[], int n) {...} // Определение ранее объявленной функции

 

 

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

· объявление заканчивается символом ";";

· если функция находится вне текущего файла, то объявление предваряется служебным словом extern;

· имена переменных в списке формальных параметров объявления могут отсутствовать;

· если функция не имеет формальных параметров, то в объявлении присутствует формальный параметр типа void.

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

 

extern double sin(double);

int x; double y;

y = sin(x); //------Неявное преобразование (double)x

Типы данных. Линейные алгоритмы и программы

Основные типы данных в C++

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

1. int (целый);

2. char (символьный);

3. wchar_t (расширенный символьный);

4. bool (логический);

5. float (вещественный);

6. double (вещественный с двойной точностью).

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

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

• short (короткий);
• long (длинный);
• signed (знаковый);
• unsigned (беззнаковый).

Целый тип (int)

Размер типа int не определяется стандартом, а зависит от компьютера и компилятора. Для 16-разрядного процессора под величины этого типа отводится 2 байта, для 32-разрядного — 4 байта.

Спецификатор short перед именем типа указывает компилятору, что под число требуется отвести 2 байта независимо от разрядности процессора. Спецификатор long означает, что целая величина будет занимать 4 байта. Таким образом, на 16-разрядном компьютере эквиваленты int и short int, а на 32-разрядном — int и long int.

Внутреннее представление величины целого типа — целое число в двоичном коде. При использовании спецификатора signed старший бит числа интерпретируется как знаковый (0 — положительное число, 1 — отрицательное). Спецификатор unsigned позволяет представлять только положительные числа, поскольку старший разряд рассматривается как часть

 

кода числа. Таким образом, диапазон значений типа int зависит от спецификаторов. Диапазоны значений величин целого типа с различными

 

спецификаторами для IBM PC-совместимых компьютеров приведены в таблице «Диапазоны значений простых типов данных» в конце записи.

По умолчанию все целочисленные типы считаются знаковыми, то есть спецификатор signed можно опускать.

Константам, встречающимся в программе, приписывается тот или иной тип в соответствии с их видом. Если этот тип по каким-либо причинам не устраивает программиста, он может явно указать требуемый тип с помощью суффиксов L, l (long) и U, u (unsigned). Например, константа 32L будет иметь тип long и занимать 4 байта. Можно использовать суффиксы L и U одновременно, например, 0x22UL или 05Lu.

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

Под величину символьного типа отводится количество байт, достаточное для размещения любого символа из набора символов для данного компьютера, что и обусловило название типа. Как правило, это 1 байт. Тип char, как и другие целые типы, может быть со знаком или без знака. В величинах со знаком можно хранить значения в диапазоне от -128 до 127. При использовании спецификатора unsigned значения могут находиться в пределах от О до 255. Этого достаточно для хранения любого символа из 256-символьного набора ASCII. Величины типа char применяются также для хранения целых чисел, не превышающих границы указанных диапазонов.

Расширенный символьный тип (wchar_t)

Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта, например, Unicode. Размер этого типа зависит от реализации; как правило, он соответствует типу short. Строковые константы типа wchar_t записываются с префиксом L, например, L»Gates».

Логический тип (bool)

Величины логического типа могут принимать только значения true и false, являющиеся зарезервированными словами. Внутренняя форма представления значения false — 0 (нуль). Любое другое значение интерпретируется как true. При преобразовании к целому типу true имеет значение 1.