Министерство образования Республики Беларусь

БЕЛОРУССКИЙ НАЦИОНАЛЬНЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

МЕЖДУНАРОДНЫЙ ИНСТИТУТ ДИСТАНЦИОННОГО ОБРАЗОВАНИЯ

ОСНОВЫ АЛГОРИТМИЗАЦИИ И ПРОГРАММИРОВАНИЯ

МЕТОДИЧЕСКИЕ УКАЗАНИЯ

ДЛЯ ВЫПОЛНЕНИЯ ЛАБОРАТОРНЫХ РАБОТ

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

1-40 01 01 – «Программное обеспечение информационных

технологий»

Минск 2007

УДК 681.3 (075.8)

В методические указания включен цикл заданий для выполнения лабораторных работ для студентов I курса заочной формы обучения. Задания ориентированы на программную реализацию средствами языка программирования C/C++ любой версии.

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

Составители: Ю.Б. Попова, И.О. Лапанович

Содержание

ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ 3

ЗАДАНИЕ №1 22

ЗАДАНИЕ №2 25

ЗАДАНИЕ №3 27

ЗАДАНИЕ №4 29

ЛИТЕРАТУРА 32

Теоретические сведения

Программы на C/C++, в общем случае, состоят из трех частей: среды программирования, собственно языка и стандартной библиотеки C/C++ [10].

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

Наиболее часто используемые при написании программ директивы препроцессора и заголовочные файла стандартной библиотеки:

#include<stdio.h> // подсоединение к программе раздела библиотеки с функциями

// форматированного ввода/вывода данных

#include<iostream.h> // подсоединение к программе раздела библиотеки с функциями

// потокового ввода/вывода данных

#include<math.h> // подсоединение к программе раздела библиотеки

// с математическими функциями

#include<stdlib.h> // подсоединение к программе раздела библиотеки с функциями для

// работы с динамической памятью

#include<conio.h> // подсоединение к программе раздела библиотеки с функциями для

// работы с экраном

Основными типами данных языка C/C++ являются: char (символьный) – занимает 1 байт памяти; int (целый) – занимает 2 либо 4 байта памяти в зависимости от типа процессора; float (вещественный) – занимает 4 либо 8 байтов памяти в зависимости от типа процессора; double (вещественный с двойной точностью) – занимает 8 либо 16 байтов памяти в зависимости от типа процессора; void (пустой).

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

Тип Имя_Переменной;

unsigned int a, b; // объявлены беззнаковые переменные a и b целого типа

float c; // объявлена переменная с вещественного типа

Общий вид определения переменной:

Тип Имя_Переменной=Значение;

int x=2, y=15; // определены переменные x и y целого типа

float z=5.6; // определена переменная z вещественного типа

При определении переменных для них выделяется необходимое количество байтов памяти.

Общий вид объявления константы:

const Тип Имя_Константы=Значение;

const float PI=3.14; // объявляется переменная-константа PI и инициализируется

// значением 3.14

Для организации потокового ввода/вывода данных на C++ используются операторы cin, cout. Тогда программы на C++ должны включать заголовочный файл iostream.h.

cout<<”Введите число”; // вывод на экран текста

cin>>n; // ввод значения переменной

cout<<”Вывод числа”<<n; // вывод на экран значения переменной

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

Пример. Программа для вычисления суммы двух целых чисел.

#include<iostream.h> // подсоединение к программе раздела библиотеки с функциями

// потокового ввода/вывода данных

void main()

{ // начало функции main()

int a, b, c; // объявление переменных a, b, c целого типа

cout<<”Введите значение переменных a и b:”; // вывод строки на экран

cin>>a>>b; // ввод значений a и b

c=a+b; // присваивание переменной c значения суммы переменных a и b

cout<<”Сумма=”<<c; // вывод значения переменной c на экран

} // конец функции main()

Результаты работы программы:

Введите значение переменных a и b: 5 10

Сумма=15.

Для организации форматированного ввода/вывода программы на C/C++ должны включать заголовочный файл stdio.h.

Функция printf() выводит форматированные данные в стандартный поток, обеспечивает вывод на экран сообщений и значений переменных.

