Аргумент измеряется в радианах
Объявление переменных в программе.
Переменная представляет собой имя ячейки памяти, которая может хранить конкретное значение. В зависимости от типа хранимого значения, например, целое число, символ, число с плавающей запятой, тип переменной может быть разным. Прежде чем использовать переменную, ее необходимо объявить. Объявление переменной считается оператором, поэтому после объявления ставится точка с запятой. Имя переменной или идентификатор должно нести смысловую нагрузку, которая описывает использование переменной. Переменные одного и того же типа можно перечислить через запятую. Переменную можно объявить в любом месте программы. Если переменная объявлена вне всяких функций, в том числе main, она является глобальной и может использоваться в любом месте программы. Переменная, объявленная внутри блока, в том числе внутри функции (например, main), является локальной и может использоваться только внутри блока. Переменную можно объявить в выражении, например,
float f = x + y ;
В программе можно использовать константы. В отличие от переменной, константа не меняет свое значение в программе. Описание константы начинается со слова const.При объявлении переменной можно указать ее тип, иначе он будет определен автоматически. Т.к. в программировании важную роль играют 8 и 16 системы счисления, можно использовать 8 и 16-ричные константы. Восьмеричная константа начинается с цифры 0, шестнадцатеричная: 0х. например, 016, 01677 ― 8-ичные константы, 0х16, 0хА3В, 0xFFFF ― 16-ичные константы.
Общий вид объявления переменной:
<тип_переменой> <имя_переменной>
Основные типы переменных
| Тип | Диапазон значений | Размер в байтах |
| char(символ) | -128 . . . 128 Обычно используется для хранения букв | |
| int(целый) | -32768 … 32767 | |
| unsigned(целый без знака) | 0 … 65535 | |
| long(длинный целый) | -2147483648 … 2147483647 | |
| float(вещественный) | -3. 4E-38 … 3. 4E38 | |
| Double(двойной вещественный) | 1.7E-308 … 1. 7E308 |
E означает 10 в степени
Пример.
int x, y, sum;
float radius;
Присваивание значений переменным
Оператор присваивания = знак «равно»
age =17; a=2; a=a*a; i=i+1 ;
При объявлении переменной ей можно присваивать начальное значение (инициализировать)
int age=17;
float distance =238857;
В отличие от других языков здесь оператор присваивания может использоваться в выражениях, которые также включают в себя операторы сравнения или логические операторы, например,
If (( f = x―y) > 0) cout << ²число х больше, чем у ²;
Еще одна особенность использования оператора присваивания:
a = b = c = x*y
Этот оператор выполняется справа налево.
Также имеются дополнительные операции присваивания: += - = /= *= % =
n = n + 5 аналогично n +=5
Здесь += аддитивная операция присваивания, в результате выполнения которой величина, стоящая справа прибавляется к значению переменной, стоящей слева
m -=20 m=m-20
m *=20 m=m*20
m /=20 m=m/20
m %=20 m=m%20
Операция х +=5 выполняется быстрее, чем х =х+5
Ввод с клавиатуры.
Для чтения ввода с клавиатуры используется входной поток cin, который является объектом класса istream (входной поток). При использовании cin необходимо указать переменную, в которую cin поместит данные. В cin используется оператор извлечения >> , который извлекает данные из входного потока.
Пример.
#include <iostream. h>
void main(void)
{
int a, b;
char simvol;
cout << ²введите два числа и нажмите enter: ² ;
cin >> a >> b;
cout << ²были введены числа: ² << a << b << endl;
cout << ²введите любой символ и нажмите enter: ²;
cin >> simvol;
cout << ² был введен символ ² << simvol << endl;
}
В текст программы необходимо включать комментарии. Комментарий в С++ начинается с / /. Когда компилятор встречает двойной слэш, он игнорирует весь текст в текущей строке, который следует за / / . Также можно заключать комментарий в символы /* */, такой комментарий может охватить несколько строк. Можно использовать пустые строки для разделения операторов. Пустые строки компилятор пропускает.
Основные операции
Математические: Сложение + вычитание -
умножение * деление / % остаток от целочисленного деления
Операция увеличения на 1 : + + (инкремент)
Операция уменьшения на 1 - - (декремент)
Операция увеличения можно записать::
а = а + 1, или а++, или a+=1
Существует префиксная(до) и постфиксная(после) операции увеличения
Пример:
а = b++; или a = b;
b = b + 1; постфиксная
a = ++b; или b = b + 1;
a = b; префиксная
Существуют аналогичные операции уменьшения.
Префиксные операции сначала производят увеличение или уменьшение значения переменной, а затем используют это значение.
Постфиксные операции сначала используют значение переменной, а затем увеличивают или уменьшают его.
Операции используются для записи выражений. Выражение―это некоторая допустимая комбинация переменных, констант, операций. Если операнды при записи операции имеют один и тот же тип, то и результат имеет тот же тип. Поэтому при выполнении например, операции деления над целыми числами остаток отбрасывается, т.е.
11 / 3 = 3 1 / 2 = 0
Для того, чтобы получить вещественное число, следует в записи числа использовать десятичную точку: 1. / 2. = 0.5
=> pow (x+y , 1. / 4.) или pow (x + y, 0.25)
Другие операции С++ и порядок их выполнения
| Операция | имя | пример |
| [ ] | индексация | a [ i ] |
| ( ) | вызов функции | sin(x), main(void) |
| sizeof | размер типа | sizeof(int) |
| ++ | приращение после | a++ |
| ++ | приращение до | ++a |
| -- | уменьшение после | a-- |
| -- | уменьшение до | --a |
| & | адрес объекта | &a |
| * | разыменование | *a |
| ~ | Дополнение, инвертирует биты значений | ~a |
| ! | логическое НЕ | !a |
| * | умножение | a * b |
| / | деление | a / b |
| % | остаток от целочисленного деления | a % b |
| + | сложение | a + b |
| ― | вычитание | a - b |
| << | сдвиг влево; сдвигает биты значения влево на указанное количество разрядов | a<<1 |
| >> | сдвиг разрядов вправо | a>>1 |
| & | побитовое И | a&b |
| | | побитовое ИЛИ | a | b |
| ^ | побитовое исключающее ИЛИ | a ^ b |
| && | логическое И | a&& b |
| | | | логическое ИЛИ | a | | b |
| < | меньше, чем | a<b |
| > | больше, чем | a>b |
| = = | равно | a= = b |
| ! = | не равно | a !=b |
Операции, находящиеся в верхней части имеют более высокий приоритет. Операции внутри каждой части имеют одинаковый приоритет. Управлять порядком выполнения арифметических операций можно с помощью круглых скобок.
Таблица истинности для логических операций
| x | y | x && y | x | | y | ! x | x ^ y |
Операции отношения и логические имеют более низкий приоритет, чем арифметические операции. Это значит, что выражение 12>10+1 аналогично выражению 12>(10+1)
Среди логических операций – старшая операция отрицания, затем выполняются операции отношения, а затем логические «И», «ИЛИ» и т.д.
Каждое условное выражение проверяется, истинно оно или ложно, причем в языке нет логического (булевого) типа, поэтому результатом логического выражения является целочисленное арифметическое выражение: ложь – 0, истина – ненулевая величина (1)
Пример:
#include <iostream. h>
void main(void)
{
int tr, fal;
tr = (101<=105); //выражение истинно
fal = (101>105); //выражение ложно
cout << ²true ² << tr << ² false ² << fal << endl;
}
Результат:
true 1 false 0
Поразрядные (побитовые операции) можно проводить с любыми целочисленными переменными и константами.
Побитовые операции позволяют обеспечить доступ к каждому биту информации. При их выполнении сравниваются не значения выражений, как в логических операциях, а значения каждой пары разрядов (битов). Часто поразрядные операции используются в драйверах устройств, программах, связанных с принтером, модемом и др. Поразрядные операции удобны для хранения информации в сжатом виде ― в виде флагов (включено, выключено, 0 или 1). В одном байте можно хранить 8 флагов. Например, проверка установлен ли флаг в 2-ом разряде переменной а:
|
Флаг в 6-ом разряде РС внешнего устройства означает «разрешение прерывания»
if (a & 0100) cout << “ прерывания разрешены”
Сдвиг вправо на 1 разряд аналогичен операции деления на 2 в 8 с/с
|
|
Сдвиг вправо ― аналогичен операции умножения на 2 в 8 с/с
Пример: написать программу для вычисления функции
 |
