Пусть функция DigitN(K,N) уже есть. тогда обращение к ней можно использовать там, где допустимы объекты целого типа (функция DigitN(K,N) целого типа. т.е. она возвращает значение целого типа, например, int)
можно так:
int i;
i= DigitN(34,4);
или так:
double b;
b= DigitN(34,4)/2+10;
или так:
cout << DigitN(25,1);
и т.д.
Напишем теперь программу, которая будет вызывать функцию DigitN пять раз, как требуется по условию задачи. Тело функции пока программировать не будем. Сделаем "заглушку". Такой подход даст нам возможность проверить, что функция вызывается, в нее передаются аргументы, и она возвращает значение в основную программу.
#include <iostream>
using namespace std;
int DigitN(int, int);
int main () {
int k1,k2,k3,k4,k5;
k1=342;
k2=7;
k3=57764;
k4=9872;
k5=22222;
cout << DigitN(k1,1) << endl;
cout << DigitN(k2,2) << endl;
cout << DigitN(k3,3) << endl;
cout << DigitN(k4,4) << endl;
cout << DigitN(k5,5) << endl;
return 0;
}
int DigitN(int k, int n){
cout << "Внутри DigitN: k = " << k << " n = " << n << endl;
return 0;
}
Теперь можно приступить к программированию функции. Разумеется, необходимо прежде составить алгоритм!
int DigitN(int k, int n){
int s;
for (int i=0; i<n; i++) {
if (k==0) return -1;
s=k%10;
k/=10;
}
return s;
}
Массивы
До сих пор мы составляли алгоритмы, в которых объем хранимой информации был невелик. Количество переменных, которые мы использовали, не превышало десятка. А как быть, если необходимо работать с сотней, тысячей чисел или значений другого типа.
Если с группой величин одинакового типа требуется выполнять однообразные действия, им дают одно имя, а различают по порядковому номеру (индексу). Это позволяет компактно записывать множество операций с помощью циклов.
Конечная именованная последовательность однотипных величин называется массивом.
Перед использованием массив необходимо объявить.
int a[25];
a – массив из 25 элементов типа int.
Как и в случае обычных переменных, объявление массива начинается с указания типа данных, после чего следует имя массива и пара квадратных скобок, заключающих константное выражение, которое определяет размер массива. Внутри квадратных скобок может стоять только константа, но не имя переменной, чтобы компилятор точно знал, какой объем памяти резервировать. Таким образом, размер массива должен быть известен заранее и не может быть изменен в ходе выполнения программы.
В С++ нумерация элементов массива начинается с нуля. Поэтому массив a состоит из элементов:
a[0], a[1], a[2], … ,a[24]
Объявляя массив, можно сразу его инициализировать (присвоить начальные значения его элементам).
double b[5]={3.0, 23.25, 4.3, 5, 12};
или так:
int c[]={23,3,14,5,12,1,2}; //массив из семи элементов
Но такой способ инициализации удобен только для небольших массивов. Большие массивы инициализируют в процессе выполнения программы — путем записи данных в массив.
Чтобы получить значение, хранящееся в простой переменной , достаточно обратиться к этой переменной по имени. Элементы массива отдельных имен не имеют. К ним обращаются, используя имя массива, после которого в квадратных скобках указывают индекс элемента.
Отдельные элементы массива m , объявленного как
T m[size]
могут использоваться там, где допустимо использование объектов типа T.
Например:
int a[5]={1,2,3,4,5};
int b;
a[0]=400;
b=a[3]+a[4]*5;
int i=4;
a[i]=100;
a[i-2]=200;
Если для всех элементов массива необходимо проделать однотипные действия, используют конструкцию цикла.
Ниже приведен пример заполнения массива квадратами целых чисел и вывода их на экран.
int m[25];
for (int i=0; i<25; i++){
m[i]=i*i;
}
for (int i=0; i<25; i++){
cout << m[i] << " ";
}
Если теперь нам понадобится изменить размерность массива с 25, скажем, на 50. Нам придется менять приведенную выше программу в трех местах.
Поэтому размерность массивов предпочтительнее задавать с помощью именованных констант, т.к. в случае необходимости изменения его размерности, количество изменений в программе сводится к минимуму
const int size_m = 25;
int m[size_m];
for (int i=0; i<size_m; i++){
m[i]=i*i;
}
for (int i=0; i<size_m; i++){
cout << m[i] << " ";
}
Важное замечание!
Компилятор С++ никак не контролирует ситуацию выхода за границы массива! Этот контроль возложен на программиста!
Следующий фрагмент программы ошибки компилятора не вызовет:
int m[5];
for (int i=0; i<10; i++){
m[i]=i*i;
}
for (int i=0; i<10; i++){
cout << m[i] << " ";
}
Но вывод программы будет некорректен. А при ее выполнении могут быть непроизвольно изменены значения других переменных, и выполнение программы может завершиться крахом из-за того, что в ней есть обращения за пределы массива