Общий вид функции printf():

printf(строка_управления_форматом, другие_аргументы);

printf(“Введите значения переменных”); // вывод текста на экран

printf(“%d%f”, x, y); // вывод значения целой переменной x и значения

// вещественной переменной y

Функция scanf() выполняет форматированный ввод данных из входного потока.

Общий вид функции scanf():

scanf(строка_управления_форматом, другие_аргументы);

scanf(“%d%f”, &x, &y); // ввод значения целой переменной x и

// и вещественной переменной y

Пример. Программа демонстрирует ввод/вывод переменных с использованием функций форматированного ввода/вывода.

#include<stdio.h> // подсоединение к программе раздела библиотеки

// с функциями форматированного ввода/вывода данных

void main()

{ int a; // объявление целой переменной a

float b,c; // объявление вещественных переменных b и c

char ch=’A’; // определение символьной переменной ch

char string[]=”BNTU”; // инициализация символьного массива string

printf(“%d\n”, 455); // вывод на экран целого числа

printf(“%f\n”, 12.34); // вывод на экран вещественного числа

printf(“%c%s\n”, ch, string); // вывод на экран символа и строки

printf(“Введите целую переменную:\n”); // вывод на экран текста

scanf(“%d”, &a); // ввод значения целой переменной a

printf(“%d\n”, a); // вывод на экран введенного значения целой переменной a

printf(“Введите вещественные переменные:\n”); // вывод на экран текста

scanf(“%f%f”, &b, &c); // ввод значений вещественных переменных b и c

printf(“%f%f”, b, c); // вывод на экран введенных значений вещественных

// переменных b и c

}

Результаты выполнения программы:

455

12.340000

A BNTU

Введите целую переменную: 1000

1000

Введите вещественные переменные: 1.1 2.2

1.1 2.2

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

Общий вид структуры выбора if:

if (условие) оператор1;

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

Пример. Программа демонстрирует использование else-if конструкции. Написать программу, в которой необходимо ввести число и определить, оно больше, меньше или равно нулю [7].

#include<iostream.h>

void main()

{ int n;

cout<<”Введите n:”<<endl;

cin>>n;

if (n>0) cout<<”n>0”; // использование else-if конструкции

else if (n<0) cout<<”n<0”; // если значение условия (n>0) является истинным, на экран

// выводится текст n>0 иначе, если значение условия (n<0)

// является истинным, на экран выводится текст n<0 иначе

else cout<<”n=0”; // на экран выводится текст n=0

}

Результаты работы программы:

Введите n: 7

n>0

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

Общий вид структуры выбора switch:

switch (выражение)

{ case const1: оператор1; break;

case const2: оператор2; break;

…

case constN: операторN; break;

default: опреторN+1; break; }

В качестве выражения можно использовать переменную целого или символьного типа. Значение выражения сопоставляется с константами const1-constN, стоящими после case. Оператор после case выполняется, если значение выражения равно соответствующей константе. Если совпадений нет, то управление передается оператору, стоящему после ключевого слова default. Оператор break передает управление за пределы оператора switch.

Пример. Программа демонстрирует использование структуры со множественным выбором. Написать программу, которая запрашивает у пользователя номер недели, затем выводит название дня недели или сообщение об ошибке, если введены неверные данные [8].

#include<stdio.h>

void main()

{

int nd; // дни недели

printf(“Введите номер дня недели (1…7):”);

scanf(“%d”,&nd);

switch(nd) // структура со множественным выбором

{

case 1: puts(“Понедельник”); break;

case 2: puts(“Вторник”); break;

case 3: puts(“Среда”); break;

case 4: puts(“Четверг”); break;

case 5: puts(“Пятница”); break;

case 6: puts(“Суббота”); break;

case 7: puts(“Воскресение”); break;

default: puts(“Число должно быть в диапазоне от 1 до 7”); break;

}}

Результаты работы программы:

Введите номер дня недели: 1

Понедельник

Язык C/C++ предоставляет программисту три типа структур повторения, а именно, циклы while, do-while, for [1]. Под циклом понимается оператор или группа операторов, повторяющихся некоторое количество раз.

