Тест
Задание №1: Что не так со следующим фрагментом кода?
void multiply(int a, int b)
{
return a * b;
}
int main()
{
std::cout << multiply(7, 8) << std::endl;
return 0;
}
|
1 |
voidmultiply(inta,intb) { returna *b; } intmain() { std::cout<<multiply(7,8)<<std::endl; return; } |
Задание №2: Какие здесь есть две проблемы?
#include <iostream>
int multiply(int a, int b)
{
int product = a * b;
}
int main()
{
std::cout << multiply(5) << std::endl;
return 0;
}
|
1 |
#include <iostream> intmultiply(inta,intb) { intproduct=a *b; } intmain() { std::cout<<multiply(5)<<std::endl; return; } |
Задание №3: Какой результат выполнения следующей программы?
#include <iostream>
int add(int a, int b, int c)
{
return a + b + c;
}
int multiply(int a, int b)
{
return a * b;
}
int main()
{
std::cout << multiply(add(3, 4, 5), 5) << std::endl;
return 0;
}
|
1 |
#include <iostream> intadd(inta,intb,intc) { returna+b+c; } intmultiply(inta,intb) { returna *b; } intmain() { std::cout<<multiply(add(3,4,5),5)<<std::endl; return; } |
Задание №4: Напишите функцию doubleNumber(), которая принимает целое число в качестве параметра, удваивает его, а затем возвращает результат обратно в caller.
Задание №5: Напишите полноценную программу, которая принимает целое число от пользователя (используйте ), удваивает его с помощью функции doubleNumber() из предыдущего задания, а затем выводит результат на экран.
График функции
А еще это означает, что решать уравнение для всех возможных значений х нет необходимости. Для функции можно построить график, т.е. отобразить зависимость у от х визуально. Для этого используется плоская система координат с осями х и у. Соответственно по оси х откладывается значение переменной х, а по оси у значение переменной у, определенной для этого значения х.
В простых случаях, т.е. когда между переменными существует линейная зависимость, для построения графика достаточно знать координаты 2 точек. Например для функции f(x) = 2х в пределах от 0 до 4 график будет выглядеть так:
Рисунок 538.1. График функции f(x) = 2x.
Сначала мы определяем значения функции для нижнего (х = 0) и верхнего (х = 4) пределов: f(0) = 2·0 = 0, f(4) = 2·4 = 8. Эти результаты и будут координатами точек (показаны на рисунке 538.1 красным цветом), через которые проходит график функции. Прямая, соединяющая эти точки (показана на рисунке 538.1 синим цветом) — это и есть график рассматриваемой функции.
Таким образом, для всех промежуточных значений х, а это могут быть не только натуральные (т.е. целые) числа, мы можем определять значения у по графику. Для этого достаточно провести вертикальную линию из точки, обозначающей значение х, до графика (показан на рисунке 538.1 синей линией), а затем провести горизонтальную линию из точки пересечения вертикальной линии и графика. Пересечение горизонтальной линии с осью у покажет значение переменной у для соответствующего значения х. На рисунке 538.1 подобные действия не показаны, чтобы не усложнять график.
Более того, понятие функции применимо и к простым уравнениям, содержащим только одну неизвестную, а потому постоянную величину, и для таких уравнений тоже можно построить график. Например, уравнение у = 7 — 2 можно записать так: у = f(x) = 5 и тогда графиком функции будет прямая горизонтальная линия, проходящая на высоте 5 делений от оси х.
А теперь несколько слов о том, зачем все это может понадобиться например при изучении теоретической механики или теории сопротивления материалов.
При расчете строительных конструкций, например балок, необходимо определить значение поперечных сил и моментов, действующих в различных сечениях балки, а также углы поворота и перемещения нейтральной оси балки. Для этого строятся эпюры поперечных сил, моментов, углов поворота и прогиба. Так вот эти эпюры и есть графики соответствующих функций.
При этом длина балки l измеряется по оси х, соответственно нижний предел функции х = 0, а верхний предел функции х = l.
Например уравнение моментов М(х) = qlx/2 — qx2/2 при действии на балку равномерно распределенной нагрузки в обще виде можно записать так:
у = f(x) = qlx/2 — qx2/2 (538.6)
Но на этом увлекательный мир уравнений, а также функций, их аргументов и т.п. не заканчивается, а только начинается. Следующий уровень сложности — это дифференциальные уравнения, когда одна из неизвестных величин является производной или дифференциалом второй неизвестной величины, но это уже отдельная большая тема.
Ответы
Чтобы просмотреть ответ, кликните на него мышкой.
Ответ №1
Функция multiply() имеет тип возврата void, что означает, что эта функция не возвращает значения. Но, так как она всё равно пытается возвратить значение с помощью оператора return, мы получим ошибку от компилятора. Функция должна иметь тип возврата int.
Ответ №2
Проблема №1: main() передаёт один аргумент в multiply(), но multiply() имеет два параметра.
Проблема №2: multiply() вычисляет результат и присваивает его локальной переменной, которую не возвращает обратно в main(). А поскольку тип возврата функции multiply() — int, то мы получим ошибку (в некоторых компиляторах) или неожиданные результаты (в остальных компиляторах).
Ответ №3
Функция multiply() принимает следующие параметры: и . Сначала процессор обрабатывает , т.е. . Затем уже выполняет операцию умножения, результатом которой является . Ответ: 60.
Ответ №4
int doubleNumber(int a)
{
return 2 * a;
}
|
1 |
intdoubleNumber(inta) { return2*a; } |
Ответ №5
#include <iostream>
int doubleNumber(int a)
{
return 2 * a;
}
int main()
{
int a;
std::cout<<«Enter a number: «;
std::cin >> a;
std::cout << doubleNumber(a) << std::endl;
return 0;
}
/*
// Следующее решение является альтернативным:
int main()
{
int a;
std::cout<<«Enter a number: «;
std::cin >> a;
a = doubleNumber(a);
std::cout << a << std::endl;
return 0;
}
*/
|
1 |
#include <iostream> intdoubleNumber(inta) { return2*a; } intmain() { inta; std::cout<<«Enter a number: «; std::cin>>a; std::cout<<doubleNumber(a)<<std::endl; return; } |
Примечание: У вас могут быть и другие решения заданий №4 и №5 — это ок. В программировании есть много случаев, когда одну задачу можно решить несколькими способами.
Когда начинают учить алгебру в школе?
Разделение математики на несколько областях определило для алгебры решение определенных уравнений, под названием алгебраические уравнения. Что такое алгебра как предмет можно узнать только в 7-ом классе. Именно тогда вместе привычной математики появляется два отдельных предмета: алгебра и геометрия. Изучение начинается с простых понятий, также как и в случае других учебных процессов, все строится от простого материала к сложному.
7 класс оптимальное время для того, чтобы узнать, что такое алгебра. Вместо обычных операций с числами осуществляется переход на переменные. Так проще понять общие законы арифметики, научиться работать с неизвестными и функциями. Алгебру можно разделить на 5 отдельных категорий:
— общая алгебра
— элементарная алгебра
— линейная алгебра
— универсальная алгебра
— алгебраическая комбинаторика.
Школьная программа подразумевает изучение исключительно элементарной категории. Элементарная алгебра занимается изучением операций с вещественными числами. Перемененные и постоянные обозначены в алгебре символами в виде букв. С их помощью происходит преображение уравнений и математических выражений на основе четких правил.
Функция
Даже такие относительно простые уравнения как (538.5), решать 100 раз очень долго. А ведь уравнения бывают гораздо более сложными, а область определения практически бесконечной.
Для таких случаев и придумано понятие функции. Т.е. функция — это не только обозначение связи между неизвестными переменными, но еще и как бы обозначение действий, которые необходимо совершить для определения значения функции. Возможно поэтому и выбрано название «функция», от латинского functio — исполнение, совершение, осуществление.
При этом математическая запись следующего вида:
у = f(x) = x · 2 (538.5.2)
означает, что у является функцией аргумента х, а для определения значения функции — переменной у — достаточно значение аргумента функции — независимой переменной х — умножить на 2.
Переменные неизвестные величины
Иногда жизнь ставит перед нами более сложные задачи. Например, мы по-прежнему хотим купить 2 пирожка, но еще не определились с выбором, так как пирожков с различной начинкой на рынке много и цена у них разная, от 3 до 30 рублей, а денег в кармане мало.
В этом случае с точки зрения математики разная цена пирожков становится переменной величиной х, а требуемая сумма денег для покупки пирожков — переменной величиной у, зависящей от значения переменной х. Языком математики эту зависимость можно выразить так:
у = 2 · х (538.5)
Т.е если один пирожок стоит 3 рубля, то нам для приобретения 2 пирожков потребуется как и прежде 6 рублей, а если мы хотим купить 2 пирожка, стоящих по 30 рублей каждый, то нам потребуется уже 60 рублей. Это конечно еще не высшая математика, но очень близко к тому.
В данном случае переменная х — возможная цена пирожка — это аргумент функции (или аргумент продавца, расхваливающего различные начинки пирожков). От нашего желания купить пирожков побольше и подешевле цена никак не зависит, поэтому переменная х является независимой переменной. А вот переменная у — необходимое количество денег, которое мы готовы потратить на покупку 2 пирожков, зависит и от нашего желания сэкономить и от значения переменной х.
Часто переменные величины называются просто переменными, а уравнения с двумя переменными — функциональными уравнениями.
Ещё примеры
Рассмотрим ещё несколько вызовов функций:
#include <iostream>
int add(int a, int b)
{
return a + b;
}
int multiply(int c, int d)
{
return c * d;
}
int main()
{
std::cout << add(7, 8) << std::endl; // внутри функции add(): a = 7, b = 8, значит a + b = 15
std::cout << multiply(4, 5) << std::endl; // внутри функции multiply(): c = 4, d = 5, значит c * d = 20
// Мы можем передавать целые выражения в качестве аргументов
std::cout << add(2 + 3, 4 * 5) << std::endl; // внутри функции add(): a = 5, b = 20, значит a + b = 25
// Мы можем передавать переменные в качестве аргументов
int x = 4;
std::cout << add(x, x) << std::endl; // будет 4 + 4
std::cout << add(1, multiply(2, 3)) << std::endl; // будет 1 + (2 * 3)
std::cout << add(1, add(2, 3)) << std::endl; // будет 1 + (2 + 3)
return 0;
}
|
1 |
#include <iostream> intadd(inta,intb) { returna+b; } intmultiply(intc,intd) { returnc *d; } intmain() { std::cout<<add(7,8)<<std::endl;// внутри функции add(): a = 7, b = 8, значит a + b = 15 std::cout<<multiply(4,5)<<std::endl;// внутри функции multiply(): c = 4, d = 5, значит c * d = 20 // Мы можем передавать целые выражения в качестве аргументов std::cout<<add(2+3,4*5)<<std::endl;// внутри функции add(): a = 5, b = 20, значит a + b = 25 // Мы можем передавать переменные в качестве аргументов intx=4; std::cout<<add(x,x)<<std::endl;// будет 4 + 4 std::cout<<add(1,multiply(2,3))<<std::endl;// будет 1 + (2 * 3) std::cout<<add(1,add(2,3))<<std::endl;// будет 1 + (2 + 3) return; } |
Результат выполнения программы:
С первыми двумя вызовами всё понятно.
В третьем вызове, параметрами являются выражения, которые сначала нужно обработать. и результат присваивается переменной . и результат присваивается переменной . Результатом выполнения функции является значение .
Следующая пара относительно лёгкая для понимания:
int x = 4;
std::cout << add(x, x) << std::endl; // будет 4 + 4
|
1 |
intx=4; std::cout<<add(x,x)<<std::endl;// будет 4 + 4 |
Здесь уже и . Поскольку , то . Результат — .
Теперь рассмотрим вызов посложнее:
std::cout << add(1, multiply(2, 3)) << std::endl; // будет 1 + (2 * 3)
| 1 | std::cout<<add(1,multiply(2,3))<<std::endl;// будет 1 + (2 * 3) |
При выполнении этого процессор должен определить значения параметров и функции add(). С параметром всё понятно — мы передаем значение (). А вот чтобы определить значение параметра , нам необходимо выполнить операцию умножения: , результат — . Затем возвращает число , которое и выводится на экран.
Короче говоря:
Последний вызов может показаться немного сложным из-за того, что параметром функции add() является другой вызов add():
std::cout << add(1, add(2, 3)) << std::endl; // будет 1 + (2 + 3)
| 1 | std::cout<<add(1,add(2,3))<<std::endl;// будет 1 + (2 + 3) |
Но здесь всё аналогично примеру выше. Перед тем, как процессор вычислит внешний вызов функции add(), он должен обработать внутренний вызов функции . . Затем процессор обрабатывает функцию , результатом которой является значение . Затем передается в std::cout.
Короче говоря:
Параметры и аргументы функций
Во многих случаях нам нужно будет передавать данные в вызываемую функцию, чтобы она могла с ними как-то взаимодействовать. Например, если мы хотим написать функцию умножения двух чисел, то нам нужно каким-то образом сообщить функции, какие это будут числа. В противном случае, как она узнает, что на что перемножать? Здесь нам на помощь приходят параметры и аргументы.
Параметр функции — это переменная, которая используется в функции, и значение которой предоставляет caller (вызывающий объект). Параметры указываются при объявлении функции в круглых скобках. Если их много, то они перечисляются через запятую, например:
// Эта функция не имеет параметров
void doPrint()
{
std::cout << «In doPrint()» << std::endl;
}
// Эта функция имеет один параметр типа int: a
void printValue(int a)
{
std::cout << a << std::endl;
}
// Эта функция имеет два параметра типа int: a и b
int add(int a, int b)
{
return a + b;
}
|
1 |
// Эта функция не имеет параметров voiddoPrint() { std::cout<<«In doPrint()»<<std::endl; } voidprintValue(inta) { std::cout<<a<<std::endl; } intadd(inta,intb) { returna+b; } |
Параметры каждой функции действительны только внутри этой функции. Поэтому, если printValue() и add() имеют параметр с именем , то это не означает, что произойдет конфликт имен. Эти параметры считаются независимыми и никак не взаимодействуют друг с другом.
Аргумент функции — это значение, которое передается из caller-а в функцию и которое указывается в скобках при вызове функции в caller-е:
printValue(7); // 7 – это аргумент функции printValue()
add(4, 5); // 4 и 5 – это аргументы функции add()
|
1 |
printValue(7);// 7 – это аргумент функции printValue() add(4,5);// 4 и 5 – это аргументы функции add() |
Обратите внимание, аргументы также перечисляются через запятую. Количество аргументов должно совпадать с количеством параметров, иначе компилятор выдаст сообщение об ошибке