#include <iostream.h>
#include <math.h>
void main(void)
{
const pi = 3.1415;
float x=3. 3, f ;
f=exp(x*sqrt(2))*cos(sqrt(x/3)+pi/4)/(pow(2*pi*x,1./3.)+log(atan(x)));
cout<<”f=”<<f;
}
Для каждой операции определено количество операндов: один операнд― унарная операция, два операнда―бинарная операция, например, операции сложения или вычитания
Условный оператор.
Оператор if позволяет осуществить проверку условия и на основании этой проверки выполнять операторы. Условный оператор в неполной форме :
if ( условие ) оператор;
Если условие выполняется, выполняется оператор, если не выполняется, выполняется следующий за if оператор. Оператор может быть составным. (Составной оператор – это несколько операторов, заключенных в { } ).
Условный оператор в полной форме:
if ( условие)
оператор1;
else
оператор2;
Если условие истинно, выполняется оператор 1, если ложь, то выполняется оператор 2, «else» - иначе
Пример №1. Найти минимум из трех чисел а, b, с
#include < iostream.h>
void main(void)
{
float a, b, c, min;
cout << ² введите 3 числа: ²;
cin >> a >> b >> c;
if ((a<b) &&(a<c)) min=a;
else if (( b<a) && (b<c)) min=b;
else min = c;
cout << “min = “ << min ;
}
Пример №2 Даны действительные числа х и у . Если оба отрицательны, то каждое значение заменить модулем. Если отрицательно одно из них, то оба увеличить на 0.5. Если оба неотрицательны и ни одно из 
них не принадлежит отрезку [0.5, 2], оба значения уменьшить в 10 раз.
#include < iostream.h>
#include < math.h>
void main(void)
{
float x, y ;
cout << “Введите 2 действительных числа :” ;
cin >> x >> y ;
if ((x<0) && (y<0)) { x=fabs(x); y= fabs(y);}
if ((x<0) | | (y<0)) {xx=x+0.5; y=y+0.5;}
if (((x>=0) && (y>=0)) && ((x<0.5) | | (x>2)) && ((y<0.5) | | (y>2)))
{ x=x/10; y=y/10;}
cout <<:x=: <<x<<”y=” << y;
}
Оператор выбора switch.
Оператор позволяет осуществлять множественный выбор. Общая форма оператора:
Switch (выражение)
{
case constant1: оператор1; break;
case constant2: оператор2; break;
. . .
Цикл while
Это цикл с предусловием, т.к. проверка условия находится в начале цикла. Пока условие истинно, цикл работает. Если условие ложно, то цикл не выполнится ни разу.
Основная форма имеет вид:
while (условие) оператор;
Оператор может быть простым, составным или пустым. Цикл выполняется до тех пор, пока условие истинно. Когда условие будет ложным, произойдет передача управления следующему по порядку оператору.
Пример. №1 Программа требует ввести Д (да) для окончания работы. При вводе любого другого символа звучит сигнал.
#include <iostream.h>
void main(void)
{
int signal = 1;
char bukva;
Оператор do while.
Это цикл с постусловием. В операторе do while проверка условия происходит в конце цикла, поэтому тело цикла исполняется хотя бы один раз до тех пор, пока условие истинно. Основная форма записи этого оператора:
do оператор while ( условие );
если оператор составной, то:
do
{
оператор1; оператор2; . . . ; операторn;
}
while (условие);
Пример №4. Вычислять сумму двух чисел с запросом конца вычислений.
#include <iostream.h>
void main(void)
{ float x, y, sum; char zapros;
do
{
cout << ²введите два числа: ²;
cin >> x >> y;
sum = x + y ;
cout << “sum=” << sum << endl;
cout << “завершить программу (д, Д) ?”; cin >> zapros;
}
while ((zapros = = ’д’) | | (zapros = = ’Д’));
}
Пример № 5. Вычислить 
c точностью e. Точность считается достигнутой, если очередное слагаемое меньше, чем e.
#include <iostream.h>
#include <math.h>
void main (void)
{ float f = 0, x , s, e ; int k = 1;
cout << “введите х:”; cin >> x;
cout <<” введите точность” ; cin >> e;
do
{ s= sqrt(fabs(x))/pow(k, 3) ;
f + = s;
k++;
}
while (fabs(s) >e);
cout << “ f = ” << f;
}
Оператор цикла for
Оператор цикла for позволяет повторить один или несколько операторов определенное количество раз. Основная форма цикла for имеет следующий вид:
for (инициализация; проверка условия; изменение) оператор;
В общем виде этот оператор выглядит так:
for(выражение1; выражение2; выражение3) оператор;
Инициализация используется для присвоения начального значения параметру цикла. Проверка условия - обычно условие, при котором происходит выход из цикла. Изменение - приращение параметра цикла.
Выполнение цикла происходит до тех пор, пока условное выражение истинно.
Пример. for ( i=0 ; i<10 ; i++) cout << i << endl ;
В результате выполнения этого оператора будут напечатаны в столбик цифры от 0 до 9. Для печати этих цифр в обратном порядке в строчку :
for ( I = 9 ; I >=0 ; i - - ) cout << ‘ ‘ << i ;
Оператор может быть составным.
Пример. Вычислить факториал числа n. ( n!=1*2*. . . *n)
#include <iostream.h>
void main(void)
{
int i, n; float fact=1;
cout << ²введите число, факториал которого вычислить: ² ; cin >> n;
for ( i = 1; i <= n; i++) fact=fact*i;
cout << ²n!= ² << fact;
}
Параметр цикла не обязательно изменяется с шагом 1.
Пример. Вывод каждого пятого числа в диапазоне от 0 до 100.
#include <iostream.h>
void main(void)
{
int i;
for (i=0; i<=100; i+=5)
cout << i << ‘ ‘;
}
(i+=5 аналогичен оператору i=i+5)
Цикл for позволяет также использовать в качестве параметров цикла переменные различных типов (char, float, . . . )
Пример.
#include < iostream. h>
void main(void)
{
char bukva;
float a;
for (bukva=’a’; bukva<=’я’; bukva++)
cout << bukva << ‘ ‘;
cout << endl;
for (a=0. 0; a<=1; a+=0. 1)
cout << a << ‘ ‘;
cout << endl;
}
Пример дано натуральное число n. Вычислить значения функции 
для х=1, 1.1, 1.2, 1.3, . . . , 1 + 0.1n
#include <iostream.h>
#include<math.h>
void main(void)
{ int n ; float x, y ;
cout << “ введите n” ; cin >> n ;
for ( x=1 ; x<=1+0.1*n ; x+=0.1 )
{
y = (x*x-3*x+2) / sqrt ( 2*pow(x, 3) -1 );
cout << y << “ “;
}
}
Оператор continue.
Если оператор continue встретился в цикле, происходит переход к следующей итерации цикла. В циклах while и do while - на проверку условия, в цикле for - на приращение шага. Этот оператор используется, если необходимо закончить текущую итерацию и не выполнять оставшиеся операторы, а сразу перейти к следующей итерации цикла.
Пример. Напечатать натуральные числа, кратные 7.
#include <iostream.h>
void main(void)
{
int i;
for ( i=1; i<1000; i++ )
{
if ( i%7 ) continue; / / или if ( i!=0 ) continue
cout << ²число ²<< i << ²кратно 7² << endl;
}
}
. . .
goto exit;
. . .
}
}
exit: cout << ²быстрый выход из вложенных циклов²;
Массивы
Массив - это набор данных одного и того же типа, собранных под одним именем. Каждый элемент массива определяется именем массива и порядковым номером в этом массиве, который называется индексом. Индекс всегда целое число.
Объявление одномерного массива
тип имя_массива [ размер]
Объявление n-мерного массива
тип имя_массива [ размер1][ размер2]. . .[размер n] .
Мы знаем, что С++ позволяет инициализировать переменные при объявлении. То же верно и для массивов. При объявлении массива можно указать начальные значения, поместив их между фигурных скобок. Если массив инициализирован при объявлении, то используется 0 для индекса первого элемента массива, а индекс последнего элемента на 1 меньше размерности массива.
int a [5] = { 100, 200, 300, 400, 500 };
float b[3]={1. 1, 2. 2, 3. 3};
Если не указывать первоначальное значение элемента, программа будет инициализировать его с нулем. Если не указывать размер массива, который мы инициализируем, С++ сам определит количество ячеек памяти под массив.
int [ ] = { 1, 2, 3, 4, 5 }
Пример №1. Записать –1 вместо минимального элемента массива и подсчитать количество отрицательных элементов.
#include <iostream.h>
void main(void)
{
int i, n, kol = 0, nommin ; float a[100], min ;
cout <<” n=” ; cin >> n;
for ( i=1; i<=n; i++ )
{ cout << “введите” << i << “элемент массива” ; cin >> a[ i ]; }
min = a[1] ; nommin = 1;
for ( i=1; i<=n; i++ )
if ( ( a[i] < 0 ) { kol ++ ;
if ( a[ i ] < min) { min = a [ i ];
nommin = i ;
}
a[ nommin] = -1 ;
cout <<“\nизмененный массив :\n”
for ( i=1; i<=n; i++ ) cout << a[ i ];
cout << “ \nколичество отрицательных элементов: ” << kol;
}
|
|
#include<iostream.h>
#include<math.h>
void main ( )
{ int n, i, nom; float a[100], sr, sum = 0, min;
cout <<” введите количество элементов”;
cin >> n;cout << “ введите”<<n<<”чисел\n”;
for (i=1; i<=n; i++)
{cin >>a[i]; sum+=a[i];}
sr=sum/n;
min=fabs(sr – a[1]); nom = 1;
for (i=2; i<=n; i++)
{ if (fabs(sr – a[i])<min) { min= fabs(sr – a[i]) ; nom = i;}
}
cout <<” ближе всего к среднему” << nom << “элемент”;
}
Пример №3. Дано натуральное число. Получить новое число, записав цифры исходного числа в обратном порядке.
an 10n + an-1 10n-1 +… + a0 100 + a -1 10 -1 + …
#include<iostream.h>
#include<math.h>
void main ( )
{ int n, a[10], I=0, st, j;
cout << “введите натуральное число”; cin >> n;
while (n) // т.е. пока n ¹0
{ a[i++] = n – n/10*10; // последняя цифра
n/=10; //число без последней цифры
st = j = i – 1;
for ( i = 0; i < st; i++)
{ n+=a[I]*pow(10, j); j – – ; }
cout << “новое число :” << n;
}
Вложенные циклы.
Когда один цикл находится внутри другого, то говорят, что это вложенные циклы. Вложенные циклы часто встречаются при обработке таблиц чисел (матриц). Во вложенных циклах быстрее работают внутренние циклы.
Матрица – таблица чисел с адресами:
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] 2[2][2] a[2][3]
Двумерные массивы можно инициализировать при объявлении, например:
Int a[2][3]={1, 2, 2,
3, 4, 5 };
При этом левый верхний элемент матрицы имеет адрес a[0][0]
Матрицу можно заполнять с клавиатуры или использовать генератор случайных величин.
Пример №1. Дана действительная квадратная матрица порядка n. Выяснить, верно ли, что наибольшее из значений элементов главной диагонали больше, чем наименьшее из значений элементов побочной диагонали. Для заполнения матрицы будем использовать генератор случайных величин.
|
#include<iostream.h>
#include<stdlib.h>
#include<iomanip.h>
void main ( )
{ int n, a[10][10], i, j, max, min;
cout<<”введите размерность матрицы:”;
cin>>n;
randomize(); //инициализация генератора случайных величин
for ( i = 1; i <=n; i++)
{
for ( j = 1; j <=n; j++)
{
a[i][j]=random(100)-random(100);
cout << setw(5)<<a[i][j];
}
cout<<endl;
}
max=a[1][1]; min=1[1][n];
for ( i = 1; i <=n; i++)
if ( a [i] [i] > max) max = a[i][i];
for ( i = 1, j=n; i <=n; i++, j--)
if ( a [i] [j] < min) min = a[i][j];
if (max > min) cout<<”верно”;
else cout << “неверно”;
}
При вводе матрицы с клавиатуры можно использовать функции позиционирования курсора в нужное место экрана, чтобы при вводе числа отображались в виде таблицы. Для этого используется заголовочный файл <conio.h> , который содержит функции:
gotoxy(a, b) перемещает курсор в позицию а строки в
wherex() , wherey() возвращают координаты x, y текущего положения курсора.
сlrscr() очистка экрана
Пример №2. Дана действительная матрица размера n´m. Найти среднее арифметическое положительных элементов каждого столбца матрицы. Ввод матрицы с клавиатуры с использованием позиционирования курсора.
#include <iostream.h>
#include <conio.h>
void main(void)
{
int a[10][10], i, j, n, m, kol, sum; float sr;
cout <<”введите количество строк”; cin >> n;
cout << “введите количество столбцов”; cin >> m;
for ( i = 1; i <=n; i++)
{
for ( j = 1; j <=n; j++)
{ gotoxy(wherex()+5*j, wherey()-1);
cin >> a[i][j];
}
cout << endl;
}
for(j = 1; j <= n; j++)
{
sum = kol = 0;
for ( I = 1; I < = m; i++)
if (a[i][j]>0)
{
sum+= a[i][j];
kol++;
}
if (kol ==0) cout << ²в столбце номер ² << j << ² нет положительных элементов²;
else
{
sr=sum/kol;
cout << ²в столбце номер ² << j << ² ср арифм полжит элементов=² << sr;
}
}
Вложенные циклы используются не только для обработки матриц.
Пример №3. Получить все числа, которые входят в последовательность по одному разу.
#include <iostream.h>
#include <iomanip.h>
void main(void)
{
int n=20;
int a[20]; // исходный массив А
int b[20]; // массив из чисел, которые не повторяются
int i, j; // параметры циклов
int k; // количество неповторений
int nom = 0; // номер элемента в массиве В
for ( i = 0; i < n; i++)
{cout << ²введите ² << i << ² элемент массива : ² ; cin >> a[i];
}
for (i=0; i<n; i++)
{ k=1;
for (j=1; j<n; j++) if (a[i]!=a[j]) k++;
if (k ==n-1) b[nom++]=a[i];
}
cout << ² массив из чисел, которые не повторяются: ² ;
for ( i=0; i< nom; i++)
cout << setw(8)<<b[i];
}
Пример №4. Отсортировать массив (расположить элементы в порядке возрастания)
#include <iostream.h>
#include <stdlib.h>
#include <iomanip.h>
void main(void)
{
int a[10], i, j, x;
randomize(); // заполнение массива случайными числами
cout << ² исходный массив: ² << endl;
for (i=0; i<10; i++)
{ a[i]=random(30)-random(30);
cout << setw(8) << a[i]; }
for ( i=0; i<9; i++)
for ( j=i; j<10; j++)
if (a[j+1]<a[j])
{
x=a[j]; a[j]=a[j+1]; a[j+1]=x;
}
cout << ²отсортированный массив : ² << endl;
for ( i=0; i<10; i++) cout << setw(8) << a[i];
}
Указатели.
(Понимание и правильное использование указателей очень важно для создания хороших программ на С++. Указатели необходимы для успешного использования функций и динамического распределения памяти.)
Указатель – это переменная, которая содержит адрес некоторого объекта.Здесь имеется в виду адрес в памяти компьютера. Если переменная будет указателем, она должна быть соответствующим образом объявлена. Указатель объявляется следующим образом:
тип *<имя переменной>
Тип-это некоторый тип языка С++
* означает, что следующая за ней переменная является указателем Например:
char *ch // идентификатор ch указывает на объект типа char
int *temp, i, *j // i-переменная типа int; temp , j - указатели на // объект типа int
float *f // f-указатель на объект типа float
С указателями связаны две операции: & и *
Обе эти операции являются унарными, т. е. имеют один операнд, перед которым они ставятся. Операция & соответствует операции «взять адрес», операция * – разыменование, означает «извлчь значение, расположенное по указанному адресу» . Простейшие действия с указателями в программе:
#include <iostream.h>
void main(void)
{
int x, y, *px;
x=2;
px=&x; //px содержит адрес переменной х (х=2)
y=*px; // извлечь значение, находящееся по адресу рх и записать ее в у // y=2
*px=10; // x=10
}
Тот же самый результат можно получить без использования указателей:
#include <iostream.h>
void main(void)
{
int x, y;
x=2;
y=x;
}
Унарная операция * может использоваться в левой части оператора присваивания для того, чтобы какие-то данные были сохранены в области памяти, на которую показывает указатель.
Пример.
#include <iostream. h>
void main(void)
{
int x, *px;
px=&x; // px содержит адрес переменной х
*px=10; // изменить значение, находящееся по адресу рх(в результате х=10)
}
В языке С++ существует связь между массивами и указателями. Имя массива – это адрес памяти, начиная с которого расположен массив, т. е. Имя массива является указателем еа первый элемент массива. Если объявлен массив а:
int a[10];
то идентификатор а является указателем на массив, точнее на первый элемент массива
Операторы
int a[10], *pa;
pa=a и pa=&a[0] приведут к одному и тому же результату.
Для того, чтобы получить значение 6-го элемента массива «а», можно написать:
a[5] или *(a+5)
Преимущество второго варианта в том, что арифметические операции над указателями выполняются быстрее, если мы работаем с подряд идущими элементами массива.
Если выбор элементов массива случайный, то быстрее работа с индексами.
Функции.
Функция -это часть программы, предназначенная для решения определенной задачи. Обычно функция вызывается несколько раз. Стандартные математические функции находятся в файле <math.h>. В программе функции находятся перед функцией main. Общий вид функции:
тип < имя функции > (список параметров)
{
объявления переменных;
операторы;
}
тип- тип значения, которое возвращает функция с помощью оператора return
список параметров состоит из перечня типов и имен параметров, разделенных запятыми. Функция может не иметь параметров и не возвращать значение, например
void main(void); void означает «пустой». Выполнение программы всегда начинается с главной функции main. Если в программе встречается вызов функции, выполняются операторы, находящиеся внутри функции, после завершения функции программа продолжает работу с оператора, следующего за именем функции.
Пример№1
#include <iostream.h>
void show(void)
{
cout << ² Borland C++ ² << endl;
}
void main(void)
{
cout << ² перед вызовом функции ² << endl;
show(); // обращение к функции
cout << ² после функции ² << endl;}
В результате будет напечатано:
перед вызовом функции
Borland C++
после функции
Программа может передавать информацию в функцию. Параметры функции перечисляются в круглых скобках после ее имени, причем для каждого параметра указывается его тип. Например:
f(int x, int y, float z); нельзя перечислять параметры одного типа через запятую.
Пример №2.
#include <iostream.h>
void show_number ( int a)
{
cout << ² значение параметра а= ² << endl;
}
void main(void)
{
show_number(1); show_number(1001); show_number(-500);
}
будет напечатано:
значение параметра а=1
значение параметра а=1001
значение параметра а= -500
Функция может возвращать результат. В этом случае необходимо указать тип результата, а для передачи результата в функции используется оператор return.Оператор return может иметь параметры или не иметь.
Если оператор return встретился в функции, это означает немедленный выход из функции и возврат в вызывающую программу. В теле функции может быть несколько операторов return, может быть ни одного.
Пример №3. Функция, которая возводит число а в натуральную степень b:
a × a × … × a
b раз
#include<iostream.h>
float step (float a, int b)
{
int i; float f=1;
for ( i=1; i<abs(b); i++) f*=a;
if (b>=0)return f;
else return (1/f);
}
void main () { cout <<”3.2^5=”<<step(3.2,5);}
В программе можно использовать возвращаемое функцией значение, запоминая его в переменной с помощью оператора присваивания:
rezult=step(3, 5);
Можно использовать вызов функции в операторе cout:
cout << «3^5=» << step(3, 5) << endl;
Программа может использовать функцию в условном операторе:
if ( max(a, b)<100) . . .
Можно в самом начале программы поместить прототип функции, а сама функция может быть задана в другом месте программы. Прототип указывает тип возвращаемого значения, имя функции, количество и тип каждого параметра. Чаще всего прототип совпадает с заголовком в описании функции. Прототип может выглядеть так: float func(int a, float b); или так:
float func(int, float);
Эти два объявления абсолютно равносильны.
Пример №4. Функция возведения в квадрат.
#include < iostream.h>
float sqr(float); // прототип функции
void main(void)
{
float b;
cout << ² введите число: ²
cin >> b;
cout << ² b^2= ² << sqr(b) << endl;
}
float sqr(float a); // описание функции
{
return a*a;
}
Область действий переменной.
Область действий – это правила, которые устанавливают, какие данные доступны из определенного места программы. С точки зрения области действия переменных различают три типа переменных: глобальные, локальные и формальные параметры (переменные).
Локальные переменные – это переменные, объявленные внутри блока, в частности внутри функции. Локальная переменная доступна внутри блока, в котором объявлена Блок открывается и закрывается с помощью фигурных скобок. Локальная переменная существует, пока выполняется блок, в котором она объявлена. При выходе из блока эта переменная и ее значение теряется.
Пример №5.
#include <iostream.h>
void func(void); //прототип функции
void main(void)
{
int i=1; //локальная переменная
func();
cout << ²В функции main значение i=² << i << endl;
}
void func(void)
{
int i=10; //локальная переменная
cout << ² в функции func значение i=² << i << endl;
}
Будет напечатано:
в функции func значение i=1
в функции main значение i=10
Формальные параметры – это переменные, объявленные при описании функции как ее аргументы. Функции могут иметь некоторое количество параметров, которые используются при вызове функций для передачи значений в тело функции. Формальные параметры могут использоваться в теле функции так же, как локальные переменные, которыми они по сути являются. Область действия формальных параметров – блок, являющийся телом функции. Существуют фактические параметры – это параметры, которые передаются в функцию при ее вызове.
Глобальные переменные – это переменные , объявленные вне какой-то функции.
В отличие от локальных переменных глобальные переменные могут быть использованы в любом месте программы, но перед их использованием они должны быть объявлены. Область действия глобальной переменной -вся программа. Имя локальной и глобальной переменной может совпадать, в этом случае приоритет предоставляется локальной переменной. В случае, если необходимо обратиться к глобальной переменной , чье имя совпадает с именем локальной переменной внутри функции, можно использовать глобальный оператор разрешения С++(::)
Пример №6.
#include <iostream. h>
int a=1001; // глобальная переменная а
void show(int a) // локальная переменная а
{
cout << ² локальная переменная а=² << a << endl;
cout << ² глобальная переменная а=² << ::a << endl;
}
void main(void)
{
int b=2002;
show(b);
}
результат:
локальная переменная а=2002
глобальная переменная а=1001
Модификаторы переменных.
В языке С имеется несколько модификаторов, которые изменяют область действия и время жизни переменных.
| Модификатор | применение | область действия | выделение памяти | объяснение |
| auto | локальная переменная | блок | временное | для локальных переменных применяется по умолчанию |
| register | локальная переменная | блок | временное | предполагается, что переменная располагается в машинном регистре |
| extern | блок | информирует компилятор, что переменная определяется в другом блоке | ||
| static | локальная переменная | блок | постоянное | область действия соответствует локальной переменной, а время жизни -глобальной |
| static | глобальная переменная | файл | постоянное | ограничивает область действия глобальной переменной текущим файлом |
Пример №7: определить, сколько целых чисел в интервале от 1 до 500 являются степенью цифры 3.
27=33, 81=34
#include <iostream.h>
#include <math.h>
int step3(int a)
{
if (pow(а, 1./3.)==int(pow(а, 1./3.))) return 1;
return 0;
}
void main ()
{ int i, kol=0;
for (i=1; i<=500; i++)
if (step3(i) != 0)
{cout << setw(5)<<i; kol++;}
cout << kol-1 << “чисел – степени тройки”;
}
Пример №8. Вычислить f(x,y)+f(x-y,x/y), где 
#include <iostream.h>
#include <math.h>
float f(float a, float b) //a, b формальные параметры
{
float f= fabs(a+b)/(a*b);return f; } // f локальный параметр
void main ()
{ float x, y, z; //x, y, z локальные параметры
cout << “введите два числа”;cin>>x>>y;
z=f(x,y)+f(x-y,x/y);
cout<<z;
}
аргумент измеряется в радианах
sin(x) – синус угла х,
cos(x) – косинус х
tan(x) – тангенс х
asin(x) – арксинус х
acos(x) – арккосинус х x от -pi/2 до pi/2
atan(x) –