Общий вид структуры повторения while:

while (условие) оператор;

Пример. Программа демонстрирует использование структуры повторения while. Необходимо вывести на экран числа, делящиеся на 2. Количество чисел задается с клавиатуры.

#include<stdio.h>

void main()

{

int a=0, b=1, n;

puts("Введите количество чисел:");

scanf("%d", &n);

while(a!=n) // использование структуры повторения while

{ if(b%2==0) // пока значение условия (a!=n) является истина

{ printf("%d\n", b); // выполняется тело цикла

a++; }

b++;

}}

Результаты работы программы:

Введите количество чисел: 5

2

4

6

8

10

Общий вид структуры повторения do-while:

do оператор while (условие);

Пример. Программа демонстрирует использование структуры повторения do while. Необходимо определить максимальное число в последовательности положительных чисел [8].

#include<stdio.h>

void main()

{

int a;

int m; // максимальное число

puts(“Введите числа. Для завершения ведите 0:”);

m=0;

do {scanf(“%d”,&a); // использование структуры повторения do while

if(a>m) m=a; // тело цикла выполняется пока значение условия (a>0)

} while(a>0); // является истина

printf(“Максимальное число :%d”, m);

}

Результат выполнения программы:

Введите числа. Для завершения ведите 0: 5 3 7 9 0

Максимальное число: 9

Структура повторения for используется для организации циклов с фиксированным, известным во время разработки программы, числом повторений.

Общий вид структуры повторения for:

for (инициализация управляющей переменной; условие; изменение управляющей переменной )

{оператор1; оператор2; оператор3;}

Пример. Программа демонстрирует использование структуры повторения for. Необходимо вычислить сумму элементов натурального ряда чисел от 1 до 10 включительно [7].

#include <iostream.h>

void main()

{

int res=0;

for(int i=0;i<10;i++) // использование структуры повторения for

// объявление переменной i при инициализации

res+=i; // цикл повторяется десять раз

cout<<”Результат=”<<res;

}

Результат выполнения программы:

Результат=45

Операторами безусловной передачи управления, которые относятся к неструктурным методам языка C/C++, являются операторы break, continue, goto. Они предназначены для изменения потока управления [1].

Пример. Программа демонстрирует использование оператора break. Необходимо написать программу, которая будет прерывать выполнение цикла при обнаружении числа 5 [10].

#include<stdio.h>

main()

{ int x;

printf(“Вывод значений переменной x:”);

for(x=1;x<=10;x++)

{ if(x==5) break; // выполнение оператора break прерывает цикл

// как только значение переменной x станет равно 5

printf(“%d”,x);}

return 0;

}

Результаты работы программы:

Вывод значений переменной x: 1 2 3 4

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

Общий вид объявления массива:

Тип Имя_Массива [Размерность];

float array[12]; // объявляется массив array, который содержит 12 элементов

// вещественного типа

Доступ к элементу массива осуществляется путем указания имени массива и индекса элемента. Индекс – это номер позиции элемента в массиве. В качестве индекса можно использовать выражение целого типа – константу или переменную. Индекс может меняться от 0 до n-1, где n – количество элементов массива.

Ввод значений элементов массива может быть осуществлен следующим образом:

scanf(“%d”,& a[0]); // либо cin>> a[0]; ввод значения элемента массива a

for(i=0;i<3;i++) // ввод значений элементов массива a с использованием структуры

// повторения for. В качестве индекса массива применяется переменная

scanf(“%d”,& a[i]); // либо cin>> a[i];

При каждом проходе цикла значение переменной i получает приращение. Поскольку переменная используется в качестве индекса массива, то конкретный элемент, на который ссылается функция scanf() или оператор cin , каждый раз будет следующим в массиве.

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

#include<iostream.h>

#define SIZE 10 // определение символической константы SIZE,

// значение которой равно 10

void main()

