Информатика Экзамен
.pdf#include <conio.h> //директива препроцесора
void main ()
{
int x,y; //объявляем переменный целого типа
int sum; //Переменная для вычисления суммы
std::cout<<"X = "; //На экран выводится 'X = '
std::cin>>x; //вводим с клавиатуры число, например: 5
std::cout<<"Y = "; //На экран выводится 'Y = '
std::cin>>y; //вводим с клавиатуры число, например: 8
sum = x + y ;
std::cout<<"x+y = "<<(x+y)<< std::endl;
_getch();
}
Результат работы программы будет аналогичный. std::endl - это оператор конца строки. Давайте это же сделаем и для дробных чисел:
#include <iostream>//директива препроцесора
#include <conio.h> //директива препроцесора
void main ()
{
float x,y; //объявляем переменный дробного типа
float sum; //Переменная дробного типа для вычисления суммы
std::cout<<"X = "; //На экран выводится 'X = '
std::cin>>x; //вводим с клавиатуры число, например: 2.25
std::cout<<"Y = "; //На экран выводится 'Y = '
std::cin>>y; //вводим с клавиатуры число, например: 4.89
sum = x + y; //Вычисление суммы
std::cout<<"x+y = "<<(x+y)<< std::endl;
_getch();
}
Результат работы программы:
Итак, мы видим, что функция cin и функция cout интелектуально способные различить дробные и целые числа.
17.
ЛОГИЧЕСКИЕ КОНСТАНТЫ, или: Логические постоянные
термины, относящиеся к логической форме рассуждения (доказательства, вывода) и являющиеся средством передачи человеческих мыслей и выводов, заключений в любой области. К Л. к. относятся такие слова, как "не", "и", "или", "есть", "каждый", "некоторый" и т. п. Л. к. не имеют самостоятельного содержания. Сами по себе они ничего не описывают и ничего не обозначают. Вместе с тем они позволяют из одних содержательных выражений получать другие. Установление точного смысла Л. к. и выяснение самых общих зак
В языке C++ определены две логические константы: true и false. В заголовка определенны макросы true и false. онов, относящихся к ним, - одна из основных задач логики
18.
Препроцессор С/С++ — программный инструмент, изменяющий код программы для последующей компиляции и сборки, используемый в языках программирования Си и его потомка - C++. Этот препроцессор обеспечивает использование стандартного набора возможностей:
Замена триграфов ??=, ??(, ??) (и других) символами #, [, ]
Замена комментариев пустыми строками
Включение файла — #include
Макроподстановки — #define
Условная компиляция — #if, #ifdef, #elif, #else, #endif
Важной областью применения препроцессоров С является условная компиляция. При подготовке программы к компиляции разработчик может с помощью нескольких изменений адаптировать программу к текущей ситуации (например, к определенной модели процессора).
Препроцессор языка Си — низкоуровневый, лексический препроцессор, потому что он требует только лексического анализа, то есть он обрабатывает только исходный текст перед парсингом, выполняя простую замену лексем и специальных символов заданными последовательностями символов, в соответствии с правилами, установленными пользователями.
Препроцессор си не является тьюринг-полным хотя бы потому, что он не может зависнуть в принципе.
Директивы
Директивой препроцессора (или командной строкой препроцессора[1]) называется строка в исходном коде, которая начинается с символа # и следующего за ним ключевого слова препроцессора. Есть чётко определённый список ключевых слов:
define — задаёт макроопределение (макрос) или символическую константу
undef — отменяет предыдущее определение
include — вставляет текст из указанного файла
if — осуществляет условную компиляцию при истинности константного выражения
ifdef — осуществляет условную компиляцию при определённости символической константы
ifndef — осуществляет условную компиляцию при неопределённости символической константы
else — ветка условной компиляции при ложности выражения
elif — ветка условной компиляции, образуемая слиянием else и if
endif — конец ветки условной компиляции
line — препроцессор изменяет номер текущей строки и имя компилируемого файла
error — выдача диагностического сообщения
pragma — действие, зависящее от конкретной реализации компилятора
пустое слово - пустое действие.
19.
Функция - это модуль в с++. Функции в языке си позволяют создавать модульные программы, то есть программы состоящие из модулей. Для написания программ, лучше использовать готовые стандартные функции библиотеки c++. Если же вы хотите в программе использовать свою функцию, то необходимо объявить прототип функции, после этого в конце программы написать реализацию функции.
Функция может принимать значения или не принимать вообще. Если функция не принимает параметры, то пишется имя функции и пустые скобки, если функция принимает параметры, то в скобках через запятую пишутся параметры. Функция может принимать параметры такие, как: массив, указатель, ссылку, целочисленные переменные, дробные и т. д.
Пример: Написать функцию get(), set(). set - функция установки значения в массив. get - функция получения значений или другими словами печать.
#include<iostream>
#include<conio.h>
using std::cout;
using std::endl;
using std::cin;
const int n = 5;
void set(int []); //прототип функции установки значения
void get(int []); //прототип функции печати значения
void main()
{
int mas[n];
set(mas); //вызов функции установки значения в программе
get(mas); //вызов функции печати в программе
_getch();
}
void set(int s[n]) //реализация функции установки
{
cout<<"SET massiva:\n";
cout<<"Vvedite "<<n<<"elementov massiva: ";
for (int i = 0; i<n; i++)
cin>>s[i];
}
void get(int s[n]) //реализация функции печати
{
cout<<"GET massiv:\n";
for (int i = 0; i<n; i++)
cout<<s[i]<<"\t";
cout<<endl;
}
Функция - это группа операторов у которой есть имя. Во всех предыдущих уроках, код наших программ располагался в одной функции - main. Функции позволяют разбить программу на небольшие части, каждая из которых выполняет какую-то небольшую задачу. Посмотрите на полный код морского боя (раздел - Листинги). В нём больше 500 строк кода. Без функций было бы довольно проблематично написать эту программу. В ней используется 11 функций, самая длинная из которых состоит из 50 строк кода.
Обязательными для функции являются два компонента: определение и вызовы.
Определение функции
Определение функции должно располагаться в глобальной области видимости, до начала функции main. Рассмотрим пример, простого определения:
int simple_function ()
{
return 0;
}
Определение функции состоит из заголовка и тела. Заголовок фукнции включает в себя:
Тип возвращаемого значения
Почти все функции должны возвращать значения. Тип этого значения указывается в заголовке перед именем функции. Вот несколько примеров заголовков функций:
int simple_function()
float simple_function()
char simple_function()
В первом случае функция должна вернуть целое число (int), во втором - вещественное число (float), а в третьем случае - символ (char).
Возвращаемые значения используются для передачи данных из функции в вызывающее окружение. Вызывающее окружение - это то место, откуда вызывается данная функция, подробнее ниже.
Идентификатор или имя функции
Идентификатор (имя) функции задаётся точно также, как и любой другой идентификатор. В данном примере мы создали функцию с идентификатором simple_function (simple - простой).
Список аргументов или параметров
Список аргументов функции записывается в круглых скобках после имени функции. В данном примере список аргументов пуст.
Список аргументов записывается через запятую. Каждый элемент списка состоит из типа и идентификатора. Рассмотрим пример заголовка функции со списком из двух аргументов:
int simple (int a, float b)
В скобках мы записали два аргумента: a и b. У аргумента a тип int, а у аргумента b тип float.
Аргументы используются, когда в функцию нужно передать какие-либо данные из вызывающего окружения.
Тело функции
Тело функции располагается сразу под заголовком и заключено в фигурные скобки. В теле функции может содержаться сколько угодно операторов. Но обязательно должен присутствовать оператор return. Оператор return возвращает значение:
int simple_function ()
{
return 0;
}
Здесь, simple_function всегда будет возвращать 0. Надо признать, что данная функция бесполезна. Напишем функцию, которая принимает из вызывающего окружения два значения, складывает их и возвращает результат в вызывающее окружение. Назовём эту функцию sum (сумма):
int sum (int a, int b)
{
int c;
c = a + b;
return c;
}
Вфункцию передаётся два аргумента: a и b типа int. В теле функции они используются как обычные переменные (они и являются обычными переменными). Давайте договоримся: снаружи функции, переменные, которые передаются в неё, мы будем называть аргументами, а эти же переменные в теле функции - параметрами.
Втеле функции определяется переменная c. А затем, в эту переменную мы помещаем значение суммы двух параметров.
Последняя строчка возвращает значение переменной c во внешнее окружение.
После ключевого слова return нужно указать значение которое будет возвращено. Можно возвращать как простые значения, так и переменные и даже выражения. Например:
return 32; return a; return b; return a+b;
В последнем случае в вызывающее окружение будет возвращён результат суммы переменных a и b.
Обратите внимание, что оператор return не только возвращает значение, но и служит как бы выходом из функции, после него не будет выполнен ни один оператор:
return a;
c = a+b; // этот оператор не будет выполнен
Благодаря этому, с помощью return удобно создавать условия выхода из функций: if (a > 0)
{
return 0;
}
else if (a < 0)
{
return 1
}
Здесь, из функции будет возвращено число в зависимости от значения переменной a: если a больше нуля, то будет возвращён 0, в противном случае - 1.
Вызов функции После того как создано определение функции, её можно вызвать. int sum (int a, int b)
{
int c;
c = a + b; return c;
}
int main()
{
int s;
s = sum(2,2); // вызов функции
cout << s;
return 0;
}
В результате выполнения программы, на экран будет выведено: 4.
Вызов функции состоит из идентификатора функции и списка аргументов в круглых скобках. Вот несколько вызовов функции sum:
int x = 5; |
|
int y = 4; |
|
int z; |
|
sum(0,1); |
// 1 |
sum(x,2); |
// 7 |
sum(x,y); |
// 9 |
z = sum(x,y); // z = 9
Вызывающее окружение
То место, откуда вызывается функция, называется вызывающим окружением. Вызывающим окружением функции sum является функция main, а вызывающим окружением функции main является отладчик или операционная система.
Функция может обмениваться данными с вызывающим окружением благодаря списку аргументов и возвращаемому значению: вызывающее окружение передаёт данные в функцию с помощью аргументов, а функция передаёт данные в вызывающее окружение с помощью возвращаемого значения.
Тип передаваемого в функцию значения должен совпадать с типом указанным в списке аргументов. Нельзя, например, написать вот так:
int simple (int a)
{
return 1;
}
int main ()
{
int b;
b = simple(0.5);
return 0;
}
В списке аргументов мы указали тип int, а в функцию передаётся вещественное значение 0.5. Так делать нельзя.
Рассмотрим более полезный пример: напишем функцию для передвижения персонажа:
int x; // глобальная переменная
int move_x (int dx)
{
x = x + dx;
return x;
}
int main ()
{
int ch; char act; while (1)
{
act = _getch();
ch = static_cast(act);
if (ch == 75) // была нажата стрелочка влево move_x(-1);
else if (ch == 77) // была нажата стрелочка вправо move_x(1);
} // конец while return 0;
} // конец main
Обратите внимание, что для тела if и else if не стоит скобочек. Скобочки ветвлений можно опускать, если в теле ветвления всего один оператор.
Функция move_x двигает персонажа на одну единицу влево или вправо в зависимости от клавиши, которую нажал пользователь.
Создадим ещё одну функцию, а заодно уберём из main часть кода: int x; // глобальная переменная
int move_x (int dx)
{
x = x + dx; return x;
}
void move (int ch)
{
if (ch == 75) // была нажата стрелочка влево move_x(-1);
else if (ch == 77) // была нажата стрелочка вправо move_x(1);
}
int main ()
{
int ch; char act; while (1)
{
act = _getch();
ch = static_cast(act);
move(ch); // вызов функции move
} // конец while return 0;
} // конец main
Обратите внимание, что в функции move на месте типа возвращаемого значения стоит void, кроме того, в теле move нет оператора return.
Объявления функций (прототипы)
В последнем примере, определение функции move_x должно располагаться выше определения move (а определения move_x и move должны располагаться до main), так как в функции move происходит вызов move_x.
Обычно определения всех пользовательских функций располагаются после определения main. При этом используются объявления функций (прототипы). Внесём изменения в предыдущую программу:
int x; // глобальная переменная
void move(int); // прототип (объявление) функции move int move_x(int); // прототип функции move_x
int main ()
{
int ch; char act; while (1)
{
act = _getch();
ch = static_cast(act); move(ch); // вызов move
}
return 0;
}
void move (int ch)
{
if (ch == 75) // была нажата стрелочка влево move_x(-1);
else if (ch == 77) // была нажата стрелочка вправо move_x(1);
}
int move_x (int dx)
{
x = x + dx;
return x;
}
Прототип функций совпадает с заголовком определения, но в прототипе можно опустить имена переменных в списке аргументов. Следующие объявления равносильны:
int move_x(int dx);
int move_x(int);
Объявления функций расположены в начале файла. Прототип функции говорит компилятору, что данную функцию можно вызывать, а её определение будет позже (или находится в другом файле).
Объявление функции может находиться в любом месте программы (за пределами определений функций программы или в любом определении), главное, чтобы оно появилось до первого вызова функции. Если вы не используете объявления, то до первого вызова функции должно стоять определение, которое также может располагаться в любом месте программы.
Возврат void
На месте возвращаемого типа, в определении (и в объявлении) функции move стоит ключевое слово void (void - пусто, пустой). Это значит, что функция не возвращает никакого значения. Следовательно не требуется и оператор return, так как функции нечего вернуть в вызывающее окружение.
Функции на языке С++
Формально в языках С/С++ нет процедур, а имеются только функции. Если же необходима именно процедура, то достаточно создать функцию, возвращающую тип void.
Рассмотрим каким образом применить свою функцию в программе на языке С++. Чтобы использовать в программе свою собственную функцию, необходимо выполнить три действия:
задать прототип функции;
вызвать функцию в необходимом месте, например, в функции main()
дать определение функции.
Разберёмся немного подробнее с тем, что мы перечислили.
Прототип функции — это заголовок функции, который заканчивается точкой с запятой. Прототипы всех функций, используемых в программе, обычно записывают в начале текста программы до определения функций. Прототип необходим для того, чтобы у компилятора была полная информация о типе результата работы функции и о списке параметров, передаваемых в функцию. Когда в тексте программы встретится обращение к функции, то компилятор проверяет правильность её вызова, сверяясь с информацией из прототипа.
Для программиста прототипы тоже полезны: можно в сжатой форме сразу увидеть, какие функции используются в программе, какие параметры им необходимы и т.д.
Вызов функции возможен в любой функции, где это потребуется. Если тип результата функции — void, то вызов записывается отдельным оператором, в остальных случаях — в выражении того же типа, что и тип результата функции. В прочем, языки С/С++ позволяют записать вызов функции в виде отдельного оператора даже в том случае, когда она возвращает тип результата, отличного от void. К примеру, оператор
sin(x);
совершенно законен, хотя вряд ли стоит так делать.
Определение функции состоит из её заголовка и тела, записанного в виде блока. Допустимо записывать определение функций в любой последовательности. Нельзя определять функцию внутри другой функции (С/С++ — это не Паскаль!).
Теперь на конкретном примере рассмотрим применение своей функции.
Пример. Найти максимум из двух чисел. Алгоритм поиска максимума оформить в виде функции.
Возможный вариант программы:
#include <iostream>
using namespace std;
// 1)Прототип функции
double fmax(double a, double b);
int main()
{
double a = 4, b = 3, max;
cout << "a=" << a << " max=" << b << endl;
// 2)Вызов функции
max = fmax(a, b);
cout << "max=" << max << endl;
return 0;
}
// 3)Определение функции
double fmax(double x, double y)
{
double max;
if(x > y)
max = x;
else
max = y;
return max;
}
20.
Структура является объединением простых переменных. Эти переменные могут иметь различные типы: int, float и т. д. (именно разнородностью типов переменных структуры отличаются от массивов, в которых все переменные должны иметь одинаковый тип). Переменные, входящие в состав структуры, называются полями структуры.
Для тех, кто изучает язык C++, структуры являются одной из составляющих главных концепций языка – объектов и классов. На самом деле синтаксис структуры фактически идентичен синтаксису класса. На практике отличие структуры от класса заключается в следующем: структуры в языке С++, как правило, используют в качестве объединения данных, а классы — в качестве объединения данных и функций. Таким образом, изучая структуры в языке С++, мы тем самым закладываем основы для понимания классов и объектов.
Простая структура
Мы начнем рассмотрение со структуры, содержащей три поля, два из которых имеют целый тип и одно поле – вещественный тип. Эта структура предназначена для хранения информации о комплектующих деталях изделий, выпускаемых фабрикой. Компания производит несколько типов изделий, поэтому номер модели изделия включен в структуру как первое из полей. Номер самой детали представлен вторым полем, а ее стоимость – последним, третьим полем.
В программе PARTS определяется структура part и переменная part1 типа part. Затем полям переменной part присваиваются значения
и выводятся на экран.1 |
// parts.срр - структура для хранения информации о деталях изделий |
|
2 |
#include "iostream" |
|
3