{int i;

int array[SIZE]; // объявление массива array, содержащего 10 элементов целого

// типа

// символическая константа SIZE заменяется на текст 10

cout<<”Введите значения элементов массива:”;

for(i=0;i<SIZE;i++) // символическая константа SIZE заменяется на текст 10

// ввод значений элементов массива array

cin>> array[i]; // с использованием структуры повторения for

cout<<”Вывод значений элементов массива в обратном порядке:”;

for(i=SIZE-1;i>=0;i--) //символическая константа SIZE заменяется на текст 10

// вывод значений элементов массива array

cout<< array[i]; // с использованием структуры повторения for

}

Результаты работы программы:

Введите значения элементов массива: 1 2 3 4 5 6 7 8 9 0

Вывод значений элементов массива в обратном порядке: 0 9 8 7 6 5 4 3 2 1

В C/C++ строка – это массив символов, заключенный в двойные кавычки и заканчивающийся специальным символом окончания строки – нулевым символом ‘\0’. При объявлении массива под строку необходимо предусмотреть место для нулевого символа.

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

char string[5]=”БНТУ”; // инициализация элементов символьного массива srting

// отдельными символами строкового литерала “БНТУ”

char string[5]={‘Б’’Н’’Т’’У’’\0’}; // инициализация элементов символьного

// массива string отдельными символьными константами

Пример: Программа демонстрирует работу с символьным массивом. Необходимо ввести с клавиатуры строку, а затем вывести ее на экран, вывести первый символ строки и вывести длину строки [7].

#include<stdio.h>

void main()

{

char string[20]; // объявление символьного массива string, в котором

// может храниться строка из 19 элементов

char q;

printf("Введите строку без пробелов:");

scanf("%s", string); // ввод строки

printf("Строка:%s\n", string); // вывод строки

printf(“Символ:%c\n”, string[0]); // вывод символа

for(q=0;string[q];q++);

printf("Длина строки:%d символов\n", q); // вывод длины строки

}

Результаты работы программы:

Введите строку без пробелов: stroka

Строка: stroka

Символ: s

Длина строки: 6 символов

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

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

Тип Имя_Массива [Размерность] [Размерность] …;

int mas[2][2]; // объявление двумерного массива mass с двумя строками и

// двумя столбцами

char string[2][50]; // объявление двумерного массива string, состоящего из 2 строк

// по пятьдесят байт

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

#include <stdio.h>

void main()

{

int i,j,sum=0;

int mas[2][3]; // объявление двумерного массива mas из двух строк и трех столбцов

printf("Ввод элементов массива:\n");

for(i=0;i<2;i++) // использование вложенной структуры повторения for для

{ // ввода элементов двумерного массива mas

for(j=0;j<3;j++)

scanf("%d",&mas[i][j]);

}

printf("Вывод элементов массива:\n");

for(i=0;i<2;i++) // использование вложенной структуры повторения for для

{ // вывода на экран элементов двумерного массива mas

for(j=0;j<3;j++)

printf("%d",mas[i][j]);

}

for(i=0;i<2;i++) // использование вложенной структуры повторения for для

{ // подсчета суммы элементов двумерного массива mas

for(j=0;j<3;j++)

sum+=mas[i][j]; // подсчет суммы элементов массива mas

}

printf("\n");

printf("Сумма элементов массива:%d", sum); // вывод суммы элементов

// массива mas на экран

}

Результаты работы программы:

Ввод элементов массива: 1 1 1 2 2 2

Вывод элементов массива: 1 1 1 2 2 2

Сумма элементов массива: 9

Указатели представляют собой переменные, значениями которых являются адреса памяти [6]. В «обычной» переменной непосредственно содержится некоторое значение. Указатель же содержит адрес переменной, в которой находится конкретное значение. Символ * означает, что объявляемая переменная является указателем.

Общий вид объявления указателя:

Тип *Имя_Указателя;

int *Ptr; // объявление переменной Ptr как указателя на целый тип

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

#include <stdio.h>

void main()

{

int a;

int *aPtr; // объявление указателя aPtr на целый тип

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

aPtr=&a; // применение операции взятия адреса

// указателю aPtr присваивается адрес переменной a

printf("Адрес a:%p\n"

"Значение aPtr:%p\n", &a, aPtr);

printf("Значение a:%d\n"

"Значение *aPtr:%d\n", a, *aPtr);

*aPtr+=8; // применение операции разыменования. Происходит доступ к значению

// переменной a через ее адрес. Теперь значение переменной a равно 15

printf("Адрес a:%p\n"

"Значение aPtr:%p\n", &a, aPtr);

printf("Адрес a:%d\n"

"Значение *aPtr:%d\n", a, *aPtr);

}

Результаты работы программы:

Адрес a: 0012FF7C

Значение aPtr: 0012FF7C

Значение a: 7

Значение *aPtr: 7

Адрес a: 0012FF7C

Значение aPtr: 0012FF7C

Значение a: 15

Значение *aPtr: 15

Функция – это самостоятельная единица программы, спроектированная для реализации конкретной задачи [3].

Определение функции – это ее полная реализация. Определение функции включает в себя тело функции.

Общий вид определения функции:

Тип_Возвращаемого_Значения Имя_Функции (Тип_Параметра1 Параметр1, … , Тип_ПараметраN ПараметрN)

{Тело функции}

double sum(double a, double b) // определение функции sum(), которая получает два

// параметра вещественного типа и возвращает

// результат вещественного типа

{ return a+b;} // тело функции sum(). В качестве результата функция

// возвращает сумму двух вещественных чисел

Пример. Программа демонстрирует использование прототипа функции. Функция sum в программе не определена до первого обращения к ней.

#include<iostream.h>

double sum(double, double); // прототип функции sum()

int main()

{ double x, y;

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

cin>>x>>y;

cout<<"Сумма="<<sum(x,y); // вызов функции sum()

return 0;

}

double sum(double a, double b) // определение функции sum()

{ return a+b;}

Результаты работы программы:

Введите два числа:

2.2 7.7

Сумма=9.9

Пример. Определение функции sum находятся в программном коде до обращения к ней. Прототип функции не требуется.

#include<iostream.h>

double sum(double a, double b) // определение функции sum()

{ return a+b;}

int main()

{ double x, y;

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

cin>>x>>y;

cout<<"Сумма="<<sum(x,y); // вызов функции sum()

return 0;

}

Результаты работы программы:

Введите два числа:

2.2 7.7

Сумма=9.9

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

Общий вид вызова функции:

Имя_Функции (Аргумент1, … , АргументN);

cout<<sum(x,y); // вызов функции sum с двумя аргументами

Пример. Программа демонстрирует передачу параметра функции по значению и передачу параметра функции по ссылке с использованием указателей [10].

#include<iostream.h>

int sqZ(int); // прототип функции sqZ()

void sqS1(int *); // прототип функции sqS1()

main()

{ int x=2, y=3;

cout<<"x="<<x<<"До вызова функции sqZ";

cout<<"Значение, возвращаемое функцией sqZ"<<sqZ(x); // вызов sqZ() по значению

cout<<"x="<<x<<"После вызова функции sqZ";

cout<<"y="<<y<<"До вызова функции sqS1";

sqS1(&y); // вызов sqS1() по ссылке

cout<<"y="<<y<<"После вызова функции sqS1”;

return 0; }

int sqZ(int a) // возводим в квадрат значение локальной переменной a

// изменится значение только локальной переменной

{return a*=a;} // параметр в вызывающей функции не изменяется

void sqS1(int *bPtr) // возводим в квадрат значение переменной y,

// оперируя адресом переменной

{ *bPtr*=*bPtr;} // параметр в вызывающей функции изменяется

Результаты работы программы:

x=2 До вызова функции sqZ

Значение, возвращаемое функцией sqZ 4

x=2 После вызова функции sqZ

y=3 До вызова функции sqS1

y=9 После вызова функции sqS1

Общий вид указателя на функцию:

Тип_Возвращаемого_Значения(*Имя_Указателя_На_Функцию)(Список_

Типов_Параметров);

double (*f)(int, int); // объявляется указатель на функцию f, которая получает

// два параметра целого типа и возвращает результат вещественного типа

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

Функция со списком аргументов переменной длины - это функция, число аргументов которой не фиксировано. Многоточие (…) в прототипе и определении функции означает, что функция получает переменное число аргументов любого типа. В таких функциях в списке перед многоточием должен находиться хотя бы один фиксированный параметр. Многоточие должно всегда находиться в конце списка параметров [10].

int printf(const char *format, …); // прототип функции printf(), которая принимает

// переменное число аргументов. Как минимум, printf() должна получить строку

// в качестве первого аргумента, но, кроме того, может принимать любое

// количество дополнительных аргументов.

Во многих системах существует возможность передавать аргументы функции main() из командной строки посредством включения аргументов int argc, char *argv[] (**argv) и char *envp[] в список параметров функции main() [10]:

main(int argc, char *argv[], char *envp[])

{ Тело функции }

Параметр argc получает число аргументов в командной строке. Поскольку в качестве аргумента всегда передается имя программы, это значение не бывает меньше единицы. Параметр argv – массив строк, в котором сохраняются имеющиеся в командной строке аргументы. Первая строка argv[0] содержит имя программы. Параметр envp – массив строк, содержащий информацию о системном окружении операционной системы, т.е. о среде, в которой выполняется программа.

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

#include<iostream.h>

void main(int argc, char *argv[], char *envp[]) // список параметров функции main()

{

int i;

cout<<"Число аргументов в командной строке:"<<argc<<endl;

cout<<"Имя программы:"<<*argv<<endl;

cout<<"Информация о среде:"<<endl;

for(i=0;envp[i];i++)

cout<<envp[i]<<endl;

}

Результаты работы программы:

Число аргументов в командной строке: 1

Имя программы: C:\Documents and Settings\Administrator\Desktop\Debug\2.exe

Информация о среде:

ALLUSERPROFILE=C:\Documents and Settings\All Users

APPDATA=C:\Documents and Settings\Administrator\Application Data и т.д.

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

Пример. Программа демонстрирует использование перегруженных функций. Необходимо вычислить квадраты целого числа и вещественного числа [10].

#include<iostream.h>

int square(int x)

{ return x*x;}

double square(double y)

{ return y*y; }

main()

{

cout<<”Квадрат целого числа 7:”;

cout<<square(7); // вызов перегруженной функции square() для подсчета

// квадрата целого числа

cout<<”Квадрат вещественного числа 7.5:”;

cout<<square(7.5); // вызов перегруженной функции square() для подсчета

// квадрата вещественного числа

return 0;

}

Результаты работы программы:

Квадрат целого числа 7: 49

Квадрат вещественного числа 7.5: 56.25

Если операции для всех типов идентичны, то же самое можно сделать в более сжатой и удобной форме путем определения шаблона функции. Определения шаблонов функций начинаются с ключевого слова template, за которым следует список формальных параметров шаблона функции, заключенный в угловые скобки (< и >), каждому из которых предшествует ключевое слово class. Эти формальные параметры используются для задания типов параметров функции, задания типа возвращаемого функцией значения и объявления переменных внутри функции. Далее следует определение шаблона, которое не отличается от определения любой другой функции [10].

Пример. Программа демонстрирует использование шаблонов функций. Необходимо вывести на экран содержание массива целых чисел, массива вещественных чисел и символьного массива [10].

#include<iostream.h>

template <class T> // шаблон функции

void printArray(T *array, const int n)

{

for(int i=0; i<n; i++)

cout<<array[i]<<” ”;}

main()

{

const int aN=3, bN=4, cN=6;

int a[aN]={1,2,3};

float b[bN]={1.1, 2.2, 3.3, 4.4};

char c[cN]=”HELLO”; // шестая позиция для нулевого символа

cout<<”Массив а содержит:\n”;

printArray(a, aN); // версия для целых чисел

cout<<”Массив b содержит:\n”;

printArray(b, bN); // версия для вещественных чисел

cout<<”Массив c содержит:\n”;

printArray(c, cN); // версия для символов

return 0;

}

Результаты работы программы:

Массив а содержит: 1 2 3

Массив b содержит: 1.1 2.2 3.3 4.4

Массив c содержит: H E L L O